System Types
• function of Base System Types
• System types, Value Types and Reference Types.
• Boxing and Unboxing.
• special system types
• Generics for reusability.
• Allow null values with Nullable Types.
• Exception classes.
• Modify class behavior via Attributes.
• interfaces
• comparison interfaces.
• IConvertible for type conversion.
• Support object cloning with ICloneable.
• Format data with IFormattable.
• IDisposable to release unmanaged resources.

• Primary Collection Types
• Collections and Collection Interfaces.
• ArrayLists, Stacks, and Queues.
• Enumerators and Comparers.
• Hashtable and SortedList Key/Value collections.
• Generic Collections
• generic Lists, Stacks, and Queues.
• linked and doubly linked lists.
• generic Dictionary, SortedList, and SortedDictionary Key/Value collections.
• Specialized Collections
• type-safe specialized String collections.
• high-performance specialized dictionarys.
• specialized String-Based key collections.
• Collection Base Classes
• Create custom collections. using Collection Base classes.
• Create custom dictionaries using Dictionary Base types.

• Assemblies
• Create Assemblies.
• Assign strong names.
• Deploy to the Global Assembly Cache.
• Install assemblies by using installer classes
• Install assemblies using the Installer, AssemblyInstaller and ComponentInstaller.
• Manage assembly installation using Installer Collection and Install Context.
• Handle installation events
• configuration classes and files
• Configuration classes to manage application settings.
• Manage configuration elements and actions.
• Create custom configuration classes.
• Configuring the .NET Framework runtime.

• Manage event logs
• Read and write to an event log.
• Manage Application Processes
• Retrieve running processes and modules.
• Retrieve information about the current process.Start and stop application processes.
• Manage Application Performance
• Debug and add application tracing
• Microsoft Visual Studio® 2005 debugger for examining exceptions.
• Programmatically debug applications.
• Configure the Visual Studio 2005 debugger with debugger attributes.
• StackFrame and StackTrace classes.
• Embed Management and Instrumentation
• management classes.
• Subscribe applications to management events.
• Retrieve system resource information via WMI.

• Manage the File System
• Streams, Stream reader and Stream writer classes to access data.
• Manipulate strings efficiently
Gobalization
• Culture Information by Using Globalization Classes
• Access Culture and Region Information using CultureInfo and RegionInfo
• Using DateTimeFormatInfo for format Dates
• Using NumberFormatInfo to format numeric values
• Comparing Information using CompareInfo
• Create a Custom Culture
• Build a Custom Culture with Culture and RegionInfoBuilder
• Primary Encoding Classes
• Using Encoding and EncodingInfo to encode characters
• Encoding using ASCII and Unicode Standards
• Advanced Encoding Classes
• Handling Failure Events with Encoder and EncoderFallback
• Handling Failure Events Using Decoder and DecoderFallback

• Delegates, events
Serialization
• Serialize to Binary and SOAP
• Using the SoapFormatter
• Using the BinaryFormatter
• Serialize to XML
• Serializing objects using XmlSerializer
• Customizing serialization with serialization attributes
• Customizing serialization using IXmlSerializable
• Handling XML Serialization Events
• Create Custom Serialization Classes
• Using Serialization interfaces
• Creating custom formatters
• Handling Serialization Events
• Using ObjectManger to manage deserialized objects

• Graphics, Brushes, Pens, Colors, and Fonts
• Manipulate Shapes and Sizes
• Images, Bitmaps, and Icons

Code Access Security
• Configure Code Access Security
• Manage Security Policy
• Manage Permissions
• Manage Access Control
• Manage User Identity Information
Cryptography
• Encrypt Data
• Hash Data
• Extend the Cryptographic Behavior
• Manage Configuration Information with Cryptography Classes

• Import a Type Library into .NET
• COM Types in Managed Code
• Compile and Deploying Interop applications
• Call Win32 API Functions
• Create Prototypes in Managed Code
• Call COM Functions from managed code
• Map exceptions to HRESULT
• How pinvoke marshals data
• Control data marshalling with Marshal and MarshalAsAttribute

• Create a Windows service using ServiceBase
• Install a service using ServiceInstaller
• Debug a service using Microsoft Visual Studio®
• Control a service using ServiceController
• E-mail Messages
• Create a message using Mail classes
• Add Attachments to a message
• Send a Message with SmtpClient
• Handle E-mail Exceptions
• Handle the SendComplete

• Access type metadata using Assembly
• Discover type metadata using MemberInfo
• reflection to examine method contents
• Assembly Attributes, assemblies dynamically

Multithreading and AppDomains
• Thread class
• ThreadPool Class
• Manage access to a shared resource
• signaling classes
• Manipulate Shared Memory Resources with Interlocked
• Manage callback methods
• Migrate the execution context of a thread through asynchronous calls
• SynchronizationContext

Create a Web application.
• Visual Studio Web Site Types
• Default Event Handling in Web Applications
• Web Configuration Files
• Creating a New Web Application
• Configuring and Building a Web Application

Program a Web application.
• Event Handling in Web Applications
• Browser Capability Detection
• Page Header Retrieval
• Page-Level and Application-Level Error Handling
• Implementing Non-Default Event Handlers
• Detecting Browser Capabilities and Setting Page Header Properties
• Handling Page-Level Exceptions

• HTML Controls and Web Server Controls
• Types of Web Server Controls
• Working with Web Server Controls
• The ASP.NET 2.0 Page Postback Model
• Building Graphical User Interfaces with HTML Controls
• Building Graphical User Interfaces with Web Server Controls
• Programming Web Server Controls and Working with Postbacks

Use master pages to establish a common layout for a Web application.
• Master Pages
• Content Pages
• Nested Master Pages
• Adding and Configuring Content Pages

• ViewState Properties and ControlState Data
• Application and Session Objects
• Strategies for Managing Session State Data
• The Cache Object
• Configuring ViewState Properties for Web Server Controls
• Storing and Retrieving Application and Session State
• Implementing Out-of-Process Session State
• Storing and Managing State Data in the Cache Object

• Database Connections and the Web.Config File
• Relational Data and Data Source Controls
• XML Data and Data Source Controls
• Object Data and Data Source Controls
• Creating and Retrieving Database Connections
• Accessing Data by Using SqlDataSource Controls and Data Controls
• Accessing Objects as Data with ObjectDataSource Controls
• Accessing XML Data by Using XmlDataSource Controls
Control access to a Web application.
• Authentication for Web Applications
• Authorization for Web Applications
• Site Membership Systems Using the Membership Class
• Web Site Security Administration Using the Roles Class

• The Copy Web Site Utility
• The Publish Web Site Utility
• Windows Installer Setup Packages
Making Web Applications Available to Mobile Devices
• Device Emulators for Mobile Web Forms
• Mobile Device Detection and Redirection
• Mobile Web Forms
• Device-Specific Features in Mobile Web Forms
Build dynamic Web applications.
• Dynamic Control Creation
• Localization and Globalization
• Dynamic Master Pages
• Dynamic Web Configuration

• User Controls
• Custom Web Server Controls
• Composite Web Server Controls
• Templated Controls
Optimize Web applications.
• The Page Scripting Object Model
• Tracing and Instrumentation in Web Applications
• ASP.NET 2.0 Caching Techniques
• Asynchronous Processing in Web Applications
• Web Farm Development Considerations

• Configuring Personalization
• Implementing Personalization Functionality
• Adding Themes to the Web Application
• Implementing Personalized Themes
Connect to databases and read data.
• ADO.NET
• The Process for Connecting to a Database and Reading Data
• Connection Pooling
• Connecting to a Database
• Saving a Connection String Securely in an Application Configuration File
• Retrieving Data from a Database
• Handling Connection Events and Exceptions
• Configuring and Using Connection Pooling (if time permits)
Query and update databases by using commands.
• ADO.NET Commands, The Process for Passing Parameters into Commands

• Transaction, The Process for Managing Local Transactions
• The Process for Managing Distributed Transactions
• Isolation Levels

• Saving a DataSet as XML Data, Loading a DataSet from XML
• Saving and Loading DataSet Schema Information

Read and write XML data.
• The Process for Serially Reading XML Data
• The Process for Serially Writing XML Data
Process XML data by using the Document Object Model DOM.
• DOM, DOM Trees, Types of XML Nodes in a DOM Tree

• Data Conflicts Arise
• Isolation Levels Available in SQL Server 2005
• Guidelines for Using SQL Server 2005 Isolation Levels

Handle large objects.
• Binary Large Objects and Character Large Objects
• The Process for Reading Large Objects from a Database
• The Process for Writing Large Objects to a Database
Enhance database performance.
• Accessing Multiple Result Sets Concurrently
• Performing Asynchronous Data Access Operations
• Performing a Batch Update
• Performing a Bulk Data Copy

• Creating Managed Stored Procedures and Triggers
• Creating Managed User-Defined Functions
• Creating a Managed Aggregate
• Creating a Managed User-Defined Type
• Importing Existing Assemblies into SQL Server 2005 (if time permits)
Query XML by using XPath.
• The XPath Data Model
• The Process for Selecting and Editing XML Data by Using XPathNavigator
• The Process for Evaluating XPath Expressions by Using XPathNavigator

Transform XML by using XSLT style sheets.
• XSLT
• The Process for Executing an XSLT Style Sheet
• Extension Objects

Envisioning and Designing an Application
• Evaluate the technical feasibility of an application design concept.
• Create a proof-of-concept prototype
• Evaluate the technical specifications for an application to ensure that the business requirements are met.
• Evaluate the design of a database
• Translate the functional specification into developer terminology, such as pseudo code and UML diagrams.
• Suggest component type and layer.
• Recommend a database schema.
• Identify the stored procedures that are required for an application.
• logical design of an application.
• Performance, maintainability, Extensibility, scalability.
• Availability, security, logical design for recoverability, logical design for data integrity.
• Performance, maintainability, physical location of files affects the extensibility of the application, scalability, availability, security, recoverability, data integrity.

• layout for the visual interface.
• Evaluate a strategy for implementing a common layout throughout the UI.
• Choose an appropriate control based on design specifications.
• Choose an appropriate data validation method at the UI layer.
• Choose appropriate user assistance and application status feedback techniques.
• Choose an appropriate mechanism to deliver multimedia data from an application.
Designing and Developing a Component
• create a single component or multiple components.
• Decide which tier of the application a component should be located.
• Decide which type of object to build.
• Establish the life cycle of a component.
• Decide whether to use established design patterns for the component.
• Decide whether to create a prototype for the component.
• Document the design of a component by using pseudo code, class diagrams, sequence diagrams, activity diagrams, and state diagrams.

• Decide whether existing functionality can be implemented or inherited.
• Decide how to handle unmanaged and managed resources.
• Decide which extensibility features are required.
• Decide whether a component must be stateful or stateless.
• Decide whether a component must be multithreaded.
• Decide which functions to implement in the base class, abstract class, or sealed class.
• Develop an exception handling mechanism.
• Analyze data relationships.
• Analyze the data handling requirements of a component.
• Develop a component to include profiling requirements.

• Identify a reusable software component from available components to meet the requirements.
• reusable software component needs to be extended.
• reusable software component needs to be wrapped.
• Identify whether any existing functionality needs to be hidden.
• Test the identified component that is based on the requirements.
• Current exception handling mechanism.
• New exception handling technique.
• data storage mechanism.
• data flow structure.
• decision flow structure.
• Decide whether to log data. Considerations include policies, security, requirements, and debugging.

• Choose a systemwide event logging method. For example, centralized logging, distributed logging, and so on.
• Decide logging levels based on severity and priority.
• Monitor specific characteristics or aspects of an application.
• Choose event monitoring mechanisms, such as System Monitor and logs.
• Decide monitoring levels based on requirements.
• Choose a systemwide monitoring method from the available monitoring mechanisms.
• Decide which configuration attributes to store.
• Choose the physical storage location for the configuration attributes.
• Decide in which format to store the configuration attributes.
• Choose when to use ASP.NET Administrative tools.
Testing and Stabilizing an Application
• Perform a code review.
• Create the unit testing strategy.
• Evaluate the integration testing strategy.
• Evaluate the stress testing strategy.
• Evaluate the performance testing strategy.
• Evaluate the test environment specification.
• Describe the testing scenarios.
• Decide coverage requirements.

• Decide the type of assertion tests to conduct.
• Determine if the component works as intended in the target environment.
• Identify component interactions and dependencies.
• Verify results.
• Resolve a bug.
• reported bug.
• Reproduce a bug.
• Fix a bug.
Deploying and Supporting an Application
• Performance spikes.
• Performance trends.
• Track page response times.
• Track logon times.
• Monitor and analyze resource usage.
• Monitor and analyze security aspects.

• Choose when to use ASP.NET 2.0 Health Monitoring APIs.
• Evaluate the deployment plan.
• Deployment dependencies.
• Scripting requirements for deployment.
Create an application flow-logic diagram.
• Validate the production configuration environment.
• Considerations include load balancing, Web farms, and Web gardens.
• Verify networking settings.
• Verify the deployment environment.