Drop Down MenusCSS Drop Down MenuPure CSS Dropdown Menu

Tuesday, February 22, 2011

Dot Net Module

MS.NET – 4.0 INCL. C#, VB.NET & ASP.NET
MS.NET FRAMEWORK
·         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

VB.NET AND C# LANGUAGES
·         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

ADVANCE LANGUAGE FEATURES AND BASE CLASS API
·         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
Introduction
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.
WinForms
Introduction
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.
·         XML
Introduction
XML-DOM
XMLDocument, XMLElement, XMLAttribute
Interoperating with DataSet
XMLDataDocument
XML TextReader / XML TextWriter
XPath.



·         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











ASP.NET
·         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
·         Caching
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
AJAX.NET
·         Architecture
·         Working with AJAX Pro
Using AJAX.NET Controls
Accordion
Calendar
CascadingDropDown
CollapsiblePanel
FilteredTextBox
NumericUpDown
ModalPopup
PopupControl
·         Distributed Application
·         Development
·         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.

·         Remoting
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.

C# LANGUAGE EXTENSIONS IN 3.5 (PREREQUISITE)

  • Type Inference

  • Object Initializers.

  • Anonymous Types

  • Extension Methods

  • Partial Methods


LINQ ARCHITECTURE

  • Understanding the LINQ Framework

  • LINQ Providers

o   LINQ to Objects

o   LINQ to SQL

o   LINQ to Dataset

o   LINQ to XML







LINQ TO OBJECTS

  • IEnumerable and IQueryable interfaces

  • System.Linq namespace

  • Query Expressions

  • Lambda Expression

  • Using Custom Class Collection



LINQ TO SQL

  • 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
WCF 
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
Transactions
    • What is Transaction and ACID
    • How to enable Transaction in WCF Service
    • TransactionScope in to begin a transaction.
    • Transaction Isolation
    • Transactions and Sessions
MSMQ
    • 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


LINQ to XML

  • 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





















LIVE PROJECT EXECUTION PROCESS

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.

Post a Comment