Enterprise Development
with .NET
In this course, you’ll
learn about the services offered by Enterprise Services and when
to use them. You’ll see how to use asynchronous programming and
threading in your applications, and how to use transactions to
prevent data corruption while reducing coding effort. The course
shows you how to use MSMQ and Queued Components to create client-server
applications that work even when the client and server are disconnected.
You’ll also learn how to manage scarce resources with the Dispose
pattern and object lifetime options such as pooling and just in
time activation.
This course is focused
on the “back end” part of enterprise programming, not the user
interface. The sample applications are Windows applications, to
keep the pre-requisites to a minimum. You’ll be able to use these
same concepts as the back end to a web (ASP.NET) application as
well.
Topics Covered:
Identify the Enterprise
Services that may be useful for a particular application.
Use asynchronous programming and threading to speed the response
time of your applications.
Use COM components from a .NET application and .NET objects
from a COM application.
Add transaction support to an enterprise application.
Use Message Queuing and Queued Components to write distributed
applications that are more robust and available.
Manage scarce resources and object lifetimes.
Prerequisites:
In order to understand some of the problems and dilemmas that
present to a developer creating an enterprise application, you
should be an experienced programmer (in any language). The course
uses Visual Basic .NET, so you should already be comfortable with
the .NET Framework and coding in Visual Basic .NET, including
how to compile and run applications in Visual Studio .NET.
Introduction to
Enterprise programming
- Characteristics
of an Enterprise Application
- Asynchronous Programming
and Threading
- Interoperability
and Reuse
- Transactions
- Security
- The "ilities"
Asynchronous Programming
- Advantages of Asynchronous
Programming
- The BeginSomething
and EndSomething Function Calls
- The Sample Application
- Calling a Begin
Function and Setting Up Notification
- Calling an End
Function
- Calling a Web Service
Asynchronously
Threading
- Threading Concepts
- Starting a Thread
- Passing Parameters
to a Thread
- Getting Answers
from a Thread
- Updating Form Values
from the New Thread
- Marshalling to
the Form Thread
- Thread Priorities
- Stopping a Thread
- Preventing Collisions
Enterprise Services
Overview
- What Are Enterprise
Services?
- Is COM Dead? Is
COM+ Dead?
- What Is a Serviced
Component?
- The Global Assembly
Cache
- Interop: COM Calling
.NET
- Deploying a COM
Project that Calls .NET
- Interop: .NET Calling
COM
- Interop: Pinvoke
Transactions
- Transaction Concepts
- Context
- A Transaction Example
- Using Transactions
- Ending a transaction
Role-Based Security
- What Is Role-Based
Security?
- Checking Roles
in Code
- Demanding Roles
with Attributes
- Establishing Roles:
Windows User Groups
- Enterprise Services
Roles
- Establishing Roles
with Component Services
Controlling Object
Lifetime
- Resource Management
and Dispose()
- Object Pooling
- Just in Time Activation
- Synchronization
- Lifetime Sample
- Combinations of
Enterprise Services Attributes
Wrapping a Legacy
App as a Web Service in COM+
- Why use COM+ to
Expose a Web Service?
- Using Component
Services to Expose a Web Service
- Requesting SOAP
Support
- Using the Wrapped
Component
Messages with MSMQ
- What Is MSMQ?
- Setting Up a Queue
- Sending a Message
to a Queue
- Processing a Message
from a Queue
- MSMQ Acknowledgments
- More Reliability
Features
- MSMQ and Transactions
Components
- What Are Queued
Components?
- Sample Application
- Creating the Component
and the Interface
- Accessing the Recorder
from a Client
- Handling Errors
- Loosely Coupled
Events
Considerations
for Scalability, Reliability, and the Other "ilities"
- High-Performance
Enterprise Applications
- Availability
- Maintainability
- Manageability
- Performance
- Reliability
- Scalability
- Security
