Core and Advanced Foundations of Microsoft .Net
2.0 Development
Course 2956-2957: Five days;
Instructor-Led
|
Introduction
This instructor-led course provides students with the
knowledge and skills to program Microsoft .NET Framework applications by
using Microsoft Visual Studio 2005 development system. This course helps
students to prepare for Exam 70-536, which is a core requirement for the
MCTS certification. With the release of this course, Microsoft Partners
will be able to provide their customers with a complete certification
track in the classroom.
Audience
The audience for this course consists of application
developers with the skills to develop business applications by using
Visual Studio 2005 and either Microsoft Visual Basic development system
or Microsoft Visual C# development tool.
At Course Completion
After completing this course, students will be able
to:
| • |
Develop applications that use types and
standard contracts.
|
| • |
Manage common data by using collections.
|
| • |
Deploy and configure assemblies.
|
| • |
Monitor and debug applications.
|
| • |
Read and write files.
|
| • |
Serialize data.
|
Prerequisites
Before attending this course, students must:
| • |
Understand the purpose and components of the
.NET 2.0 Framework and the common language runtime.
|
| • |
Understand and use the .NET Framework 2.0
common type system (CTS).
|
| • |
Understand basic language syntax for decision
structures, loop structures, and variables.
|
| • |
Write code by using language-specific
functionality such as the My. classes for Visual Basic.
|
| • |
Understand and use classes, objects, methods,
properties, and functions.
|
| • |
Write code to implement overridden methods,
static (Visual C#) or Shared (Visual Basic) methods, and
properties.
|
| • |
Use type conversions and text conversions.
|
| • |
Create and use solutions and projects by
using Visual Studio 2005.
|
| • |
Use the Visual Studio 2005 object browser and
the Visual Studio help system.
|
Course Outline
Module 1: Developing Applications by Using Types and
Standard Contracts
This module describes the differences between
reference types and value types. The module also describes how to create
generic data types, implement standard .NET Framework interfaces, use
delegates and events, and use attributes and exceptions.
Lessons
| • |
Explaining Value Types and Reference Types
|
| • |
Working with Generic Types
|
| • |
Implementing .NET Standard Contracts
|
| • |
Implementing Delegates and Events
|
| • |
Working with Attributes and Exceptions
|
Lab: Developing Applications by Using Types and
Standard Contracts
| • |
Using Nullable Types
|
| • |
Defining a Generic Type
|
| • |
Implementing Standard .NET Framework
Interfaces
|
| • |
Throwing and Catching Exceptions (If Time
Permits)
|
| • |
Raising and Handling Events (If Time Permits)
|
After completing this module, students will be able
to:
| • |
Manage data in a .NET Framework application
by using the .NET Framework 2.0 system types.
|
| • |
Implement generic types.
|
| • |
Implement .NET Framework interfaces to cause
components to comply with standard contracts.
|
| • |
Control interactions between .NET Framework
application components by using delegates and events.
|
Module 2: Managing Common Data by Using Collections
This module introduces the object-based collection
classes in the System.Collections namespace. The module also describes
the generic collection classes in the System.Collections.Generic
namespace and outlines the benefits of the generic collections. The
module also covers several specialized collections in the
System.Collections.Specialized namespace.
Lessons
| • |
Working with Object-Based Collections
|
| • |
Working with Generic Collections
|
| • |
Working with Specialized Collections
|
Lab: Managing Common Data by Using Collections
| • |
Using the Dictionary Generic Collection
|
| • |
Using the List Generic Collection
|
| • |
Using the NameValueCollection Specialized
Collection
|
After completing this module, students will be able
to:
| • |
Use the object-based collections that are
defined in the System.Collections namespace.
|
| • |
Use the generic collections that are defined
in the System.Collections.Generic namespace.
|
| • |
Use the specialized collections that are
defined in the System.Collections.Specialized namespace.
|
Module 3: Deploying and Configuring Assemblies
This module describes the key features of assembly
configuration and installation. It also explains how to install
assemblies and how to configure assemblies and the .NET Framework.
Lessons
| • |
Installing and Configuring Assemblies
|
| • |
Installing Assemblies by Using the Installer
|
| • |
Configuring Assemblies
|
| • |
Configuring the .NET Framework
|
Lab 3: Deploying and Configuring Assemblies
| • |
Managing the Configuration Settings of an
Assembly
|
| • |
Deploying an Application by Using Windows
Installer
|
After completing this module, students will be able
to:
| • |
Describe the purpose of deployment and
configuration.
|
| • |
Create a custom Microsoft Windows Installer
for the .NET Framework components by using the
System.Configuration.Install namespace.
|
| • |
Embed configuration management functionality
in a .NET Framework application.
|
| • |
Configure the .NET Framework and applications
by using configuration files, environment variables, and the
.NET Framework Configuration tool.
|
Module 4: Monitoring and Debugging Applications
This module describes how to use the available
classes of the System.Diagnostics namespace to monitor and debug a .NET
Framework application.
Lessons
| • |
Working with Application Processes
|
| • |
Managing Application Performance
|
| • |
Reading and Writing to an Event Log
|
| • |
Debugging and Tracing Applications
|
Lab: Monitoring and Debugging Applications
| • |
Monitoring Application Performance
|
| • |
Logging Information in a Custom Event Log
|
| • |
Adding and Configuring Tracing Statements in
an Application
|
After completing this module, students will be able
to:
| • |
Manage system processes by using the Process
class of the System.Diagnostics namespace.
|
| • |
Monitor the performance of a .NET Framework
application by using the diagnostics functionality of the .NET
Framework 2.0.
|
| • |
Manage the Windows Event Log by using the
System.Diagnostics namespace.
|
| • |
Debug and trace a .NET Framework application
by using the System.Diagnostics namespace.
|
Module 5: Reading and Writing Files
This module describes how to use the classes in the
.NET Framework 2.0 Class Library to manipulate files and folders and how
to read and write data to and from files and memory.
Lessons
| • |
Managing the File System
|
| • |
Reading and Writing Data by Using Streams
|
| • |
Compressing and Protecting Data by Using
Streams
|
| • |
Improving Application Security by Using
Isolated Storage
|
Lab: Reading and Writing to File and Folders
| • |
Archiving Files
|
| • |
Compressing Files
|
| • |
Storing and Retrieving User Preferences
|
After completing this module, students will be able
to:
| • |
Access files and folders by using the .NET
Framework file system classes.
|
| • |
Use streams to read and write data held in
files and in memory.
|
| • |
Compress, decompress, encrypt, and decrypt
data as it is streamed.
|
| • |
Create and manage isolated data stores for an
application.
|
Module 6: Serializing Data
This module describes how the .NET Framework Class
Library implements serialization and explains how to use the classes
provided to serialize and deserialize classes and structures. This
module also describes how to customize the serialization mechanism
implemented by the .NET Framework.
Lessons
| • |
Serializing and Deserializing Objects by
Using Runtime Serialization
|
| • |
Customizing the Runtime Serialization and
Deserialization Processes
|
| • |
Serializing and Deserializing Objects As XML
Data
|
Lab 6: Serializing Data
| • |
Serializing and Deserializing Data Across a
Network by Using Runtime Serialization
|
| • |
Customizing the Runtime Serialization Process
|
| • |
Serializing and Deserializing Data as XML
|
After completing this module, students will be able
to:
| • |
Serialize and deserialize an object graph to
a stream by using runtime serialization techniques.
|
| • |
Customize the runtime serialization and
deserialization processes.
|
| • |
Serialize and deserialize an object graph
into XML format data.
|
Module 7: Enhancing User Interfaces by Using
System.DrawingThis
module describes the key features of the
System.Drawing
namespace that the .NET Framework provides. It also explains how to
create and modify your own custom drawings.Lessons
- Drawing Fundamentals
- Drawing Lines and Shapes
- Rendering Bitmaps and Icons
Lab : Drawing to a Windows Form
- Drawing a Feedback Bar
- Drawing a Feedback Pie Chart
- Implementing an Automatic Double Buffer
- Adding Fonts to Your Application
- Saving Your Scaled Image
After completing this module, students will be able to:
- Use points, sizes, brushes, pens, colors, and
fonts.
- Draw lines and shapes.
- Create and use images, bitmaps, and icons.
Module 8: Processing Text by Using Regular
Expressions and EncodingsThis
module describes the key features of the
System.Text
namespace that the .NET Framework provides. It explains how to store and
manipulate strings, how and when to implement regular expressions, and
how to customize encodings to produce the correct results when you
process textLessons
- Handling Text and Large Strings
-
Using Regular Expressions
- Encoding Text
Lab : Processing Text by Using Regular Expressions
and Encodings
- Handling Text and Strings
- Creating and Using Regular Expressions
- Working with Encoding
After completing this module, students will be able to:
- Explain the purpose of and use the
StringBuilder class.
- Describe the purpose of and create regular
expressions by using the classes in the
System.Text.RegularExpressions namespace.
- Describe text encoding and how to encode and
decode text by using the encoding classes.
Module 9: Encrypting and Hashing Data by
Using CryptographyThis
module describes when to use data encryption and hashing and explains
how to use the classes in the .NET Framework 2.0 to perform these
cryptographic tasks. It also discusses how to customize the
implementation of specific algorithms by extending base classes in the
System.Security.Cryptography namespace.Lessons
- Working with Encryption and Hashing
- Encrypting and Decrypting Data
- Hashing Data
- Extending Cryptography
Lab : Creating a Cryptographic Application
- Creating an Asymmetric Key
- Encrypting a File
- Decrypting a File
- Exporting and Importing a Public Key
- Getting a Private Key
After completing this module, students will be able to:
- Explain the purpose of encryption and hashing
algorithms.
- Describe the algorithms available for hashing
and encryption.
- Describe the difference between symmetrical and
asymmetrical algorithms.
- Encrypt and decrypt data by using the classes in
the System.Security.Cryptography namespace.
- Create custom classes that extend the .NET
Framework cryptography model.
Module 10: Application Interoperability
This module describes how to
invoke functions that are implemented in unmanaged DLLs, and how to use
various techniques for integrating Component Object Model (COM)
components into managed applications. It also explains how to make
managed components that are built by using the .NET Framework available
to unmanaged COM client applications
Lessons
- Using the Platform Invoke Service
- Integrating COM Components into a .NET Framework
Application
- Integrating Managed Components into an Unmanaged
Application
Lab : Application Interoperability
- Integrating Unmanaged Functions into a Managed
Application
- Integrating a COM Component into a Managed
Application by Creating an Interop Assembly
- Integrating a COM Component into a Managed
Application by Using Late Binding
- Manually Creating an Interop Assembly for a COM
Component
After completing this module, students will be able to:
- Use the
Platform Invoke service to incorporate unmanaged functions into a
.NET Framework application.
- Integrate
unmanaged COM components into a .NET Framework application.
-
Incorporate components that are built by using the.NET Framework
into unmanaged applications.
Module 11: Reflection, Metadata, and Emitting
Objects (Optional)This module describes how
to use the classes in the .NET Framework 2.0 class library to examine a
program, alter the behavior or structure of the program as it runs, and
create and run new code.Lessons
- Reflecting on Objects
- Adding Assembly Metadata
- Emitting Objects by Using Builder Classes
Lab : Creating an Add-in Framework by Using
Reflection
- Creating a Custom Attribute to Decorate Add-in
Classes
- Using Reflection to Discover the Add-in Classes
- Creating a Mapping from Columns to Properties
- Creating a Dynamic Method to Set a Property
Value
- Invoking the Row Handler
After completing this module, students will be able to:
- Explain and use reflection in .NET Framework
applications by using the System.Reflection
namespace.
- Describe and create application metadata.
- Describe and create Microsoft intermediate
language (MSIL) and portable executable (PE) files by using the
System.Reflection.Emit namespace.
|
