Mastering Dot Net Training Detailed Course Contents

Summary of Dot Net Training Classes

  • Total Microsoft C# Training Classes
  • Total Microsoft ASP.NET Training Classes

Currently all our Dot Net Training classes are conducted in Chennai, India.

In our Mastering Dot Net Training, We’ll provide complete coverage of critical Dot Net architecture and design issues, teaching students best not only practices, but also key mistakes to avoid.

    • Total Hours:300
    • Location: Chennai, India

    •
    • Course Contents
    • Duration in Hours
    • C# Language
    • 110 Hours
    • Introduction to Dot Net
    • 2 Hours
    • .Net Framework Architecture
    • Compiling Source Code
    •  
    • Program Execution
    • The Overall Process
    •  
    • Common Language Runtime (CLR)
    • Common Language Infrastructure (CLI)
    •  
    • Common Type System (CTS)
    • Common Language Specification (CLS)
    •  
    • Intermediate Language (IL)
    • Base Class Library (BCL)
    •  
    • .Net Framework Features
    • The C# Language
    •  
    • Evolution of C#
    • Summary
    •  
    • Lab Activities
    • Introduction to WWW
    • 2 Hours
    • What is Internet?
    •  
    • World Wide Web (WWW)
    •  
    • What is URL?
    •  
    • URI Vs URL Vs URN
    •  
    • Internet Protocol
    •  
    • HTTP
    •  
    • Important Internet Glossaries
    •  
    • Summary
    •  
    • Lab Activities
    • C-Sharp Language Fundamentals
    • 2 Hours
    • My First Program
    •  
    • Develop, Compile & Execute C# Program
    •  
    • Console Output
    •  
    • Console Input
    •  
    • Statement
    •  
    • Various Main Methods
    •  
    • Block
    •  
    • Comments
    •  
    • Keywords
    •  
    • Whitespaces
    •  
    • Summary
    •  
    • Lab Activities
    • Variables & Data Types
    • 3 Hours
    • Variables
    •  
    • Programming Language Classification – Based on Data Types
    •  
    • C# Data Types Groups & Categories
    •  
    • Integers Primitive Value Data Types
    •  
    • Integer Representation
    •  
    • Literals
    •  
    • Integer Literals
    •  
    • Char Data Type
    •  
    • C# Valid Identifiers
    •  
    • Floating Point Types
    •  
    • Float Data Type
    •  
    • Double Data Type
    •  
    • Decimal Data Type
    •  
    • Floating Point Special Values
    •  
    • Real Literals
    •  
    • bool Data Type
    •  
    • Local Variable & Its Scope
    •  
    • Summary
    •  
    • Lab Activities
    • Expressions & Operators
    • 3 Hours
    • Expressions & Operators
    •  
    • C# Operators
    •  
    • Assignment Operators
    •  
    • Arithmetic Operators
    •  
    • Binary Arithmetic Operators
    •  
    • Relational Operators
    •  
    • Numeric Comparison
    •  
    • Conditional Logical Operators
    •  
    • Bitwise Operators
    •  
    • Increment & Decrement Operators
    •  
    • Compound Assignment Operators
    •  
    • Conditional Operators
    •  
    • Order of Operator Precedence
    •  
    • Summary
    •  
    • Lab Activities
    • Control Structures
    • 3 Hours
    • Empty Statement
    •  
    • Control Structures
    •  
    • Sequence Structures
    •  
    • Selection Structures
    •  
    • If Selection Structures
    •  
    • Switch Selection Structures
    •  
    • Repetition Structures
    •  
    • While Statement
    •  
    • Do – While Statement
    •  
    • For Statement
    •  
    • Foreach Statement
    •  
    • continue Statement
    •  
    • break Statement
    •  
    • goto Statement
    •  
    • Summary
    •  
    • Lab Activities
    • Implicit & Explicit Primitive type Conversion
    • 2 Hours
    • Conversion Fundamentals
    •  
    • Implicit Conversions
    •  
    • Implicit Identity Conversion
    •  
    • Implicit Numeric Conversion
    •  
    • Implicit Constant Expression Conversion
    •  
    • Explicit Conversions
    •  
    • Explicit Numeric Conversions
    •  
    • Summary
    •  
    • Lab Activities
    • OOP in C#
    • 10 Hours
    • What is OOP?
    •  
    • Class
    •  
    • Instance Variables
    •  
    • Member Instance Variables Initializers
    •  
    • Instance Methods
    •  
    • Constructors
    •  
    • This Keyword
    •  
    • Value & Reference Variables and Assignment
    •  
    • Argument Passing
    •  
    • Value Type Vs Reference Data Type
    •  
    • Ref Keyword
    •  
    • Out Keyword
    •  
    • Return Objects
    •  
    • What is Polymorphism?
    •  
    • Method Overloading
    •  
    • Constructor Overloading
    •  
    • Object Initializers
    •  
    • Optional Arguments
    •  
    • Named Arguments
    •  
    • Inheritance
    •  
    • Types of Inheritance
    •  
    • Inheritance in C#
    •  
    • Base Keyword
    •  
    • Upcasting & Downcasting
    •  
    • Method Overriding
    •  
    • Virtual Methods
    •  
    • Constant
    •  
    • Readonly Modifier
    •  
    • Encapsulation
    •  
    • Accessibility
    •  
    • Static Modifier
    •  
    • Sealed Modifier
    •  
    • Nested Class
    •  
    • Recursion
    •  
    • Destructors
    •  
    • Lab Activities
    • Abstract Classes & Interfaces
    • 3 Hours
    • Abstract Class
    •  
    • Abstract Member
    •  
    • Abstract Nested Class
    •  
    • Important Points on Abstract Class & Method
    •  
    • Interface
    •  
    • Declaration & Implementation of Interfaces
    •  
    • Implicit Interface Implementation
    •  
    • Explicit Interface Implementation
    •  
    • Implementing More than One Interface
    •  
    • Multiple Interfaces Implementation – Name Conflict
    •  
    • Interface Inheritance
    •  
    • Single Interface Inheritance – Name Conflict
    •  
    • Multiple Interface Inheritance – Name Conflict
    •  
    • Interface Implements in Abstract Class
    •  
    • Interfaces vs Abstract Classes
    •  
    • Interfaces As Parameter
    •  
    • Interfaces As Return Datatype
    •  
    • The is Operator
    •  
    • The as Operator
    •  
    • Interfaces Within a Class
    •  
    • Types of Inheritance
    •  
    • Important Points on Interfaces
    •  
    • Lab Activities
    • Structures
    • 3 Hours
    • Quick Recall on Value Type & Reference Type
    •  
    • Structure
    •  
    • Constructors & Destructors
    •  
    • Structure Object Creation
    •  
    • Structure Assignment & Argument Passing
    •  
    • Structure & Inheritance & Polymorphism
    •  
    • Ref & Out Keyword
    •  
    • Structure & Encapsulation
    •  
    • static Modifier
    •  
    • Nested Structure
    •  
    • Lab Activities
    • Arrays
    • 3 Hours
    • About Arrays
    •  
    • Single Dimension Arrays
    •  
    • Multi Dimensional Rectangular Arrays
    •  
    • Multi Dimensional Jagged or Ragged Arrays
    •  
    • Array Immutability
    •  
    • Array References
    •  
    • Array length Property
    •  
    • Implicit Types Arrays
    •  
    • Parameter Arrays
    •  
    • Lab Activities
    • Properties
    • 3 Hours
    • What is Properties?
    •  
    • Properties Declaration
    •  
    • Internal Implementation of Properties
    •  
    • Read-only & Write-Only Properties
    •  
    • Automatic Implemented Properties
    •  
    • Auto-Implemented Properties Default Values
    •  
    • Properties Initialization
    •  
    • Static Properties
    •  
    • Access Modifiers With Properties
    •  
    • Properties & Inheritance
    •  
    • Abstract Properties
    •  
    • Implicit Implementation
    •  
    • Explicit Implementation
    •  
    • Property Name Hidng
    •  
    • In the Interface Implemented Class
    •  
    • Lab Activities
    • Indexers
    • 3 Hours
    • What is Indexer?
    •  
    • Indexer Declaration
    •  
    • Simple Indexer Program
    •  
    • Read-only & Write-only Indexers
    •  
    • Indexing Data using Different Data Type other than Integer
    •  
    • Overloaded Indexers
    •  
    • Multi Dimension Indexers
    •  
    • Indexer Without Underlying Data Store
    •  
    • Inheritance of Indexers
    •  
    • Abstract Indexers
    •  
    • Implicit Implementation
    •  
    • Explicit Implementation
    •  
    • Indexer Hiding
    •  
    • In the Interface Implemented Class
    •  
    • Indexer Restrictions
    •  
    • Indexer Vs Properties & Indexers Vs Arrays
    •  
    • Lab Activities
    • Operator Overloading
    • 3 Hours
    • Operator Overloading Overview
    •  
    • Operator Overloading Definition
    •  
    • First Unary Operator Overloading
    •  
    • Unary Operator Overloading
    •  
    • First Binary Operator Overloading
    •  
    • Relational Operator Overloading
    •  
    • Logical Operator Overloading
    •  
    • Short circuit && and || Operator Overloading
    •  
    • Bitwise Operator Overloading
    •  
    • Internal Implementation of Overloaded Operators
    •  
    • User Defined Conversion
    •  
    • Lab Activities
    • Delegates & Events
    • 4 Hours
    • Overview of Delegates
    •  
    • Delegate Declaration
    •  
    • Assigning Delegate
    •  
    • Multicasting
    •  
    • Delegates with Return Values
    •  
    • Important Points on Delegate
    •  
    • Event Overview
    •  
    • Publishing an Event
    •  
    • Subscribing an Event
    •  
    • Raising an Event
    •  
    • Event – A Complete Example
    •  
    • Events with static Keyword
    •  
    • Multicast Events
    •  
    • Covariance & Contravariance
    •  
    • Lab Activities
    • Anonymous Methods & Lambda Expressions
    • 3 Hours
    • Anonymous Functions
    •  
    • Overview of Anonymous Method
    •  
    • Anonymous Method Declaration
    •  
    • Anonymous Method Return Type
    •  
    • Pass Argument to an Anonymous Method
    •  
    • Scope of Various Variables & Parameters
    •  
    • Captured Variables Side Effect
    •  
    • Important points on Anonymous Method
    •  
    • Overview of Lambda Expressions
    •  
    • Expression Lambda
    •  
    • Statement Lambda
    •  
    • Important points of Lambda Expressions
    •  
    • Namespaces
    • 3 Hour
    • Compilation Unit & Assembly
    •  
    • Namespace
    •  
    • Namespace Declaration
    •  
    • Nested Namespace
    •  
    • using Keyword
    •  
    • Namespace Aliases
    •  
    • Namespaces are Additive
    •  
    • Namespace Alias Qualifier
    •  
    • Lab Activities
    • Enums & Preprocessors
    • 2 Hours
    • Enum Overview
    •  
    • Enum Declaration
    •  
    • Conversion
    •  
    • Specify the Underlying Type & Explicit Values
    •  
    • Important points on Enum
    •  
    • Preprocessor Overview
    •  
    • #define and #undef Directives
    •  
    • Conditional Compilation
    •  
    • #region & #endregion Preprocessor
    •  
    • Diagnostic Directives
    •  
    • #line directive
    •  
    • #pragma Directive
    •  
    • Lab Activities
    • System Namespace
    • 6 Hours
    • System Namespace
    •  
    • Object
    •  
    • Array Class
    •  
    • Convert Class
    •  
    • Math Class
    •  
    • Random Class
    •  
    • Console Class
    •  
    • ValueType class
    •  
    • Boolean Structure
    •  
    • Byte Structure
    •  
    • SByte Structure
    •  
    • Other .Net Structure to the Primitive Value Data Types
    •  
    • Char
    •  
    • Single Structure
    •  
    • Double Structure
    •  
    • Decimal
    •  
    • DateTime Structure
    •  
    • DateTimeOffset
    •  
    • TimeSpan Structure
    •  
    • Boxing & Unboxing
    •  
    • String
    •  
    • StringBuilder Class
    •  
    • IComparable interface
    •  
    • Lab Activities
    • Formatting
    • 3 Hours
    • Formatting Fundamentals
    •  
    • Creating Formatted String
    •  
    • Standard Number Formatting
    •  
    • Custom Number Formatting
    •  
    • Standard Date & Time Formatting
    •  
    • Custom Date & Time Formatting
    •  
    • Standard TimeSpan Formatting
    •  
    • Custom TimeSpan Formatting
    •  
    • Enumeration Formatting
    •  
    • Lab Activities
    • Exception Handling
    • 3 Hours
    • Errors & its Types
    •  
    • Getting Started with Exception
    •  
    • Try-catch Block
    •  
    • Multiple Catch
    •  
    • Nested try-catch Blocks
    •  
    • Finally Block
    •  
    • Throw Statement
    •  
    • Exception Class
    •  
    • User Defined Exceptions
    •  
    • Commonly Used Pre-build Exceptions
    •  
    • Checked & Unchecked Exception
    •  
    • Catching Derived Class Exceptions
    •  
    • Unreachable Code
    •  
    • Lab Activities
    • Collections
    • 8 Hours
    • Getting Started with Collections
    •  
    • System.Collection Namespace
    •  
    • IEnumerator Interface
    •  
    • IEnumerable Interface
    •  
    • ICollection Interface
    •  
    • IList
    •  
    • ArrayList
    •  
    • Stack Class
    •  
    • Queue Class
    •  
    • CollectionBase Class
    •  
    • ReadOnlyCollectionBase Class
    •  
    • IDictionary Interface
    •  
    • IComparer Interface & Comparer, CaseInsensitiveComparer
    •  
    • IEqualityComparer Interface
    •  
    • StructuralComparisons Class
    •  
    • DictionaryEntry Structure
    •  
    • IDictionaryEnumerator
    •  
    • Hashtable
    •  
    • SortedList Class
    •  
    • DictionaryBase Class
    •  
    • Structural Comparisons
    •  
    • Lab Activities
    • Generics
    • 5 Hours
    • Generics Fundamentals
    •  
    • Generic Class
    •  
    • Constructed Type
    •  
    • Constrained Type
    •  
    • Base Class Constraints
    •  
    • Interface Constraints
    •  
    • Reference Type & Value Type Constraints
    •  
    • Constructor Constraints
    •  
    • Default Values for the Type Parameter
    •  
    • Generic Methods
    •  
    • Generic Structures
    •  
    • Generic Delegates
    •  
    • Generic Interfaces
    •  
    • Generic Method Overloading
    •  
    • Inheritance in Generic Classes
    •  
    • Covariance in Generics
    •  
    • Contravariance in Generics
    •  
    • Lab Activities
    • Generic Collections
    • 8 Hours
    • System.Collection.Generic
    •  
    • IEnumerator<T> Interface
    •  
    • IEnumerable<T> Interface
    •  
    • ICollection<T> Interface
    •  
    • IList<T> Interface
    •  
    • List<T> Class
    •  
    • LinkedListNode<T>
    •  
    • LinkedList<T>
    •  
    • Stack<T> Class
    •  
    • Queue<T> Class
    •  
    • ISet<T> Interface
    •  
    • HashSet<T>
    •  
    • SortedSet<T>
    •  
    • IDictionary<TKey, TValue> Interface
    •  
    • Dictionary<TKey, TValue> Class
    •  
    • Dictionary<TKey, TValue>.KeyCollection Class
    •  
    • Dictionary<TKey, TValue>.ValueCollection
    •  
    • SortedList<TKey, TValue>
    •  
    • KeyValuePair<TKey, TValue> Structure
    •  
    • SortedDictionary<TKey, TValue> Class
    •  
    • SortedDictionary<TKey, TValue>.KeyCollection
    •  
    • SortedDictionary<TKey, TValue>.ValueCollection Class
    •  
    • IComparer<T> & Comparer<T>
    •  
    • IEqualityComparer<T> & EqualityComparer<T>
    •  
    • IReadOnlyCollection<T> Interface
    •  
    • IReadOnlyDictionary<TKey, TValue>
    •  
    • IReadOnlyList<T>
    •  
    • Lab Activities
    • Specialized Collections
    • 3 Hours
    • System.Collections.Specialized Namespace
    •  
    • CollectionsUtil
    •  
    • HybridDictionary
    •  
    • ListDictionary
    •  
    • NameObjectCollectionBase.KeysCollection
    •  
    • NameObjectCollectionBase
    •  
    • NameValueCollection
    •  
    • IOrderedDictionary
    •  
    • OrderedDictionary
    •  
    • StringCollection
    •  
    • StringDictionary
    •  
    • StringEnumerator
    •  
    • Lab Activities
    • Threading
    • 5 Hours
    • Introduction To Threading
    •  
    • Thread Delegates
    •  
    • Thread Class
    •  
    • Synchronization
    •  
    • Monitor Class
    •  
    • Inter Thread Communication
    •  
    • Deadlock & Race Condition
    •  
    • Using MethodImplAttribute
    •  
    • Mutex Class
    •  
    • Semaphore Class
    •  
    • Interlocked Class
    •  
    • ThreadPool Class
    •  
    • Timer Class
    •  
    • Lab Activities
    • Asynchronous Programming
    • 4 Hours
    • Coming Soon
    •  
    • Coming Soon
    •  
    • Coming Soon
    •  
    • Coming Soon
    •  
    • Coming Soon
    •  
    • Coming Soon
    •  
    • Coming Soon
    •  
    • Coming Soon
    •  
    • System.IO
    • 5 Hours
    • System.IO Namespace
    •  
    • DriveInfo Class
    •  
    • Directory Class
    •  
    • File
    •  
    • FileSystemInfo Class
    •  
    • DirectoryInfo Class
    •  
    • FileInfo Class
    •  
    • Stream
    •  
    • FileStream Class
    •  
    • BufferedStream Class
    •  
    • MemoryStream Class
    •  
    • BinaryReader Class
    •  
    • BinaryWriter Class
    •  
    • TextWriter Class
    •  
    • StreamWriter
    •  
    • StringWriter
    •  
    • TextReader
    •  
    • StreamReader
    •  
    • StringReader
    •  
    • IOExceptions
    •  
    • Serialization & Deserialization
    •  
    • Lab Activities
    • Implicit & Explicit Type Casting
    • 3 Hours
    • Implicit Enumeration Conversion
    •  
    • Implicit Null Literal Conversion
    •  
    • Implicit Nullable Conversions
    •  
    • Implicit Reference Conversions
    •  
    • Implicit Boxing Conversion
    •  
    • User Defined Implicit Conversions
    •  
    • Implicit Anonymous Method & Method Group Conversions
    •  
    • Explicit Enumeration Conversion
    •  
    • Explicit Nullable Conversions
    •  
    • Explicit Reference Conversions
    •  
    • Explicit Unboxing Conversion
    •  
    • Explicit Dynamic Conversion
    •  
    • User Defined Explicit Conversions
    •  
    • Lab Activities
    • HTML
    • 6 Hours
    • Coming Soon
    •  
    • CSS
    • 4 Hours
    • Coming Soon
    •  
    • SQL Server
    • 20 Hours
    • Coming Soon
    •  
    • XML
    • 10 Hours
    • Coming Soon
    •  
    • ASP.NET
    • 150 Hours
    • Coming Soon
    •  
Quick Enquiry
Name
Email ID
Phone
Addl Info
Course We Offer
Student Login
User Name
Password

Newsletter Sign Up
Email ID

Call Now   91-44
428-50005