MCTS Windows Certification Exam 70–536
Microsoft .NET Framework 2.0 - Application Development Foundation

Developing applications that use system types and collections
- Value, Reference, Generic, types
- Attributes
- Exception classes
- Boxing and UnBoxing
- TypeForwardedToAttribute Class
- ArrayList class
- Collection interfaces
- Iterators
- Hashtable class
- CollectionBase class and ReadOnlyCollectionBase class
- DictionaryBase class and DictionaryEntry class
- Comparer class
- Queue class
- SortedList class
- BitArray class
- Stack class

Generic collections.
- Collection.Generic interfaces, Generic Dictionary
- Generic Comparer class and Generic EqualityComparer class
- Generic KeyValuePair structure
- Generic List class, Generic List.Enumerator structure, and Generic SortedList class
- Generic Queue class and Generic Queue.Enumerator structure
- Generic SortedDictionary class
- Generic LinkedList
- Generic Stack class and Generic Stack.Enumerator structure

Specialized collections
- Specialized String classes, Specialized Dictionary
- Named collections, CollectionsUtil
- BitVector32 structure and BitVector32.Section structure
- IComparable, IDisposable, IConvertible, ICloneable, IEquatable, IFormattable interface

Events and delegates
- Delegate class, EventArgs class, EventHandler delegates

Implementing service processes, threading, and application domains in a .NET Framework application
- Implement, install, and control a service
- Inherit from ServiceBase class, ServiceController class and ServiceControllerPermission class
- ServiceInstaller and ServiceProcessInstaller class
- SessionChangeDescription structure and SessionChangeReason enumeration
- Develop multithreaded .NET Framework applications.

Application domains.
- Create, unload and configure an application domain.
- Retrieve setup information from an application domain.
- Load assemblies into an application domain.

Embedding configuration, diagnostic, management, and installation features into a .NET Framework application
Embed configuration management
- Installer class
- Configure which runtime version a .NET Framework application should use.
- Configure where the runtime should search for an assembly.
- Configure the location of an assembly and which version of the assembly to use.
- Direct the runtime to use the DEVPATH environment variable when you search for assemblies.
- AssemblyInstaller class
- ComponentInstaller class
- Configure a .NET Framework application by using the .NET Framework Configuration tool (Mscorcfg.msc).
- ManagedInstallerClass class
- InstallContext class
- InstallerCollection class
- InstallEventHandler delegate
- Configure concurrent garbage collection.
- Register remote objects by using configuration files.

Manage an event log
- Write to an event log. Read from an event log.
- Create a new event log.
- Manage system processes and monitor the performance
- Debug and trace a .NET Framework application by using the System.Diagnostics namespace.
- Embed management information and events into a .NET Framework application

Implementing serialization and input/output functionality in a .NET Framework application
- Serialization interfaces
- Serilization attributes
- SerializationEntry structure and SerializationInfo class
- ObjectManager class
- Formatter class, FormatterConverter class, and FormatterServices class
- StreamingContext structure

Control the serialization of an object into XML format by using the System.Xml.Serialization namespace.
- Serialize and deserialize objects into XML format by using the XmlSerializer class.
- Control serialization by using serialization attributes.
- Implement XML Serialization interfaces to provide custom formatting for XML serialization.
- Delegates and event handlers are provided by the System.Xml.Serialization namespace
- Implement custom serialization formatting by using the Serialization Formatter classes.
- Access files and folders by using the File System classes.
Manage byte streams by using Stream classes.

Compress or decompress stream information in a .NET Framework application
- IsolatedStorageFile class, IsolatedStorageFileStream class
- DeflateStream class, GZipStream class

Improving the security of the .NET Framework applications by using the .NET Framework 2.0 security features
- SecurityManager class
- CodeAccessPermission class
- Modify the Code Access security policy at the computer, user, and enterprise policy level by using the Code Access Security Policy tool (Caspol.exe).
- PermissionSet class and NamedPermissionSet class
- Standard Security interfaces

Implement access control by using the System.Security.AccessControl classes.
- Implement a custom authentication scheme by using the System.Security.Authentication classes.
- Encrypt, decrypt, and hash data by using the System.Security.Cryptography classes.
- Control permissions for resources by using the System.Security.Permission classes
- Control code privileges by using System.Security.Policy classes.
- Access and modify identity information by using the System.Security.Principal classes.
- GenericIdentity class and GenericPrincipal class
- WindowsIdentity class and WindowsPrincipal class
- NTAccount class and SecurityIdentifier class
- IIdentity interface and IPrincipal interface
- WindowsImpersonationContext class
- IdentityReference class and IdentityReferenceCollection class

Implementing interoperability, reflection, and mailing functionality in a .NET Framework application
- Expose COM components to the .NET Framework and the .NET Framework components to COM.
- Import a type library as an assembly.
- Create COM types in managed code.
- Compile and deploy an interop project.
- Qualify the .NET Framework types for interoperation.
- Apply Interop attributes, such as the ComVisibleAttribute class.
- Package an assembly for COM and deploy for COM access.

Call unmanaged DLL functions in a .NET Framework application
Control the marshaling of data in a .NET Framework application.
- Implement reflection functionality in a .NET Framework application
- Create metadata, Microsoft intermediate language (MSIL), and a PE file by using the System.Reflection.Emit namespace.
- Assembly class, Assembly attributes
- Info classes, Binder class and BindingFlags
- MethodBase class and MethodBody class

Send electronic mail to a Simple Mail Transfer Protocol (SMTP) server for delivery from a .NET Framework application.
- MailMessage class, MailAddress class and MailAddressCollection class
- SmtpClient class, SmtpPermission class, and SmtpPermissionAttribute class
- Attachment class, AttachmentBase class, and AttachmentCollection class
- SmtpException class and SmtpFailedReceipientException class
- SendCompletedEventHandler delegate
- LinkedResource class and LinkedResourceCollection class
- AlternateView class and AlternateViewCollection class

Implementing globalization, drawing, and text manipulation functionality in a .NET Framework application
- Format data based on culture information.
- Access culture and region information in a .NET Framework application.
- Format date and time values based on the culture.
- Format number values based on the culture.
- Perform culture-sensitive string comparison.
- Build a custom culture class based on existing culture and region classes.

System.Drawing namespace.
- Enhance the user interface of a .NET Framework application by using brushes, pens, colors, and fonts.
- Enhance the user interface of a .NET Framework application by using graphics, images, bitmaps, and icons.
- Enhance the user interface of a .NET Framework application by using shapes and sizes.

Enhance the text handling capabilities and search, modify, and control text using regular expressions.
- StringBuilder class, Regex class
- Match class and MatchCollection class
- Group class and GroupCollection class
- Encode text by using Encoding classes
- Decode text by using Decoding classes.
- Capture class and CaptureCollection class

Exam 70-528: TS: Microsoft .NET Framework 2.0 - Web-Based Client Development

Creating and Programming a Web Application
- Create and configure a Web application
- Create a new Web application.
- Add Web Forms pages to a Web application.
- Add and configure Web server controls. Events Control, Post Back events, Naming containers and Child Contorls.
- HTML server controls
- HTML tags, HTML Controls, Manage Banners and pop-up windows
- Web Buttons
- CheckBox Web Server control, FileUpload, HyperLink, Image Web server control,
- ImageButton, ImageMap, LinkButton, ListControl, MultiView, RadioButton
- Construct a table by using the Table, TableRow, and TableCell Web server controls
- TextBox

Create event handlers for pages and controls.
- Manage state and application data.
- Implement globalization and accessibility.
- Implement site navigation and input validation.
- Write an ASP.NET handler to generate images dynamically for display on a Web page.
- Configure settings for a Web application.

Program a Web application.
- Redirect users to another Web page by using a server-side method.
- Detect browser types in Web Forms.
- Ascertain the cause of an unhandled exception at the page level.
- Programmatically access the header of a Web page.
- Implement cross-page postbacks.
- Assign focus to a control on a page when the page is displayed.
- Avoid performing unnecessary processing on a round trip by using a page's IsPostBack property.
- Access encapsulated page and application context.
- Avoid unnecessary client-side redirection by using the HttpServerUtility.Transfer method.
- Avoid round trips by using client-side scripts.
- Use a page's Async attribute to create a page that has built-in asynchronous capabilities.
- Convert HTML server controls to HTML elements.

Integrating Data in a Web Application by Using ADO.NET, XML, and Data-Bound Controls
- Implement data-bound controls.
- Use tabular data source controls to return tabular data.
- Use hierarchical data source controls to display hierarchical data.
- Display data by using simple data-bound controls.
- Display data by using composite data-bound controls.
- Display data by using hierarchical data-bound controls.
- Use the FormView control to display the values of a single table record from a data source.

Manage connections and transactions of databases.
- Configure a connection to a database graphically by using the Connection Wizard.
- Configure a connection by using Server Explorer.
- Configure a connection to a database by using the connection class.
- Connect to a database by using specific database connection objects.
- Enumerate through instances of Microsoft SQL Server by using the DbProviderFactories.GetFactoryClasses method.
- Open a connection by using the Open method of a connection object.
- Close a connection by using the connection object.
- Secure a connection to protect access to your data source.
- Create a connection designed for reuse in a connection pool.
- Control connection pooling by configuring ConnectionString values based on database type.
- Use connection events to detect database information.
- Handle connection exceptions when connecting to a database.
- Perform transactions by using the ADO.NET Transaction object.

Create, delete, and edit data in a connected environment.
- Retrieve data by using a DataReader object.
- Build SQL commands visually in Server Explorer.
- Build SQL commands in code.
- Create parameters for a command object.
- Perform database operations by using a command object.
- Retrieve data from a database by using a command object.
- Perform asynchronous operations by using a command object.
- Perform bulk copy operations to copy data to a SQL Server computer.
- Store and retrieve binary large object (BLOB) data types in a database.

Create, delete, and edit data in a disconnected environment.
- Create an instance of the DataSet class programmatically.
- Create a DataSet graphically.
- Create a DataSet programmatically.
- Add a DataTable to a DataSet.
- Add a relationship between tables.
- Navigate a relationship between tables.
- Merge DataSet contents.
- Copy DataSet contents.
- Create a strongly typed DataSet.
- Create DataTables.
- Manage data within a DataTable.
- Create and use DataViews.
- Represent data in a DataSet by using XML.
- Access an ADO Recordset or Record by using the OleDbDataAdapter object.
- Generate DataAdapter commands automatically by using the CommandBuilder object.
- Generate DataAdapter commands programmatically.
- Populate a DataSet by using a DataAdapter.
- Update a database by using a DataAdapter.
- Resolve conflicts between a DataSet and a database by using the DataAdapter.
- Respond to changes made to data at the data source by using DataAdapter events.
- Perform batch operations by using DataAdapters.

Manage XML data with the XML Document Object Model (DOM).
- Read XML data into the DOM by using the Load method.
- Modify an XML document by adding and removing nodes.
- Modify nodes in an XML document.
- Write data in XML format from the DOM.
- Work with nodes in the XML DOM by using XmlNamedNodeMap and the XmlNodeList.
- Handle DOM events.
- Modify XML declaration.

Read and write XML data by using the XmlReader and XmlWriter.
- Read XML data by using the XmlReader.
- Read all XML element and attribute content.
- Read specific element and attribute content.
- Read XML data by using the XmlTextReader class.
- Read node trees by using the XmlNodeReader.
- Validate XML data by using the XmlValidatingReader.
- Write XML data by using the XmlWriter.

Creating Custom Web Controls
- Create a composite Web application control.
- Create a user control.
- Convert a Web Forms page to a user control.
- Include a user control in a Web Forms page.
- Manipulate user control properties.
- Handle user control events within the user control code-declaration block or code-behind file.
- Create instances of user controls programmatically.
- Develop user controls in a code-behind file.
- Create a templated user control.

Create a custom Web control that inherits from the WebControl class.
- Create a custom Web control.
- Add a custom Web control to the Toolbox.
- Individualize a custom Web control.
- Create a custom designer for a custom Web control.

Create a composite server control.
- Create a base class for composite controls.
- Create a composite control.

Develop a templated control.
- Create a templated control.
- Develop a templated data-bound control.

Tracing, Configuring, and Deploying Applications
- Use a Web setup project to deploy a Web application to a target server.
- Create a Web setup project.
- Configure deployment properties for a Web setup project.
- Install a Web application on a target server.
- Copy a Web application to a target server by using the Copy Web tool.
- Precompile a Web application by using the Publish Web utility.
- Optimize and troubleshoot a Web application.
- Customize event-level analysis by using the ASP.NET health-monitoring API.
- Use performance counters to track the execution of an application.
- Troubleshoot a Web application by using ASP.NET tracing.
- Optimize performance by using the ASP.NET Cache object.

Customizing and Personalizing a Web Application
- Implement a consistent page design by using master pages.
- Create a master page.
- Add a ContentPlaceHolder control to a master page.
- Specify default content for a ContentPlaceHolder.
- Reference external resources in a master page.
- Define the content of a particular page in a content page.
- Create a content page.
- Add content to a content page.
- Reference a master page member from a content page.
- Handle events when using master pages.
- Create a nested master page.
- Change master pages dynamically.
- Customize a Web page by using themes and user profiles.
- Implement Web Parts in a Web application.
- WebPartManager WebPartZones, CatalogPart, EditorPart control

Implementing Authentication and Authorization
- Establish a user's identity by using forms authentication.
- Use authorization to establish the rights of an authenticated user.
- Implement Microsoft Windows authentication and impersonation.
- Use login controls to control access to a Web application.
- Use the Login Web server control. LoginView, PasswordRecovery, LoginStatus, CreateUserWizard, ChangePassword

Creating ASP.NET Mobile Web Applications
- Create a mobile Web application project. Web Server Controls, Mobile Web Controls to display content