Dotnet Training in BTM Layout - Bangalore

Best Dotnet Training in BTM Layout with Placement Assistance


Dotnet Training

TecMax is one of the leading Dotnet Training Institute in Bangalore. Certified experts at TecMax are real-time consultants at multinational companies and have more than 5+ years of experience in Dotnet Training. Our Trainers have conducted more than 200 classes and have extensive experience in teaching Dotnet in most simple manner for the benefit of sudents.

We have advanced lab facilities for students to practice Dotnet course and get hands-on experience in every topics that are covered under Dotnet Training. In the presence of Dotnet Trainer, students can execute all the techniques that has been explained by the instructor. Course Material for Dotnet is specifically designed to cover all the advanced topics and each of the module will have both theory and practical classes. Dotnet Batch Timings at TecMax are flexible and students can choose to join the batch as per their requirements. We have a batch starting every week for Dotnet for regular students. Weekend batches and fast track batches for Dotnet training can be arranged based on the requirement. 

All our students will get placement assistance in Dotnet after successfully completing the Dotnet training from our institute. We are committed to provide high-quality training and provide assistance to get you the right job.


Dotnet Training Course Content

Dotnet Course Content

The .NET Framework

What is the .NET Framework?
Common Language Runtime
.NET Framework Class Library
Assemblies and the Microsoft Intermediate Language (MSIL)
Versions of the .NET Framework and Visual Studio

Getting Started with Visual Studio

Visual Studio Overview
Choosing the Development Settings
Resetting the Development Settings
Creating a New Project
Components of the IDE
Code and Text Editor
Code Snippets
IntelliSense
Refactoring Support
Debugging
Setting Breakpoints
Stepping through the Code
Watching
Autos and Immediate Windows
Unit Testing
Creating the Test
Running the Test
Testing with Floating Point Numbers
Adding Additional Test Methods

C# Language Foundations

Using the C# Compiler (csc.exe)
Passing Arguments to Main()
Language Syntax
Keywords
Variables
Scope of Variables
Constants
Comments
Data Types
Value Types
Reference Types
Enumerations
Implicit Typing
Type Conversion
Operators
Arithmetic Operators
Logical Operators
Relational Operators
Increment & Decrement Operators
Bit Shift Operators
Assignment Operators
The is and as Operators
Other Operators
Operator Precedence
Flow Control
if-else Statement
switch Statement
Looping
for Loop
foreach
while and do-while Loops
Exiting from a Loop
Skipping an Iteration
Structs
What Are Structs?
Structs Are Value Types
Assigning to a Struct
Constructors and Destructors
Instance Constructors
Static Constructors
Summary of Constructors and Destructors
Field Initializers Are Not Allowed
Structs Are Sealed
Boxing and Unboxing
Structs as Return Values and Parameters

Arrays

Single Dimensional Arrays
Accessing Array Elements
Multidimensional Arrays
Arrays of Arrays: Jagged Arrays
Parameter Arrays
Copying Arrays

Strings and Regular Expressions

The System.String Class
Escape Characters
String Manipulations
String Formatting
The StringBuilder Class
Regular Expressions
Searching for a Match
More Complex Pattern Matching

OOPs Concepts

Classes
Defining a Class
Creating an Instance of a Class (Object Instantiation)
Class Members
Access Modifiers
Function Members
Overloading Methods
Overloading Operators
Using Partial Classes
Static Classes
System.Object Class
Implementing Equals
ToString() Method
Attributes
Inheritance
Understanding Inheritance
Implementation Inheritance
Inheritance and Constructors
Calling Base Class Constructors
Virtual Methods (Polymorphism)
Sealed Classes and Methods
Abstract Class
Abstract Methods
Interfaces
Defining an Interface
Implementing an Interface
Implementing Multiple Interfaces
Interface Inheritance
Overriding Interface Implementations

Collections Interfaces

Dynamic Arrays Using the ArrayList Class
Stacks
Queues
Dictionary
Indexers and Iterators
Implementing IEnumerable and IEnumerator
Implementing Comparison Using IComparer and IComparable

Delegates and Events

Delegates
Creating a Delegate
Delegates Chaining (Multicast Delegates)
Implementing Callbacks Using Delegates
Asynchronous Callbacks
Events
Handling Events
Implementing Events
Difference between Events and Delegates
Passing State Information to an Event Handler

Generics

Understanding Generics
Generic Classes
Using the default Keyword in Generics
Advantages of Generics
Using Constraints in a Generic Type
Generic Interfaces
Generic Methods
Generic Operators
Generic Delegates
Generics and the .NET Framework Class Library
System.Collections.ObjectModel

Exception Handling

Handling Exceptions
Handling Exceptions Using the try-catch Statement
Handling Multiple Exceptions
Throwing Exceptions Using the throw Statement
Using Exception Objects
The finally Statement
Creating Custom Exceptions

Threading

Processes, AppDomains, and Object Contexts
Reviewing Traditional Win32 Processes
Interacting with Processes Under the .NET Platform
Understanding .NET Application Domains
Understanding Object Context Boundaries
Threading
The Need for Multithreading
Starting a Thread
Aborting a Thread
Passing Parameters to Threads
Thread Synchronization
Using Interlocked Class
Using C# Lock
Monitor Class
Using the BackgroundWorker Control
Testing the Application

Files and Streams

Working with Files and Directories
Working with Directories
Working with Files Using the File and File Info Classes
Creating a File Explorer
The Stream Class
Buffered Stream
The File Stream Class
Memory Stream

Working with XML

Introduction to XML
Markup
The Document Type Declaration (DTD)
Encoding Declaration
Writing XML Code using Code Editor
XML Syntax
XML Reading & Writing
Text Writer Fundamentals
Text Reader Fundamentals
XMLDocument
Serialization
Binary Serialization
XML Serialization

Assemblies and Versioning

Assemblies
Structure of an Assembly
Examining the Content of an Assembly
Single and Multi-File Assemblies
Understanding Namespaces and Assemblies
Private versus Shared Assemblies
Creating a Shared Assembly
The Global Assembly Cache
Putting the Shared Assembly into GAC
Making the Shared Assembly Visible in Visual Studio
Using the Shared Assembly

Type Reflection, Late Binding, and Attribute-Based

Programming
The Necessity of Type Metadata
Understanding Reflection
Understanding Late Binding
Building a Custom Metadata Viewer
Dynamically Loading Assemblies
Reflecting on Shared Assemblies
Understanding Attributed
Assembly-Level (and Module-Level) Attributes
Reflecting on Attributes Using Early Binding
Reflecting on Attributes Using Late Binding
Putting Reflection, Late Binding, and Custom Attributes in Perspective

ADO.NET

ADO .NET Introduction
ADO vs. ADO .NET
ADO .NET Architecture
Connecting to Data Sources
Choosing a .Net Data Provider
Defining a Connection
Managing a Connection
Handling Connection Exceptions
Connection Pooling
Performing Connected Database Operations
Working in a Connected Environment
Building Command Objects
Executing the Commands
Data Reader Object
Using Transactions
Performing Dis-Connected Database Operations
Configuring a DataAdapter to Retrieve Information
Populating a DataSet Using a DataAdapter
Modifying Data in a DataTable
Persisting Changes to a Data Source
Working in a Disconnected Environment
Building Datasets and DataTables
Binding and Saving a Dataset
Defining Data Relationships
Reading and Writing XML with ADO.NET
Creating XSD Schemas
Loading Schemas and Data into DataSets
Writing XML from a DataSet

ASP.NET

ASP.NET Introduction
The Evolution of Web Development
HTML and HTML Forms
Server-Side Programming
Client-Side Programming
Facts about ASP .NET
ASP .NET different versions
Developing ASP.NET Applications
Creating Websites
Creating a New Web Application
Websites and Web Projects
The Hidden Solution Files
The Solution Explorer
Adding Web Forms
Migrating a Website from a Previous Version of Visual Studio
Designing a Web Page
Adding Web Controls
The Properties Window
The Anatomy of a Web Form
The Web Form Markup
The Page Directive
The Doctype
Writing Code
The Code-Behind Class
Adding Event Handlers
IntelliSense and Outlining
Visual Studio Debugging
The Visual Studio Web Server
Single-Step Debugging
Variable Watches

Creating N-Tier Applications

Multi-Tier Architectures
Creating an N-Tier ASP.NET Application
The Data Tier
The Middle Tier
The Presentation Tier
Managing Concurrency

Web Form Fundamentals

The Anatomy of an ASP.NET Application
ASP.NET File Types
ASP.NET Application Directories
Introducing Server Controls
HTML Server Controls
Converting an HTML Page to an ASP.NET Page
A Deeper Look at HTML Control Classes
HTML Control Events
Advanced Events with the HtmlInputImage Control
The HtmlControl Base Class
The HtmlContainerControl Class
The HtmlInputControl Class
The Page Class
Sending the User to a New Page
HTML Encoding
Application Events
The Global.asax File
Additional Application Events
ASP.NET Configuration
The web.config File
Nested Configuration
Storing Custom Settings on the web.config File
The Website Administration Tool (WAT)

Web Controls

Stepping Up Web Controls
Basic Web Control Classes
The Web Control Tags
Web Control Classes
The WebControl Base Class
Units
Enumerations
Colors
Fonts
Focus
The Default Button
List Controls
Multiple-Select List Controls
The BulletedList Control
Table Controls
Web Control Events and AutoPostBack
How Postback Events Work
The Page Life Cycle
A Simple Web Page
Improving the Greeting Card Generator
Generating the Cards Automatically

Validation

Understanding Validation
The Validator Controls
Server-Side Validation
Client-Side Validation
The Validation Controls
A Simple Validation Example
Other Display Options
Manual Validation
Validating with Regular Expressions
A Validated Customer Form
Validation Groups

The Data Controls

The GridView
Automatically Generating Columns
Defining Columns
Formatting the GridView
Formatting Fields
Using Styles
Formatting-Specific Values
Selecting a GridView Row
Adding a Select Button
Editing with the GridView
Sorting and Paging the GridView
Sorting
Paging
Using GridView Templates
Using Multiple Templates
Editing Templates in Visual Studio
Handling Events in a Template
Editing with a Template
The DetailsView and FormView
The DetailsView
The FormView

Rich Controls

The Calendar
Formatting the Calendar
Restricting Dates
The AdRotator
The Advertisement File
The AdRotator Class
Pages with Multiple Views
The MultiView Control
The Wizard Control

Files and Streams

Files and Web Applications
File System Information
The Path Class
A Sample File Browser
Reading and Writing with Streams
Text Files
Binary Files
Shortcuts for Reading and Writing Files
A Simple Guest Book
Allowing File Uploads
The FileUpload Control

State Management

The Problem of State
View State
The ViewState Collection
A View State Example
Making View State Secure
Retaining Member Variables
Storing Custom Objects
Transferring Information between Pages
Cross-Page Posting
The Query String
Cookies
A Cookie Example
Session State
Session Tracking
Using Session State
A Session State Example
Session State Configuration
Cookieless
Timeout
Mode
Application State
An Overview of State Management Choices

Error Handling, Logging, and Tracing

Common Errors
Exception Handling
The Exception Class
The Exception Chain
Handling Exceptions
Catching Specific Exceptions
Nested Exception Handlers
Exception Handling in Action
Mastering Exceptions
Throwing Your Own Exceptions
Logging Exceptions
Viewing the Windows Event Logs
Writing to the Event Log
Custom Logs
A Custom Logging Class
Retrieving Log Information
Error Pages
Error Modes
Custom Error Pages
Page Tracing
Enabling Tracing
Tracing Information
Writing Trace Information
Application-Level Tracing

Deploying ASP.NET Applications

ASP.NET Applications and the Web Server
How Web Servers Work
The Virtual Directory
Web Application URLs
Web Farms
Internet Information Services (IIS)
The Many Faces of IIS
Installing IIS 5 (in Windows XP)
Installing IIS 7 (in Windows Vista)
Registering the ASP.NET File Mappings
Verifying That ASP.NET Is Correctly Installed
Managing Websites with IIS Manager
Creating a Virtual Directory
Configuring a Virtual Directory
Deploying a Simple Site
Web Applications and Components
Other Configuration Steps
Code Compilation
The ASP.NET Account
Deploying with Visual Studio
Creating a Virtual Directory for a New Project
Copying a Website
Publishing a Website

User Controls and Graphics

User Controls
Creating a Simple User Control
Independent User Controls
Integrated User Controls
User Control Events
Passing Information with Events
Dynamic Graphics
Basic Drawing
Drawing a Custom Image
Placing Custom Images Inside Web Pages
Image Format and Quality

Caching

Understanding Caching
When to Use Caching
Caching in ASP.NET
Output Caching
Caching on the C



Quick Enquiry


Dotnet Reviews

Tecmax

4.9 out of 5
based on
2137 ratings.


TECMAX © 2017 - 18 | All Rights Reserved
i