Dot Net Module


  • The .NET Framework - an Overview
  • Architecture of .NET Framework
  • Types of Applications which can be developed using MS.NET
  •  MSIL / Metadata and PE files.
  • The Common Language Runtime (CLR)
  • Common Type System (CTS)
  • Common Language Specification (CLS)
  • Types of JIT Compilers
  • Security Manager
  • MS.NET Memory Management / Garbage Collection
  • MS.NET Base Classes Framework
  • MS.NET Assemblies and Modules


  • Developing Console Application
  • Entry point method - Main.
  • Command Line Parameters
  • Compiling and Building Projects
  • Language Basics
  • Variables and Data Types
  • String &StringBuilder.
  • Boxing and Unboxing
  • Operators
  • Statements
  • Arrays and Strings
  • Procedures and Functions
  • Essentials of Object-Oriented Programming
  • Object and Class Definition
  • Understanding Identity, State, and Behavior
  • Using encapsulation to combine methods and data in a
  • Single class
  • Inheritance and Polymorphism.
  • Working with Classes and Objects
  • Adding Variables and Methods
  • Properties and Indexers
  • Constructors and Destructors

Type Initialize

  • Extension Methods
  • Anonymous Types
  • Memory Management and Garbage Collection
  • Shared / Static Members
  • Method Overloading
  • Anonymous Methods
  • Partial Classes & Methods
  • Operator Overloading
  • Inner Classes
  • Attributes and their Usage
  • Inheritance, Interface and Polymorphism
  • Deriving classes
  • Calling base class constructor
  • Overriding Methods
  • Non-Inheritable Classes.
  • Abstract Class
  • Interface Inheritance
  • Namespace and Access Modifiers


  • Working With Collections
  • List and Dictionary
  • ArrayList and HashTable
  • Generic Classes & Methods
  • List and Dictionary
  • IEnumerable and IEnumerator
  • Exception Handling
  • Handling Exceptions using try and catch
  • Raising Exceptions using throw
  • Pre-defined Exception classes
  • Custom Exception classes
  • Using Statement
  • Inheritance, Interface and Polymorphism
  • Deriving classes
  • Calling base class constructor
  • Overriding Methods
  • Non-Inheritable Classes.
  • Abstract Class
  • C# Features / General Features
  • Unsafe Code
  • Fixed Keyword.
  • Operator Overloading.
  • Reflection
  • P-Invoke
  • Data Streams and Files
  • Byte Streams
  • Readers and Writers.
  • Binary Streams
  • Console and File I/O
  • Serialization & Deserialization
  • Working with Components / Assemblies
  • Creating a Simple .NET Framework Component
  • Private and Shared Assemblies
  • Singing Assemblies for Strong Names
  • Deploying .NET Assemblies in Global
  • Assembly Cache
  • Multithreading


  • Application Domains
  • Creating and Managing Threads
  • Thread Priority
  • Thread States
  • Thread Synchronization using Monitor and
  • Mutex
  • Data Access using ADO.NET
  • Introduction to ADO.NET
  • Managed Providers
  • Working with Connection, Command,
  • DataReader and Transaction objects
  • Working with Prepared Statements and Stored
  • Procedures.
  • Connection Pooling and Multiple Active Result Sets
  • Working with DataSet
  • Adding, Deleting and Modifying records in a Dataset
  • Data Tables, Data Columns and DataRows ,
  • Constraints and DataRelations
  • Using DataView
  • Wording with DataGridView.


  • Controls
  • Menus and Conext Menus
  • MenuStrip, ToolbarStrip.
  • Graphics and GDI
  • SDI and MDI Applications
  • Dialogbox (Modal and Modeless)
  • Form Inheritance
  • Working with Resource Files
  • Working with Settings
  • Other Misc topics.


XMLDocument, XMLElement, XMLAttribute
Interoperating with DataSet
XML TextReader / XML TextWriter

Windows Services

  • Purpose and Advantage
  • Developing and Deploying
  • Debugging Widows Service
  • Sending Custom events
  • Packaging and Deployment
  • Compiled Deployment of ASP.NET application.
  • Types of Deployment Modules
  • Working with a Setup and Web Setup Project
  • Working with a Merge Module Project
  • Debugging and Tracing
  • Debug and Release Compilation
  • Debug and Trace Objects
  • Tracing Switches & Listeners
  • Debugging JavaScript from VS.NET
  • Debugging SQL-Server Stored Procedures.
  • Developing N-Tier Architecture Application Using
  • SQLHelper, DAO, Business Object, Data Objects and
  • Presentation Tier


  • Basic of HTML and JavaScript
  • Introduction to ASP
  • ASP Architecture
  • ASP Objects
  • Request and Response Structure
  • Forms and Querystring
  •  Overview
  • ASP.NET Architecture
  • Virtual WebServer
  • New Features over ASP and ASP.NET 1.1
  • Event Handling

Web Forms

  • Introduction
  • Advantages
  • Comparison with HTML Form
  • Page Processing States
  • Event Model
  • View State Management
  • Cross-Page Postback
  • Using Web Controls
  • HTML Server Controls
  • Standard ASP.NET Sever Controls
  • Basic Controls
  • Validation Controls
  • Web User Controls
  • Master Pages &UserControl
  • URL Rebasing in a Master Page
  • Accessing a Master Page from Code
  • Nesting Master Pages
  • Master and Content Pages
  • Applying Themes and Styles to Controls
  • Working with CSS
  • Using Themes to Customize a Site
  • Named Skins within a Theme
  • Server-side Styles using Themes
  • Contents of a Theme and Skin
  • Themes and Profiles
  • ASP.NET State Management
  • Static / Shared Members
  • ViewState Object
  • Cookies
  • Session Management
  • Application State
  • HttpContext
  • ASP Intrinsic Objects
  • Request and Response
  • Session Objects
  • Application Objects
  • Server and Context
  • ASP.NET Web Application
  • Creating Virtual Directories
  • Global.asax& Managing Application Events
  • HttpApplication Instance
  • HTTP Handlers and creating Custom Handler
  • URL Redirection
  • Data Access Controls
  • Data Binding Server Controls
  • SqlDataSource, ObjectDataSource
  • GridView
  • DetailsView and FormView
  • Data List and Repeater
  • ListView


  • Overview
  • Page Output Caching
  • CacheProfile
  • Page Fragment Caching
  • Data Caching
  • SQL Cache Invalidation
  • Notification-based Invalidation
  • Polling-based Invalidation
  • Expiration Policies and Cache Dependencies
  • Configuration
  • Configuration Overview
  • Machine.Config and Web.Config
  • Inheritance of Configuration Settings
  • Configuration File Format
  • URL Rewriting - (Programmatically and using config files)
  • Custom Error Handling.

Trace Functionality

  • Overview of Tracing
  • Trace Information
  • Page-Level Trace
  • Application-Level Trace
  • Security
  • Authentication & Authorization
  • Windows Based Authentication
  • Form Based Authentication
  • Authorizing Users and Roles
  • Impersonation
  • Using Login Controls
  • ASP.NET Membership and Roles
  • Securing Non-ASP.NET files
  • Globalization and Localization
  • Request and Response Encoding
  • Local and Global Resources
  • Implicit Expressions to Local Resources
  • Explicit Expressions to Local Resources
  • Programmatic Access to Global Resources
  • Localizing Static Content
  • Storing Language Preferences
  • Right to Left Mirroring
  • Culture specific formatting
  • Personalizing Using Web Parts
  • Webpart Controls
  • Editing Webparts
  • Personalizing


  • Architecture
  • Working with AJAX Pro
  • Using AJAX.NET Controls
  • Accordion
  • Calendar
  • CascadingDropDown
  • CollapsiblePanel
  • FilteredTextBox
  • NumericUpDown
  • ModalPopup
  • PopupControl
  • Distributed Application


  • Introduction
  • Comparison between 2 and 3-tier
  • Limitations of SOCKET communication
  • Stub / Proxy Architecture
  • Comparison between DCOM / CORBA & RMI
  • Protocol for communication.
  • Serialization and Marshalling.

Web Services

  • Architecture and Advantage.
  • SOAP Significance.
  • Building Services & Hosting Services
  • Using WSDL to Build Proxy for clients
  • Setting up a 3-Tier Application using Web
  • Service.


  • Architecture
  • Advantages over Web Services
  • Channel Types
  • Server activated : Singleton / Single Call
  • Using Remoting Object in Web Application
  • Client activated
  • MS.Net Suite: MS.NET + SharePoint + Sql Server Live Project
  • MS.Net Advanced: LINQ + WCF + WPF + Silverlight + WF
  • MS.Net JUMBO = All the Above Topics are included.
  • Type Inference
  • Object Initializers.
  • Anonymous Types
  • Extension Methods
  • Partial Methods
  • Understanding the LINQ Framework
  • LINQ Providers
  • LINQ to Objects
  • LINQ to SQL
  • LINQ to Dataset
  • LINQ to XML
  • IEnumerable and IQueryable interfaces 
  • System.Linq namespace 
  • Query Expressions 
  • Lambda Expression 
  • Using Custom Class Collection 


  • Defining the Data Model classes
  • Using Mapping attributes
  • Using the Data Context class
  • Defining Relationships using Associations
  • Creating a customized Data Context class
  • LINQ to SQL Designer (DBML File)
  • Performing Add/Edit/Delete/View perations
  • Tracking changes to entities
  • Submitting changes
  • Web Service and WCF Course Details
  • WebService
  • What is Distributed Application
  • High Level Architecture on how RMI/CORBA/DCOM works
  • Introduction to WebService & SOAP
  • To build an WebService application and client
  • Pass by value and reference behavior
  • Working with SoapHeader Attribute
  • Asynchronous Call to the WebMethod
  • Security in WebService


  • Introduction to WCF
  • Evolution of WCF
  • Evolution of Service Oriented Architecture (SOA)
  • Four Tenets of SOA
  • What is WCF
  • Where does WCF Services fit in?
  • Developing WCF Service Application and Client
  • Hosting WCF Service in IIS/ASP.NET Development Server
  • Using a Service in the client application
  • Understand Contracts in the service
  • ServiceContract.
  • OperationContract.
  • DataContract.
  • Understand Instancing behavior in the service
  • Single
  • PerCall
  • PerSession
  • Building WCF Library based Host and Client application.
  • Endpoints in configuration file
  • End points in Configuration File.
  • ABC - Address, Binding & Contract of the service in Configuration File.
  • Understanding importance of base address.
  • Importance of IMetadataExchange Contract / Endpoint.
  • Configuring service behavior in configuration file
  • WCF Service Configuration Editor
  • Creating Endpoints through Code
  • Channel Stacks & Bindings in WCF
  • Understanding Channel Stack
  • Introduction to Binding
  • Types of Bindings
  • Binding Comparison
  • Thumb rules in choosing endpoint binding
  • Configuring a Service and Client for Multiple Bindings
  • Binding Class Properties.
  • Understanding Service and Data Contracts
  • About Service Contract
  • Data Contract & Data Member
  • Versioning using Interface IExtensibleDataObject
  • Version Tolerance
  • Implications of Modifying Service Operations
  • Implications of Modifying Data Contracts
  • Working with Known Types
  • Handling WCF Exceptions/Faults
  • Overview
  • Producing Faults
  • SOAP fault with FaultCode and FaultReason
  • Culture specific SOAP fault
  • Strongly Typed SOAP fault
  • Consuming Faults
  • Proxy State for Managed Exceptions Vs SOAP Fault
  • Message Exchange Patterns
  • Request – Reply Pattern
  • One way Operations
  • Duplex Pattern
  • Duplex Publisher Subscriber Example


  • What is Transaction and ACID
  • How to enable Transaction in WCF Service
  • TransactionScope in to begin a transaction.
  • Transaction Isolation
  • Transactions and Sessions


  • Introduction
  • Advantages of using MSMQ
  • Transactional Queues
  • Steps to follow to Build a MSMQ application
  • WCF Security
  • Concepts.
  • Security Mechanisms.
  • Default Security Settings.
  • Demonstrate how Messages are encrypted.
  • Authentication
  • Windows Authentication
  • HTTPS / SSL Authentication.
  • ASP.NET Membership Authentication
  • Custom Authentication
  • Authorization
  • Windows Group/Role based Authorization
  • Custom Role based Authorization
  • ASP.NET Role Provider
  • Concurrency error handling issues 
  • Join Query 
  • Validating Entities 
  • Transaction Handling 
  • Executing Stored Produces 
  • LINQ to SQL architecture 


  • Understanding the LINQ to XML Class hierarchy
  • Create an XML document
  • Loading existing XML document
  • Querying XML using LINQ to XML
  • Manipulating XML
  • Adding nodes
  • Modifying nodes
  • Deleting nodes

LINQ to Dataset

  • Querying DataSets
  • Querying typed DataSets
  • Using LINQ over DataSet with Table Adapter
1. Developing 3-tier architecture windows based application (Video Session)
A video of developing a 3- tier architecture windows based application will be provided online, which will be giving you a clear picture of how to start with the project and what care should be taken during the implementation.

2. Developing 3-tier architecture Web based application (Sample code will be provided)
For web based application in 3 tier we are going to provide you with the sample code of a project which will giving you an overview of how to and what steps need to be followed at the time of coding.

3. Analyze the Requirement – A brief overview of the requirement – Abstract Document.
Requirement Analysis is the first and most important for the success of project, it is also referred names such as requirements gathering, requirements capture or requirement specification.

By analyzing the requirements it provides a contract between the project sponsors and the developers about what to do. In other words the requirement analysis provides the information about the need of what a particular product or service should perform. These requirements are given as input to the Design phase.

Some of the below categories of requirements should be analyzed before starting of the project,
Customer Requirements
Functional Requirements
Non Functional Requirements
Software Requirements
Hardware Requirements
Design Requirements
Documenting the requirements will give an over view and the difficulties and of the project.

4. Identify Roles and their tasks – Roles Overview Document.
For every project there are some Roles defined with the help of which it is known what a particular user’s responsibilities are, according to a particular position or status in a group or organization he/she belongs to. Based on the roles the privileges to access a particular page is given to the user.

5. Detailed documentation about Individual modules – Module Document
Every project will be divided in to one or modules, each module will have its own functionality and importance. Project will be divided in to modules in order to ease the understanding of the project and development. Based on the project requirement and the roles identified the modules will be indentified. In module document we are going to specify what the module is about, functionalities of a module and which role is going to use this module.

6. Based on the above document designing dat abase – Database design document
For storage and retrieval we need a persistent storage which we call as a Database, here we need to specify the following:
What are the different tables
What are the fields in each table
What is the data type of each field
Defining the relationships between tables
Validation rules for each field
All the above will be documented properly.
7. Creating Tables in Dat abase (SQL Server)
Based on the above database document we are going to create the tables in Database
Creating the columns in each table with its respective data type and size
Mapping the relations between the tables
Creating the Database diagram

8. Insert ting Sample Data into the tables
Once the database is created we need to enter the sample data (proper data), this will help when we wrote the code and trying to check the application. So if the Database is empty it will be difficult to test the code whatever a developer has developed.

9. Detailed Process document for each module.
This will be a semi technical document created by a developer for the end user. In this document developer is going to specify the sequence of actions to be performed by the user.

10. Writing Data classes
In the Data classes the developer is going to represent each table of database as a separate data class which holds every column of the table as a property with specific return type as the data type of the column in the table.

11. Create Stored Procedures for the required functionality
Stored procedures are the important aspect in the application development, stored procedures enable the users to change the logic without tinkering with the application. Even the developer can pass the parameters to the stored procedure from the front end, in .Net CLR makes it possible for the developers to write the stored procedures, triggers, user-defined functions and creating the database using the managed language such as C#.Net.

Developer should identify the basic functionalities like Insert, Delete, Update, GetAll, GetRecordById etc.. of the application and then start writing the stored procedure for them for each table.

12. Write Helper class and add SqlHelper class to the application
Helper class is a user defined class where the common functions are defined. Common functions are the ones which are being used in more than one page so instead of writing them in each and every page we are going to put them in one class called “Helper”.

Sql Helper class is the one which is going to be used in the Data Access layer, it contains definitions for Execute Reader, Execute Dataset, Execute non Query, For establishing a connection and closing a connection etc., this also behaves like a common class for all the Database related operations which can be accessed in any of the Data Access layer.

13. Writing DAO classes for actions to be performed over dat abase.
All the classes of DAO will be in the Data Access Layer (DAL). This layer provides a simplified access to the persistent storage or Database.

Here DAO is the Data Access object with complete attributes instead of row of fields from a database table, which allows us to create the client modules with a higher level of abstraction. DAL will hide the complexity of underlying data source to the external world.

For instance, instead of using the commands such as insert, delete, update to access a specific table in the database, we can write a class and few stored procedures in the database and we can call the stored procedure from a method inside the class which would return the object of specific type containing the requested values. Also we can fetch data from several tables of the application with a single call.

We can also make the DAL to support multiple database types, so the application can be now able to use different whatever the DAL can talk database.

14. Documenting Business Objects functionality
Business object is an entity which is going to hold the business logic of application, here we are going to do the non technical documentation which will be similar to an algorithm or a procedure and is going to define the functionality of the class.

15. Setting up the web application
Creating and setting up the application in the solution in visual studio, means, creating different folders for distinguishing different classes like BO, Data, DAO, utility etc. for ease of navigation and maintenance of the project.

16. Technical process document of BO classes including Exception handling
Here we are going to document the classes and program, we are also going to handle the
exceptions by implementing the Exceptional handling methodologies. Complete sample program will be written.

17. Design GUI
To get an idea about how the screens are going to look we are going to visit few websites and based on the above inputs and details we are going to develop the screens on paper and if everything looks fine then we are going to start designing the screens. After preparing the screens we have to integrate the application with the respective Bos.

18. Testing the entire application
We are going to perform the UI testing and the functionality testing.

1 comment:

  1. This is a nice article..
    Its very easy to understand ..
    And this article is using to learn something about it..

    c#,, php tutorial

    Thanks a lot..!


Featured Post

Xamarin : Step-by-Step Guide To Building .NET Multi-platform App (MAUI) using Visual Studio 2019 Preview 16.10

Xamarin was released 10 years before, it has helped many developers to develop mobile apps with multi-platform with native feel but now it’s...

Popular Posts