Overview:
This three-day instructor-led workshop will provide you with the knowledge and skills to develop distributed applications by using the Microsoft ( .NET Framework and Microsoft Visual Studio 2005. It focuses on building distributed applications by using Web services, remoting, Microsoft Message Queuing, and serviced components.
Learning Method:
This course will be presented in a lecture/tutorial sessions using a combination of lectures, group discussions and practical exercises. Each student will be provided with a comprehensive set of course notes. Hands-on learning combines exercises and practical work to solidify topics presented.
Who will benefit from this course?
This course is intended for corporate and Independent software vendor application developers who have a desire to learn more about specific technology areas in distributed application development.
Pre-requisites
Before attending this course, you must:
- be able to manage a solution environment using the Visual Studio 2005 Integrated development environment (IDE) and tools
- understand the Microsoft .NET Framework 2.0 and the Common Language Runtime
- be able to program an application by using a .NET Framework 2.0-compliant language
- know how to make assemblies available to other applications
- have a basic understanding of XML including XML declaration, elements, attributes, and namespaces
- have a basic understanding of application domains
- have a basic understanding of delegates and events
- have a basic understanding of threads
What can you expect to gain from this course?
After completing this course, you will be able to:
- build and use a Web service
- configure and customise a Web service application
- call Web methods asynchronously
- build remote client and server applications
- create and serialise remoteable types
- manage the lifetime of remote objects
- call remote methods asynchronously
- implement remote events
- send and receive messages by using Microsoft Message Queuing
- create and use serviced components
Course Content:
Module 1:Building and Consuming a Simple XML Web Service
- This unit describes how you can create a simple Web service and client application by using the .NET Framework. It also explains how you can configure client proxies, and debug and deploy Web services.
- Technical Context of Web Services
- Components of Web Service Technology
- Lab 1:Building and Consuming a Simple Web Services
- Exercise 1:Creating a Web Service and Client
- Exercise 2:Working with the Client Proxy
- Exercise 3:Deploying a Web Service and Configuring a Client
- Exercise 4:Debugging and Exception Handling in Web Services
- Exercise 5:Determining Web Service Connectivity
Module 2:Configuring and Customising a Web Service
- This unit introduces a number of important configuration and customisation options for Web services. It describes how to control the way in which complex parameters to Web methods are serialised. This unit also shows how to use configuration files to control the way in which a Web service operates.
- XML Serialisation
- How to Use Complex Data Types in Web Services
- How to Use Attributes to Control Serialisation
- How to Use Service Configuration Attributes
- Configuration Files
- Lab 2:Configuring and Customising a Web Service
- Exercise 1:Creating and Using Custom Data Types
- Exercise 2:Customising the Web Service
- Exercise 3:Configuring the Web Service Using the Web.config File
Module 3:Calling Web Methods Asynchronously
- This unit explains how to call a Web method asynchronously. It describes how to improve the responsiveness of client applications by avoiding the need to wait for Web methods to complete execution before continuing processing. This unit covers the different options available for calling Web methods asynchronously and it describes how to create one-way methods.
- The Need for Asynchronous Calls
- Options for Making Asynchronous Calls
- One-Way Methods
- Lab 3:Calling Web Methods Asynchronously
- Exercise 1:Using a One-Way Method
- Exercise 2:Calling a Web Method Asynchronously
Module 4:Building a Remoting Client and Server
- This unit describes key remoting concepts, and shows how to create a remoting server and client. This unit describes how to use remoting to call methods in remote objects, and how to pass data across remoting boundaries. This unit also shows how to configure and deploy remoting applications.
- Technical Context of Remoting
- Remoting Servers and Clients
- Important Components of Remoting
- Lab 4:Building a Remoting Client and Server
- Exercise 1:Implementing a Simple Remoting Client and Server
- Exercise 2:Passing Data by Value
- Exercise 3:Configuring Remoting Channels and Activation Modes Programmatically
- Exercise 4:Configuring Remoting Channels and Activation Modes with Configuration Files
- Exercise 5:Deploying and Debugging Remotable Classes
Module 5:Creating and Serialising Remotable Types
- This unit describes how to transfer complex data values across remoting boundaries, and the issues involved in doing so. It compares and contrasts the marshal by value and marshal by reference mechanisms for accessing remote data. This unit also covers version compatibility issues between clients and servers using different versions of a class, and the special requirements for remoting generic classes.
- Marshal by Value
- Marshal by Reference
- Version Compatibility for Remotable Types
- Generic Classes
- Lab 5:Creating and Serialising Remotable Types
- Exercise 1:Using Serialisation Formatters
- Exercise 2:Using Marshal by Reference
- Exercise 3:Using Version Tolerant Serialisation
Module 6:Performing Remoting Operations Asynchronously
- This unit describes how to call a method asynchronously in the remoting environment. It covers the different techniques you can use and it explains how to raise events in a remoting server and handle them in a client.
- Asynchronous Methods
- Calling Remote Methods Asynchronously
- One-Way Methods
- Using Events in Remoting Applications
- Lab 6:Performing Remoting Operations Asynchronously
- Exercise 1:Calling Remote Methods Asynchronously
- Exercise 2:Raising and Handling Events in Remoting
Module 7:Managing the Lifetime of Remote Objects
- This unit describes the lifetime of remote objects and how you can control them. This unit introduces the concepts of remote object leases and sponsors. This unit shows how to initialise a remote object's lease to a specific period, and how to renew an object's lease when it expires by using a sponsor.
- Life Cycle of Remote Objects
- Lifetime Sponsors
- Lease Properties
- Leases and Exception Handling
- Lab 7:Managing the Lifetime of Remote Objects
- Exercise 1:Initialising the Lifetime of Remote Objects
- Exercise 2:Renewing the Lifetime of Remote Objects
Module 8:Sending and Receiving Messages by Using Message Queuing
- This unit describes how to use Microsoft Message Queuing to build distributed applications. It covers the essential aspects of building client and server applications that use message queues, how to create queues, how to send and receive messages, and how to handle replies to messages. This unit also describes how to access message queues across the Internet.
- Understanding Message Queuing
- Creating a Message Queue and Sending a Message
- Receiving a Message and Posting a Response
- Using IIS with Message Queuing
- Lab 8:Sending and Receiving Messages by Using Message Queuing
- Exercise 1:Building a Simple Messaging Client and Server
- Exercise 2:Using More Complex Data Types and Formatters
- Exercise 3:Using Response Queues and Time-Outs
- Exercise 4:Placing Messages on a Queue by Using IIS and HTTP
Module 9:Creating and Consuming Serviced Components
- This unit explains how to build and access serviced components in a .NET Framework application. This unit describes the relationship between .NET Framework serviced components and COM+. It shows how to use the .NET Framework to implement a serviced component that you can register as a COM+ application and how you can write applications that use serviced components.
- COM+ Services
- Implementing a Serviced Component
- Registering a Serviced Component
- Instantiating a Serviced Component
- Lab 9:Creating and Consuming Serviced Components
- Exercise 1:Creating and Using a Serviced Component
- Exercise 2:Using Enterprise Services in a Serviced Component