CONTENTS:-

1.Transactions & COM+

2.Serialization&Deserialization
3.Remoting
4.Tracing
5.Webservices
6.Configuration Settings
7.Queued Components

1.TRANSACTIONS AND COM+:-

What is COM?

Component Object Model (COM) is a Microsoft standard for developing component

based software. COM provides :

 A defination - or model- for an object

 Services for creation and destruction of the object
 Services for communication between client and server

COM reuses the code in binary form. This makes it possible to write the component
with different tool and use it in some other tool.

The term COM means many different things to many people. One one hand it can be
defined as
A specification for writing reusable software that runs in component based
systems.
On the other hand it can be defined as
It’s a Sophisticated infrastructure that allows clients and objects to communicate
across a process and coputerboundaries.
COM allows to create objects across the network
COM is based on OOP.COM exploits the OOPs Paradigm to achive higher levels of
reuse and maintainability that is possible with other models of binary reuse.
COM programming model is based on distribution of class code in binary
components,this means COM can be reused without any dependencies on source
code.
COM is founded on the Idea of Interface Based Progarming.An interface , like a
class, is a distinct datatype.Itdeines a set of public methods without including any
implementation. In other sense, an Interface defines a very specific protocol for the
communication that occurs between a client and an Object.It allows developers to do
manythings that would be otherwise be impossible.

What are Advantages of COM?

  Binary code reuse : You can write and use your COM components with
different COM complient development tools like VB, VC++,Delphi etc.
 Cross-platform development : Eventhough Windows is the ultimate platform
for COM development. COM can be used for other platforms also. Some
vendors are providing support for UNIX.
 Version Control : COM components are said to be self-versioning. You can
install multiple versions of same COM component on the same machine.Your
older applications continue to wotk the same way and you are free to utilize
new functionality of the component for new applications

What are interfaces?

Interface is a set of properties and methods through which client and server
component communicate with each other. Interfaces just provide details like method
name, its parameters , return type etc. and not the actual implementation of the
method. If you are a VB programmer then you can look at it this way- each class
within your EXE or DLL(which is a set of properties and methods) project represents
an interface.

What are the requirements of a COM component?

To be recognised as a COM component all the objects must satisfy following

conditions :

 The object must be able to keep track of no. of connections made to it

 The object must be capable of being queried by client for the methods or
properties.

This functionality is provided by an interface called IUnknown. This interface has

following methods :

 AddRef : called when a new client connects to it i.e. when you say Set
x=new ...
 Release : called when the object is destroyed i.e. when you say Set x=nothing
 QueryInterface : which can query for methods supported by the object. VB
does this automatically when you say Set x=new...

What are different types of COM components in VB?

 ActiveX DLL
 ActiveX EXE
 ActiveX Controls

 ActiveX Documents
 What are in-process components ?

In process components are ActiveX DLLs which run in the same address space as that
of client. The communication between client and in-process server is fast but if the
server crashes it can also cause the client to crash.

What are out-of-process components?

Out-of-process components are ActiveX EXEs which run in their own address space.
The communication between client and out-of-process server is slow because of
marshalling. If the server crashes the client can still continue to function as the two
processes are different.

What is marshalling?

When a client calls a method from out-of-process server component the required
parameters need to be sent across process boundries. Packaging and transporting of
all parameters and return values between client and server is known as Marshalling.

What is instancing of a component?

When you open an ActiveX DLL or EXE project each class has a designtime property
called Instancing. This property determines how your objects will be created. There
are three main catagories :

 Single use : in which case each requesting client is provided with new copy of
the component
 Multi use : in which case multiple clients share the same instance of the
component
 PublicNotCreatable : this means instance of your component can not be
created directly by 'New' or 'CreateObject' but some other component returns
one to you(generally as return value from a function).

What is most efficient way to create objects?

In VB you can create objects using following methods :

 dim x as new myclass

 dim x as myclass
set x=CreateObject("progID")
 dim x as myclass
set x=new myclass
Out of these methods the first method is least efficient and you should actually never
use it(unless you are doing testing etc.)

The second method uses standard COM services and is the only way to use in
scripting languages like VBScript. If you are coding in VB and creating multiple
instances of same class then try using last method instead

The last method also uses standard COM services but is optimised for creating
multiple objects of same class. Thus it is the most efficient.

How do I provide events to my class?

There are four basic steps in designing and using an event :

 Declare an event in your class

public Event myevent(param1 as integer)
 Raise event in some of the method of the class
RaiseEvent myevent(100)
 Now, at client side declare object of your class
dim WithEvents x as new myclass
 Write code to handle myevent event
public sub myevent(param1 as integer)
msgbox param1
end sub

What is RPC?
COM ‘s Support for distributed applications is based on an Interprocess Mechanism
Names RemoteProcedureCall(RPC).RPC is an Industry standard that has matured on
many platforms.

COM and RPC have a symbolicRelationship.COM offers RPC an Object oriented feel
and RPC offers COM the ability to serve up objects from across network.COM
leverages RPC to transparently call methods on remote computers by sending request
and response pockets between clients and objects and how clients still invoke method
as usual, as if objects were near by.
What is MTS?
Microsoft Transaction Server allows middle tier objects running on windows NT
server to run and control distributed transactions from the middletier.MTS added lots
of critical infrastructure support that wasn’t included with COM .In particular it added
new support for Distributedtransactions,Integratedsecurity,threadpooling and
Improved configuration and administration.

MTS Extended COM’s security model .The rolebased security model of MTS
Provides more flexibility and Granularity than the original security model provided by
COM.A role is an abstraction that represents a security profile for one or more users
in an MTS application. At design time , a developer can setup security checks using
roles in either declarative or programmatic fashion.At Deployment time ,an
administrator maps a set of roles to user accounts and group accounts inside a
windows NT domain.
Another significant feature that MTS added to the platform was a scheme to manage
concurrency by conducting thread pooling thread pooling behind the scenes.MTS
introduced an abstraction called an Activity which represents a logical thread of
execution in an MTS application. MTS programmers should write their applications
to provide one activity per client application. The MTS runtime automatically binds
logical activities to physical threads. Once the number of clients reaches a predefined
threshold ,the MTS runtime begins sharing individual threads across multiple clients.
Multitier applications that use a thread pooling scheme scale better than those that use
a single threaded model or thread –per-client model.A Single thread model removes
any chance of concurrency because it can’t execute ,methods for two or more clients
at the same time.A Thread-per-Client model results in unacceptable resource usage in
larger applications because of the ongoing need to create and tear down physical
threads.Thread-pooling schema create an optimized balance between higher levels of
Concurrency and more efficient resource usage.

What is Attributed based programming?

MTS introduced a very important concept to the platform’s programming model:
Attribute-based Programming. In this Services provided by patform are exposed
through declarative attributes. Attribute settings are determined by programmers at
deign time and can be reconfigured by administrators after an application has been put
into production.
Attribute based programming is very different from the way that most Operating
Systems have exposed system services in past. Traditionally , Operating systems have
exposed services through a set of functions in a call-level application programming
interface(API).In this model , an application leverages system services by making
explicit calls to the API. This means that you must compile explicit system-level
calls into your application. If you want to change the way you use a system service
after an application is already in production, you must modify your code and
recompile the application. A programming model based on declarative is much more
flexible.

For eg A Component in an MTS Application has an Attribute that tells the MTS
Environment whether it supports transactions. If a programmer marks a component
to require transaction, Objects instantiated from the components are created inside the
context of a logical MTS Transaction. When a client calls one of these transactional
objects ,the MTS runtime automatically makes a call to start a Physical Transaction. It
also makes the appropriate call to either Commit or rollback transaction.
The point is that programmer never make explicit calls to start ,Commit, or Abort a
Transaction.All the necessary calls are made behind the scenes of MTS Runtime.
What is the Attributed based programming model better than the older
procedural model, which requires explicit API calls?

1.The new model requires Less Code and You indicate your preferences at design
time by setting attributes and the underlying runtime makes sure your needs are met.
2.That Administartors can easily reconfigure the way application uses a system
service.
What is Interception?
The Attribute based programming model of MTS relies on a mechanism known as
Interception.When a client creates an object from a component that has been
configured in an MTS application , the underlying runtime inserts an interception
layer .The interception layer represents a hook that allows the MTS runtime to
perform system supplied preprocessing and PostProcessing on method calls.The
system steals way control right before and after an Object executes the code behind
each method.
NB:- COM has its own Programming model and runtime layer.
MTS has a different programming model and a separate runtime layer.
But you could see that MTS is simply a layer that has been built on top of COM.

What is COM+? What are its features?

All the best ideas of COM and MTS have been integrated into a new runtime named
COM+.
Like COM, COM+ is based on binary components and Interface-based programming.
(1)Method calls are remoted across process and computer boundaries through the use
of a transparent RPC Layer(2). And like COM ,COM+ components can be upgraded
and extended in production without adversily affecting the client applications that use
them(3)

Like MTS,COM+ supports distributed Transactions(1) and Role-based security(2).It

provides built in Thread pooling scheme as transparent as MTS(3).The COM+
programming model also uses Interception to expose platform services to developers
through declarative attributes(4).Hower,COM+ takes attribute programming much
faster than MTS. In addition to transactional services and integrated security,COM+
exposes services such as CustomObjectContruction(5),Synchronization(6) and
ObjectPooling(7).Other new features such as QueadComponents (8)and COM+
Events(9) are Also Exposed Through Configurable attributes.

What is Configured Component?

A component that has been installed in a COM+ Application is known as a
Configured Component, primarily because it has associated COM+ attribute settings.

If you want your components take advantage of COM+ services, you must install
them in a COM+ application. When a component is installed in a COM+ application,
its given a profile in a system catalog called COM+
registrationDatabase(RegDB).The catelog holds configured attribute settings for
components as well as for COM+ applications.
What is Non-Configured Component?
The components that doesn’t have associated COM+ attributes are known as Non-
Configured Component. Theses components are not installed in COM+ applications.
Instead they registered in a manner consistent with earlier vertions of COM.These
components can’t take advantages of COM+Services.
Eg ADO(Activex Data Objects)

What are COM+ Services?

1.Automatic Transaction Processing
2.Just-in-time activation
3.Loosly-coupled events.
4. Object contruction
5. Object pooling
6. Queued components
7.Private Components
8.Role Based Security
9. SOAP services
10.Synchronization

What is Automatic Transaction Processing?

Automatic Transaction Processing is a service provided by COM+ that enables you

to configure a class at design time to participate in a transaction at runtime.To use
this service the class must derive directly or indirectly from the
System.EnterpriseServices.Serviced Component class.

What is Transaction TimeOut?

COM+ allows you to specify a different Transaction timeout for each class that
requies a transaction. You can use this to resolve conflicting time-out scenarios,
Such as forcing short transactions versus allowing long-running batch stored
procedures.

<Transaction(TransactionOption.Required,_Isolation:=
TransactionIsolationLevel.serializable,Timeout:=10>

What is Transaction?
A transaction is a set of related tasks that either succeed or fails as a unit.
In transaction Processing Terminology, the transaction either commits or fails as a
unit. For a transaction to commit, all participants must guarantee that any change to
data will be permanent.
What are ACID Properties?

The term ACID Conveys the role transactions play in applications.

ACID stands for Automicity, Consistency, Isolation and Durability.

Automicity:-
A Transaction is a unit of work in which a series of Operations occur between the
BEGINTRANSACTION and ENDTRANSACTION statements of an application. A
Transaction executes exactly once and is Automic-all the work is done or none of it
is. Operations associated with a transaction usually share a common intent and are
Interdependent.

Consistency:-

A Transaction is a unit of integrity because it preserves the consistency of Data,

Transforming one Consistent state of data into another consistent state of data.
Some of responsibility for maintaining consistency falls to the application developer
who must make sure that all known integrity constraints are enforced by the
application.

Isolation:-
A transaction is a unit of Isolation-Allowing concurrent transactions to behave as
though each were the only transaction running in the system.
Isolation requires that each transaction appear to be the only transaction manipulating
The datastore,even other transactions may be running at the same time.
A transaction never sees the intermediate stages of another transaction.

Transactions attain the highest level of isolation when they are serializable. At this
level, the results obtained from a set of Concurrent transactions are identical to the
results obtained from set of concurrent transactions are identical to the results
obtained by running each transaction serially. Because a high degree of isolation can
limit the number of Concurrent transactions, some applications reduce the isolation
level in exchange for better throughput.

Durability:-

A Transaction is also a unit of recovery. If a transaction succeeds, the system

guarantees that its updates will persist, even if the computer crashes immediately after
the commit. Specialized logging allows system’s restart procedure to complete
unfinished operations, making transactions durable.

What are Transaction Boundaries?

A Transaction boundary defies the scope of a transaction.Objects inside a transaction
boundary share a common Transaction Identifier.

As transaction executes, various transaction-aware resources may participate in the

transaction. For example , if within the scope of transaction , your application
connects to a database, the transaction flows to that resource and extends the
transaction boundary to include the database server.
You control over Transaction boundary varies depending on the transaction model
you select for your application. Manual or Automatic.
In Manual Transaction you control transaction boundaries with explicit instructors
to begin and end the transaction. From one transaction boundary , you can begin a
second transaction, called a nested transaction. The parent transaction doesnot commit
until all its subordinate transactions commit.
An Automatic Transaction manages transaction boundaries for you, based on a
declarative attribute set for each component.A transaction automatically flows to
objects instructed to participate in a transaction and by passes objects instructed to
execute outside a transaction. You cannot nest transactions when using the automatic
transaction model.

What are Distributed Transactions?

Distributed Transaction Processing (TP) systems are designed to facilitate
transactions that span heterogeneous, transaction-aware resources in a distributed
environment. Supported by a distributed TP system, your application can combine
into a Transactional unit such diverse activities as retrieving a message from a
MicrosoftMessageQueing(MSMQ) queue, storing the message in a Microsoft SQL
Server database, and removing all existing references to the message from an Oracle
Server database.Because they span multiple data sources, its important that
distributed transactions enforce ACID Properties to maintain data consistency across
all resoucrces.

A Distributed TP system consists of several cooperating entities as mentioned below.

These entities are logical and can reside on the same computer or on different
computer.

a)Transaction Processing(TP) Monitors:-

A TP monitor is software that sits between a transaction-aware application and a

collection of resources. It maximizes operating system activities, streamlines network
communications and connects multiple clients to multiple applications that potentially
access multiple data sources.

Instead of writing an application that manages a multi-user, distributed environment,

you write an application that consists of a single transaction requests.The monitor
scales your application as required.
The Distributed Transaction Coordinator(DTC) is the TP Monitor for Microsoft
Windows2000.

b)Transaction Managers:-

In a distributed transaction, each participating resource has a local transaction

manager(TM) to track incoming and Outgoing transactions on that computer.
The TP monitor assigns one TM the additional task of coordinating all activities
among local TMs. The TM that coordinates transaction activities is called the roof or
coordinating TM.
A TM coordinates and manages all transaction processing functions, but it is not
equipped to manage data directly. Resource managers handle data related activities.

c)Resource Managers:-

A Resource Manager is a system service that manages persistent or durable data in

databases, durable message queues, or transactional file systems. The resource
manager stores data and performs disaster recovery.

SQLServer,Orcale,sybase,Informix,IBM(for IBM DB2),Ingres and MSMQ provide

resource managers that participate in distributes transactions.

d)Resource Dispensers:-

A Resource dispenser manages nondurable state that can be shared.For Example the
ODBC resource dispenser manages pools of database connections, reclaiming each
connection when it is no longer needed.
NB:-For a .NET Framework object to participate in an automatic transaction, the
.NET framework class must be registered with windows 2000 component services.
What are Different Transaction Models?
a)Automatic Transaction Model
b)Manual Transaction Model

NB:- MTS,COM+1.0 and the Common Language runtime support the same
automatic distributed transaction model. Once ASP.NET page, XML
WebServiceMethod or .NET Framework class is marked to participate in a
transaction, it will automatically execute within the scope of a transaction.

How Automatic Transactions Work?

The Declarative transaction attribute specifies how an object participates in a
transaction, and is configured programmatically. Although this declarative level
represents the logic of a transaction, it is one step removed from the physical
transaction. A physical Transaction occurs when a transactional Object accesses a
data source, such as a database or message queue. The Transaction associated with the
Object automatically flows to the appropriate resource manager. An associated
driver, such as OLEDB , ODBC or ADO looks up the transaction in the Object’s
context and enlists in the transaction through the Distributed Transaction
Coordinator(DTC).The entire physical Transaction occurs automatically.

What are the Transaction Directives available in ASP.NET?

Directive Description
Disabled Indicates that the transaction context will be ignored by
ASP.NET. This is the default transaction state.
NotSupported Indicates that the page does not run within the scope of
transactions. When a request is processed, its object
context is created without a transaction, regardless of
whether there is a transaction active.
Supported Indicates that the page runs in the context of an existing
transaction. If no transaction exists, the page runs
without a transaction.
Required The page runs in the context of an existing transaction. If
no transaction exists, the page starts one.
RequiresNew Indicates that the page requires a transaction and a new
transaction is started for each request.

You can indicate the level of transaction support on a page by placing the directive in
your code. For example, you can ensure that the page activities always execute in the
scope of a transaction by inserting the following directive.

<%@ Page Transaction="Required" %>

If you omit the transaction directive, transactions are disabled for the page.
What are the Transaction Directives available in ASP.NET?
ASP.NET provides built-in support for creating and exposing XML Web services
using a programming abstraction that is consistent and familiar to Web Forms.

XML Web services provide to you the option of running your code within the scope
of an automatic transaction. A transaction ensures that all interactions with resource
managers such as SQL Servers, MSMQ Servers, Oracle Servers, and SNA Servers
maintain the ACID Properties required to run robust distributed applications.

You can declare an automatic transaction by using the TransactionOption property of

the WebMethod attribute. Setting the TransactionOption property to
TransactionOption.RequiresNew begins a new transaction each time a XML Web
service client calls the XML Web service method.

What are the Transaction Attributes available in .NET?

Attribute value Description

Disabled Eliminates the control of automatic transactions on the
object. An object with this attribute value applied can
engage the Distributed Transaction Coordinator (DTC)
directly for transactional support.
[Transaction(TransactionOption.Disabled)]
NotSupported Indicates that the object does not run within the scope of
transactions. When a request is processed, its object
context is created without a transaction, regardless of
whether there is a transaction active.
[Transaction(TransactionOption.NotSupported)]
Supported Indicates that the object runs in the context of an existing
transaction, if one exists. If no transaction exists, the
object runs without a transaction.
[Transaction(TransactionOption.Supported)]
Required Indicates that the object requires a transaction. It runs in
the scope of an existing transaction, if one exists. If no
(default) transaction exists, the object starts one.
[Transaction(TransactionOption.Required)]
RequiresNew Indicates that the object requires a transaction and a new
transaction is started for each request.
[Transaction(TransactionOption.RequiresNew)]

2.SERIALIZATION AND DESERIALIZATION:-

What is Serialization?
Serialization is the Process of Converting an Object into a stream of Bytes, that can be
persisted or transported.
What is De Serialization?
De Serialization is the process of Creating an Object from a stream of Bytes.
Serialization and Deserialization are mostly used to transport Objects(Eg. During
Remoting) or to Persist Objects(Eg. To a file or
Database).
What are Different Types of Serialization Technologies?
The .NET Frame work features two serializing technologies.
1.Binary Serialization
2.XML Serialization/Soap Serialization
1.Binary Serialization:-
Binary Serialization Preserves Type Fiedelity, which is useful for preserving the state
of an object between different invocations of an application. During this process , the
public and private fields of the object and the name of the class, including the
assembly containing the class is converted to a stream of bytes, which is then written
to a data stream. Remoting uses binary serialization to pass objects “by value” from
one computer, or application domain to another.

2.XML Serialization:-
XML serializes public properties and fields of an Object , or the parameters and
return values of methods, into an XML stream that conforms to a specific XML
schema Definition Language(XSD) document and does not preserves type fidelity.
This is useful when you want to provide or consume data without restricting the
application that uses the data. Because XML is an Open standard, it is an attractive
choice for sharing data across the web. It serializes the class that implement
ICollection or Ienumerable , XMLelement objects,xmlNodeObjects and Dataset
Objects.
XML serialization can also be used to serialize objects into XML Streams that
conform to the SOAP specification. SOAP is a protocol based on XML, designed
specifically to transport procedure calls using XML. Webservices uses XML
serialization.
XMLSerializer class is used for this.

XMLSerialization is slow as there is a once-per-process-per-type overhead with

XMLSerializer.
3.REMOTING:-
What is Remoting?
Under .NET framework Remoting provides an infrastructure for developing and
using distributed components. Using remoting multiple AppDomains can talk with
each other.
What are PROXYOBJECTS?
While developing a distributed application the underlying framework should provide
transparent programming model to the application developer. Proxies play major role
in this area. The proxy object acts as a 'dummy' of the remote object and forward all
the method calls to the remote object instance. These proxy objects are created at
client end (here client simply means a component which is calling the remote object).
The client is unaware of the actual location of the remote object and it simply calls the
methods on the proxy object which are then forwarded to the actual object.
How Activation of RemoteObjects Takes Place?
The remote objects can be activated in two ways

 Server Activation
  Client Activation

In the server activation managing the life time of the remote object is not in the hands
of client where as client activation involves life time management of the remote
object. The server activated objects are of two types:

 Single call objects : These objects are state less objects i.e. they do not
maintain state across method calls
 Singleton objects: These objects share the same instance of object among
various clients and also maintain state across method calls. Here various
clients share the same state information.

Client Activated Objects are created for individual clients and can store state
information between method calls for that specific client.

What is Leased based life time?

We just mentioned that the client activated objects can control the life time of the
remote objects. The mechanism by which it happens is called as Leasing. The remote
objects have a default lease period. When the lease expires the object is garbage
collected. The client can control the lease period by following ways:

 The server object can set its lease time to infinity

 The client can renew the lease of the object
 The client can make use of a sponsor which in turn requests a lease renewal

What are Formatters?

The communication between the client and remote object involves method parameters
and return values. This data must be serialized before it is sent across the network.
The serialization process creates a persistent copy of the data as a sequence of bytes.
The process of converting these bytes back into the original data structure is called de-
serialization. .NET remoting framework provide special objects for performing this
serialization and de-serialization. They are called as Formatters. Formatters are
available in following namespaces:
System.Runtime.Serialization.Formatters.Binary
System.Runtime.Serialization.Formatters.SOAP
As the names suggest Binary formatter deals with data in binary format while SOAP
formatter deals with data in XML format.

What are Channels?

To communicate with remote object we need a path through which the data transfer
can take place. This path is called as Channel. There are two types of channels:

 TCP channels : As the name suggestes these channels us TCP for

communication. TCP channels typically carry data in binary form i.e. they use
Binary formatters
  HTTP Channels : These channels use HTTP for communication. They
typically carry SOAP messages i.e. they use SOAP formatters.

TCP channels with Binary formatters are suitable where speed and performance is
important where as HTTP Channels with SOAP formatters are suitable for platform
independent or over the web communication. The channels are available in following
namespaces:
System.Runtime.Remoting.Channels.TCP
System.Runtime.Remoting.Channels.HTTP
You can create your own channels for gaining more control over the transmission
process.

How it works?

When the client application communicates with the remote object following steps are
involved:

At Server Side

 A Channel is established at a specific port which will listen all the client
requests
 Remote object registers itself with remoting framework and declares its
presence over the network

At Client Site

 Client establishes a channel at a specific port to talk with remote object

 Client creates an instance of remote object by calling Getobject or
CreateInstance or new method.
 Client gets the proxy for the remote object
 Client calls remote object methods on the proxy

What is Microsoft Transaction Server?

 MTS is a middle-ware from Microsoft

 In a n-tire system middleware sits between your business components and
client application. It handles all the client requests for the components
 MTS is a component-based transaction processing system for building,
deploying, and administering internet and intranet server applications
 MTS manages resorses like database connections, threads etc. for your
components

What are main parts of systems built around MTS?

 Application components
  MTS executive
 Server processes
 Resource managers
 Resource despensers
 MS-DTC
 MTS explorer

What are application components?

Application components are custom components that you design to suit your business
needs. These components are in-process(DLL) components which run under the
control of MTS. If you are designing components using VB you must make them as
ActiveX DLLs with Apartment threading.

What is MTS executive?

 MTS Executive is a DLL that provides run-time services for MTS components
like thread and context management
 This DLL loads into the processes that host application components and runs
in the background

What is server process ?

A server process is a system process that hosts the application components. A server
process can host multiple components.

What are resource managers ?

 A resource manager is a system service that manages transactional data with

help of MS-DTC
 MTS supports resource managers that implement the OLE Transactions
protocol e.g. MS-SQL Server

What are resource despensers ?

Resource despensers manage system resources like database connections. MTS

provides two resource despensers :

 ODBC/OLEDB Resource Dispenser

 Shared Property Manager

What is MS-DTC ?
Microsoft Distributed Transaction Coordinator is a system service that coordinates
transactions. With MS-DTC MTS can handle transactions spanning more than one
machines. MS-DTC uses a two-phase commit protocol for transaction management.

What is MTS explorer ?

MTS explorer is a GUI for managing and administrating MTS components

How to create transactional components?

There are two steps in creating transactional components.

 Inside your component you need to add code which tells MTS weather
transaction is completed successfully or not
 You need to set the transaction attribute of the component inside MTS -
generally using MTS explorer.

What is Object Pooling?

Object pooling is nothing but recycling a certain number of objects among clients
requesting them. The client requests for an object. If no instance of the object is
available MTS will create a new instanced and give it to the calling client. The client
will use the object and inform MTS when done with the help of special methods.
MTS will not immediately destroy the object but keep it in 'object pool'. The same
instance of the object is supplied to other clients requesting for the same component.

Presently(ver 2.0) MTS do not provide object pooling but Microsoft has promised it
at some later date. Microsoft has also provided some interfaces which you can use for
this forward compatibility. Currently, MTS simply creates and destroys objects rather
than recycling them.

What is Connection Pooling?

Connection pooling is similar to object pooling but it applies to database connections

instead of object instances. MTS does provides connection pooling.

Or

Connection pooling is recycling of available database connections.Connection

pooling is always per user basis i.e. connections set by user A can not be used by user
B. Generally, a seperate NT account is create for use by MTS components.

What is general rule while using database connections?

Connect to database as late as possible and release the connection as early as possible

Why MTS components are generally built stateless?

Because of object pooling feature of MTS clients are not guareented that between
different method calls they will get same object instance. Naturally, storing properties
or state in such objects is useless. MTS provides alternative mechanism of state
management called 'shared property manager'

What are transaction attributes of MTS components?

There are 4 transaction attributes in MTS :

 Requires a transaction : the objects require a transaction. If transaction do not

exist a new transaction is started
 Requires a new transaction : A new transaction is always started for the object
 Supports a transaction : The object uses a transaction context only if one
already exists
 Does not support transaction : The object do not participate in transaction

You can set these attribute in MTS explorer or if you are working with VB6 you can
set the MTSTransactionMode property(which you can change later in MTS explorer)

How does a typical component is built with VB to work under MTS?

To create components with VB for MTS you should create ActiveX DLLs with
apartment threading model. The classes you create are similar to your normal class
modules with some limitations like :

 You should not use functions like MsgBox in the class as the class is running
on server and any call to such methods invokes the Msgbox at the server and
not at the client
 You should avoid storing state i.e. properties because of object pooling feature
of MTS( presently MTS do not support true object pooling but Microsoft has
promised it at later date)

What are Firehose cursors?

Firehose cursors are ADO recordset objects with following properties :

 Cursorlocation : aduseServer
 Cursortype : adOpenForwardOnly
 LockType : adLockReadOnly
 Cachesize : 1
When such cursors are created the recordset values are returned generally using
GetString or GetRows method of the recordset

What is disconnected recordset?

Disconnected recordsets are ADO recordsets with following properties

 Cursorlocation : adUseClient
 Cursortype : adOpenStatic
 LockType : adLockBatchOptimistic

Also, you need to set the activeconnection to nothing once you run the query.

set rs.ActiveConnection=nothing
set myfunction=rs

Note that update method on disconnected recordset updates records from the recordset
only. To update the changes to the database you must call updatebatch method.

What is object pooling?

Object pooling is an automatic service provided by COM+ that enables you to

configure a component to have instances of itself kept active in a pool, ready to be
used by any client that requests the component. You can administratively configure
and monitor the pool maintained for a given component, specifying characteristics
such as pool size and creation request time-out values. When the application is
running, COM+ manages the pool for you, handling the details of object activation
and reuse according to the criteria you have specified.

You can achieve very significant performance and scaling benefits by reusing objects
in this manner, particularly when they are written to take full advantage of reuse. With
object pooling, you gain the following benefits:

• You can speed object use time for each client, factoring out time-consuming
initialization and resource acquisition from the actual work that the object
performs for clients.
• You can share the cost of acquiring expensive resources across all clients.
• You can preallocate objects when the application starts, before any client
requests come in.
• You can govern resource use with administrative pool management—for
example, by setting an appropriate maximum pool level, you can keep open
only as many database connections as you have a license for.
• You can administratively configure pooling to take best advantage of available
hardware resources—you can easily adjust the pool configuration as available
hardware resources change.
• You can speed reactivation time for objects that use Just-in-Time (JIT)
activation, while deliberately controlling how resources are dedicated to
clients.
What is JIT(JustInTime) Activation?

Just-in-Time (JIT) activation is an automatic service provided by COM+ that can help
you use server resources more efficiently, particularly when scaling up your
application to do high-volume transactions. When a component is configured as JIT
activated, COM+ can deactivate an instance of it while a client still holds an active
reference to the object. The next time the client calls a method on the object, which
the client believes to be still active, COM+ will reactivate the object transparently to
the client, just in time.

The advantage of JIT activation is that you enable clients to hold references to objects
for as long as they need them, without necessarily tying up server resources—such as
memory—to do so. Other benefits include the following:

• From the client perspective, JIT activation greatly simplifies the programming
model—the client doesn't have to think about how it uses expensive server
objects and server resources. Without JIT activation, when clients are
aggressive about releasing server objects, they can incur a significant penalty
in frequently calling and releasing objects.

Note You can refine this performance benefit further by using object
pooling. By pooling JIT-activated objects, you can greatly speed object
reactivation for clients while reusing whatever resources they might be
holding. And doing this gives you more precise control over how much
memory is used by a given object on the server. For more detail, see Object
Pooling and JIT Activation.

• By holding long-lived object references, clients keep open the channel to the
object for as long as they need it. The farther the client is from the server, the
greater the benefits of JIT activation become—because without JIT activation,
the cost of activating and marshaling the server object, opening the channel,
setting up the proxy and stub, and so on is much greater. With distributed
applications, an expensive network round-trip is required with every object
creation. As the volume of client calls increases, you want to minimize the
frequency of object creation because it can significantly affect the
performance of your application.
• When you JIT activate those objects to which clients hold long-lived
references, but which they aren't necessarily using all the time, server memory
is not always tied up keeping those objects alive. With lazy activation,
memory is used only when the objects are actually needed. This can
significantly increase the scalability of your application. The only performance
hit that clients see is the time it takes COM+ to reactivate the object—usually
just marginally more than the time it takes to allocate memory for the object,
and substantially less than the network round-trip for remote object creation.

4.TRACING:-
5.WEBSERVICES:-
What platforms do .NET XML Web Services run on?
 Currently, they're supported on Windows 2000 and Windows XP.
ASP.NET integrates with Internet Information Server (IIS) and thus
requires that IIS be installed. It runs on server and non-server editions
of Windows 2000 and XP as long as IIS is installed.

Can two different programming languages be mixed in a single ASMX file?

No

What is code-behind in Webservices?

Code-behind allows you to associate Web Service source code written

in a CLR compliant language (such as C# or VB.NET) as compiled in
a separate file (typically *.asmx.vb). You would otherwise typically
find the executable code directly inserted into the .asmx file.

What event handlers can I include in Global.asax?

• Application_Start
• Application_End
• Application_AcquireRequestState
• Application_AuthenticateRequest
• Application_AuthorizeRequest
• Application_BeginRequest
• Application_Disposed
• Application_EndRequest
• Application_Error
• Application_PostRequestHandlerExecute
• Application_PreRequestHandlerExecute
• Application_PreSendRequestContent
• Application_PreSendRequestHeaders
• Application_ReleaseRequestState
• Application_ResolveRequestCache
• Application_UpdateRequestCache
• Session_Start
• Session_End

You can also include event handlers in Global.asax for events fired by
custom HTTP modules.

Note that not all of the event handlers make sense for Web Services.
For example, the Application_AuthenticateRequest and
Application_AuthorizeRequest events are designed to be used with
ASP.NET Forms authentication.

What namespaces are imported by default in ASMX files?

The following namespaces are imported by default. Other namespaces

must be imported manually.
 • System
• System.Collections
• System.ComponentModel
• System.Data
• System.Diagnostics
• System.Web
• System.Web.Services

What are ASHX files?

ASHX files contain HTTP handlers-software modules that handle

raw HTTP requests received by ASP.NET. They are requested
using URL http://.../hello.ashx?Name=Cindy, it returns "Hello,
Cindy" in the HTTP response. ASHX files provide developers with
a convenient way to deploy HTTP handlers without customizing
Machine.config or Web.config. ASHX files can also employ code-
behind just like ASPX and ASMX files.

If I want to charge for a Web service, how do I know who's calling it?

While there are probably many possible use models, the three most
likely are service agreement, subscription, and per-use.

With a service agreement, you and your clients sign agreements

indicating the terms of the service. These terms vary widely, as you
might imagine.

Subscriptions allow your clients to access the Web Service for a

given period of time or for a set number of invocations. Assuming
their account remains in good standing, you continue to allow them
to access your Web Service.

Per-use, of course, is billed each time the client uses the Web
Service.

What is WSDL?

WSDL is the Web Service Description Language, and it is

implemented as a specific XML vocabulary. While it's very much
more complex than what can be described here, there are two
important aspects to WSDL with which you should be aware. First,
WSDL provides instructions to consumers of Web Services to describe
the layout and contents of the SOAP packets the Web Service intends
to issue. It's an interface description document, of sorts. And second, it
isn't intended that you read and interpret the WSDL. Rather, WSDL
should be processed by machine, typically to generate proxy source
code (.NET) or create dynamic proxies on the fly (the SOAP Toolkit or
Web Service Behavior).
The Web Services Description Language (WSDL) currently represents the service
description layer within the Web service protocol stack.

In a nutshell, WSDL is an XML grammar for specifying a public interface for a Web
service. This public interface can include the following:

• Information on all publicly available functions.

• Data type information for all XML messages.
• Binding information about the specific transport protocol to be used.
• Address information for locating the specified service.

WSDL is not necessarily tied to a specific XML messaging system, but it does
include built-in extensions for describing SOAP services.

What is UDDI?

UDDI stands for Universal Description, Discovery, and Integration.

While UDDI is implemented as a series of Web Services that execute
against known UDDI repositories, you can imagine UDDI as being a
sort of "Yellow Pages" for Web Services. The repositories, maintained
by Microsoft, IBM, and Ariba, are designed to provide you with
detailed information regarding registered Web Services for all vendors.
You query the repositories for specific information and/or Web
Services as necessary to discover and ultimately use Web Services
provided by any number of vendors.

UDDI (Universal Description, Discovery, and Integration) currently represents the

discovery layer within the Web services protocol stack.

UDDI was originally created by Microsoft, IBM, and Ariba, and represents a
technical specification for publishing and finding businesses and Web services.

At its core, UDDI consists of two parts.

• First, UDDI is a technical specification for building a distributed directory of

businesses and Web services. Data is stored within a specific XML format,
and the UDDI specification includes API details for searching existing data
and publishing new data.
• Second, the UDDI Business Registry is a fully operational implementation of
the UDDI specification. Launched in May 2001 by Microsoft and IBM, the
UDDI registry now enables anyone to search existing UDDI data. It also
enables any company to register themselves and their services.

The data captured within UDDI is divided into three main categories:

• White Pages: This includes general information about a specific company. For
example, business name, business description, and address.
• Yellow Pages: This includes general classification data for either the company
or the service offered. For example, this data may include industry, product, or
geographic codes based on standard taxonomies.
 • Green Pages: This includes technical information about a Web service.
Generally, this includes a pointer to an external specification, and an address
for invoking the Web service.

What is a Web service?

Many people and companies have debated the exact definition of Web services. At a
minimum, however, a Web service is any piece of software that makes itself available
over the Internet and uses a standardized XML messaging system.

XML is used to encode all communications to a Web service. For example, a client
invokes a Web service by sending an XML message, then waits for a corresponding
XML response. Because all communication is in XML, Web services are not tied to
any one operating system or programming language--Java can talk with Perl;
Windows applications can talk with Unix applications.

Beyond this basic definition, a Web service may also have two additional (and
desirable) properties:

• First, a Web service can have a public interface, defined in a common XML
grammar. The interface describes all the methods available to clients and
specifies the signature for each method. Currently, interface definition is
accomplished via the Web Service Description Language (WSDL).
• Second, if you create a Web service, there should be some relatively simple
mechanism for you to publish this fact. Likewise, there should be some simple
mechanism for interested parties to locate the service and locate its public
interface. The most prominent directory of Web services is currently available
via UDDI, or Universal Description, Discovery, and Integration.
• Web services currently run a wide gamut from news syndication and stock-
market data to weather reports and package-tracking systems.

 What is new about Web services?

People have been using Remote Procedure Calls (RPC) for some time now, and they
long ago discovered how to send such calls over HTTP.

So, what is really new about Web services? The answer is XML.

XML lies at the core of Web services, and provides a common language for
describing Remote Procedure Calls, Web services, and Web service directories.

Prior to XML, one could share data among different applications, but XML makes
this so much easier to do. In the same vein, one can share services and code without
Web services, but XML makes it easier to do these as well.
By standardizing on XML, different applications can more easily talk to one another,
and this makes software a whole lot more interesting.

 What is the Web service protocol stack?

The Web service protocol stack is an evolving set of protocols used to define,
discover, and implement Web services. The core protocol stack consists of four
layers:

• Service Transport: This layer is responsible for transporting messages between

applications. Currently, this includes HTTP, SMTP, FTP, and newer
protocols, such as Blocks Extensible Exchange Protocol (BEEP).
• XML Messaging: This layer is responsible for encoding messages in a
common XML format so that messages can be understood at either end.
Currently, this includes XML-RPC and SOAP.
• Service Description: This layer is responsible for describing the public
interface to a specific Web service. Currently, service description is handled
via the WSDL.
• Service Discovery: This layer is responsible for centralizing services into a
common registry, and providing easy publish/find functionality. Currently,
service discovery is handled via the UDDI.

Beyond the essentials of XML-RPC, SOAP, WSDL, and UDDI, the Web service
protocol stack includes a whole zoo of newer, evolving protocols. These include
WSFL (Web Services Flow Language), SOAP-DSIG (SOAP Security Extensions:
Digital Signature), and USML (UDDI Search Markup Language). For an overview of
these protocols, check out Pavel Kulchenko's article, Web Services Acronyms,
Demystified, on XML.com.

Fortunately, you do not need to understand the full protocol stack to get started with
Web services. Assuming you already know the basics of HTTP, it is best to start at the
XML Messaging layer and work your way up.

 What is XML-RPC?

XML-RPC is a protocol that uses XML messages to perform Remote Procedure Calls.
Requests are encoded in XML and sent via HTTP POST; XML responses are
embedded in the body of the HTTP response.

More succinctly, XML-RPC = HTTP + XML + Remote Procedure Calls.

Because XML-RPC is platform independent, diverse applications can communicate

with one another. For example, a Java client can speak XML-RPC to a Perl server.

What is SOAP?

SOAP is an XML-based protocol for exchanging information between computers.

Although SOAP can be used in a variety of messaging systems and can be delivered
via a variety of transport protocols, the main focus of SOAP is Remote Procedure
Calls (RPC) transported via HTTP. Like XML-RPC, SOAP is platform independent,
and therefore enables diverse applications to communicate with one another.

6.CONFIGURATION SETTINGS:-

a)TRACE:-

Trace element allows you to enable or disable application-wide tracing as well as set the
parameters for the tracing functionality. When tracing is enabled, you can review information
about requests received by the Web Server with the special URL
http://<servername>/<appname>/trace.axd.

<trace
enabled=”true|false”-1
localOnly=”true|false”-2
pageOutput=”true|false”-3
requestLimit=”integer”-4
traceMode=”SortByTime|SortByCategory”-5 />

1.False-Default
2.Determines whether trace information is viewable by computers other than local webserver.
True-Only from Local Webserver—Default
False-From Any machine.
3.Determines whether trace output is appended to each ASP.NET page in the application or is
available only through trace.axd.(false)—Default
4.Determines the number of requests that are stored for review through the trace.axd URL.once
this limit has been reached then the current trace must be cleared by browsing trace.axd in order
to collect information on additional requests. The Default is 10, but higher this number ,the more
overhead is involved in tracing.Set this number as small as feasible.
5.Determines the sort order of the requests stored.
SortByTime-Sorts trace information by the order in which events are processed- Default
SortByCategory-Sorts trace information by Alphabetically by category.
This is very useful while using Trace.Write method, for grouping statements using the same
category argument.

b)globalization:-

<globalization> element controls globalization settings for ASP.NET

applications.This includes the encoding used for requests,responses and files as well
as settings for specifying the culture to be associated with web requests and Local
Searches.

<globalization

culture=”any valid culture string”-1

fileEncoding=”any valid encoding string”-2
 requestEncoding=” any valid encoding string”-3
responseEncoding=” any valid encoding string”-4
uiCulture=” any valid culture string”-4/>

1.Determines the culture such as language defaults used to process incoming Web
Requests. System.Globalization.CultureInfo class provides a list of valid culture
strings.
2.Determines type of character encoding used for parsing ASP.NET application
files(.aspx,.asmx and .asax).This must be a valid encoding string either in
Machine.Config or in Web.config.If both are not available then the coding will be
base on Machine’s regional Options setting in control panel.
3. Determines type of character encoding used to process incoming WebRequests.
This must be a valid encoding string either in Machine.Config or in Web.config.If
both are not available then the coding will be base on Machine’s regional Options
setting in control panel. The Default is utf-8.

4. Determines type of character encoding used to encode outgoing responses. This

must be a valid encoding string either in Machine.Config or in Web.config.If both are
not available then the coding will be base on Machine’s regional Options setting in
control panel. The Default is utf-8.
5. Determines the culture such as language defaults used to process
searches that are culture or local specific. System.Globalization.
CultureInfo class provides a list of valid culture strings.

c)httpRuntime:-

The <httpRuntime> element controls several aspects of the ASP.NET HTTP Runtime
engine.

<httpRuntime
appRequestQueueLimit=”number of requests”-1
executionTimeOut=”seconds”-2
maxRequestLength=”Kbytes”-3
minLocalRequestFreeThreads=”number of threads”-4
minFreeThreads=”number of threads”-5
useFullyQualifiedRedirectUrl=”true|false” -6/>

1.Specifies number of requests that ASP.NET will queue when no threads are
available to process them, before returning a “503-server too busy” error message.
The Default is 100.Increasing this value may result in unacceptable long wait times
for users, so use caution and test carefully when making adjustments to this value.

2.Determines amount of time (sec), that an ASP.NET request may continue executing
before being shutdown. This can be used to prevent hung or long-running requests
from consuming more resources than necessary.The default is 90 seconds.

3.Determines maximum size of incoming file uploads ,in KB.This attribute is

designed to help prevent denial of service attacks mounted by uploading large files to
a server.set it to small size feasible for files you expect your users to upload. The
default is 4,096KB.

4.Configures the minimum number of threads ASP.NET will keep free for processing
new requests. The Default is 8.
5. Configures the minimum number of threads ASP.NET will keep free for
processing requests coming from local machine. Maintaining these free threads can
help prevent deadlocks in multithreaded processing. The Default is 4.
6.Determines whether relative or fully qualified URLs (True-Default)are used for
client-side redirects. This attribute allows developers to support certain mobile
controls that require fully qualified URLs for client-side redirects.False-Relative
URLs.

D)httpModules:-

HttpModules are classes that implements IHttpModule interface and are used to
provide functionality to ASP.NET assplications.For example , by default , the
Machine.Config file adds HttpModules for OutputCaching, Session-state
Management, authentication and authorization.The <httpModules> element allows
you to add HttpModules to ASP.NET applications.
The<httpModules> element supports three child elements,<add>,<remove> and
<clear> and has the following syntax.

<httpModules>
<add-1
name=”name”-2
type=”type\assembly name” />-3
<remove-4
name=”name”/ > -5
<clear/>-6
</httpModules>

<httpModules>-Determines the httpModules available for the ASP.NET applications

within the scope of configuration file.

1.Each <add> child element adds a specified httpModule.

2.Specifies a name that can be used by ASP.NET applications to refer to the module identified
by the type attribute.
3.Specifies the .NET class that implements the desired httpModule. This is string containing a
comma separated list with the class name and other information, such as Version and public key,
that enables ASP.NET to locate the class in either the application’s bin directory or the global
assembly cache.
4.Removes an httpModule based on the name and type attributes specified.
5.Removes all httpModules either those configured by the currentfile or those inherited from the
parent configuration files.

E)httpHandlers:-

The <httpHandlers> element allows you to assign requests of certain types or for
certain resources to specific handler classes.
For example, in Machine.Config, the handling of the ASP.NET pages is assigned to
the System.Web.UI.PageHandlerFactory class. The <httpHandlers> element can also
be used to prevent HTTP access to certain types of files by assigning them to
System.Web.HttpForbiddenHandler class.

The<httpHandlers> element supports three child elements,<add>,<remove> and

<clear> and has the following syntax.

< httpHandlers >

<add-1
path=” path”-2
type=”type\assembly name” -3
validate=”true|false”-4
verb=”verblist”/>-5
<remove-6
path=” path”-7
verb=”verblist”/>-8
<clear/>-9
< /httpHandlers >

< httpHandlers >-Determines the assignment of requests to httpHandlers for

ASP.NET applications.
1.Each <add>child element maps a specific type of request to a given httpHandler.
2.Specifies the URL path this httpHandler will handle. This can be a single URL as in
case of the default mapping of the trace.axd URL to
System.Web.Handlers.TraceHandler, or may use a wildcard to specify that the
httpHandler should handle all requests of a given type(such as .aspx or .asmx)
3.Specifies the .NET class that should handle the requests specified by the Path and verb
attributes. This is string containing a comma separated list with the class name and other
information, such as Version and public key, that enables ASP.NET to locate the class in either
the application’s bin directory or the global assembly cache.
5.Specifies the HTTP Verbs for which the httpHandler will handle requests. Comma-
separated list of verbs(GET,POST) or wild card(such as * which specifies that all
verbs should be handled).
6.Removes an httpHandler based on the path and verb attributes specified.
5.Removes all httpHandlers either those configured by the currentfile or those inherited from the
parent configuration files.

F)processModel:-

The <processModel> element configures settings related to how ASP.NET

applications run, and it provides access to a number of features geared towards
improving the availability of applications. Theses includes automatic restart(which
can be configured based on elapsed time or number of requests),allowed memory
size and webgarden. Note that when ASP.NET is running under IIS6.O In native
mode,the settings in the <processModel> element are ignored in favour of the settings
configured by the IIS administrative UI.
<processModel

clientConnectedCheck=”time”-00:00:05
comAuthenticationLevel=”Default|None|Connect|Call|Pkt|
PktIntegrity|PktPrivacy”
comImpersonationLevell=”Default|Anonymous|Identity|Impersonate|Delegate”
cpuMask=”number”-0xffffffff
enable=”true|false”
idleTimeOut=”time”-Infinite
logLevel=”logLevel”-Errors
maxIoThreads=”number”-25
maxWorkerThreads=”number”-25
memoryLimit=”number”
pingFrequency=”hh:mm:ss”-30 sec
pingTimeout=”hh:mm:ss”-5 sec
requestLimit=”number”
requestQueueLimit=”number”-5000
responseDeadlockInterval=”infinite|hh:mm:ss”-3 min
responseRestartDeadlockInterval=” infinite|hh:mm:ss”-9 min
restartQueueLimit=”number”-10
serverErrorMessageFile=”filename”
shudownTimeout=”time”-5 sec
timeout=”time”
webGarden=”true|false”
username=”user name”-MACHINE
password=”password”/>-autogenerate

G)browserCaps:-

The <browserCaps> element contains settings used by ASP.NET to provide the

functionality of the browser capability component(accessible via the Request.Browser
Property).It provides filtering processes that allow the browser capabilities component
to populate its properties with information on the capabilities of a user’s browser,
based on the information contained in the user agent string passed by the browser.The
element supports 3 child elements, <result>,<use>,<filter>.The<filter> element
supports one child element <case>.

<browserCaps>
<result type=”System.Web.HttpBrowserCapabilities”/>
<use var=”HTTP_USER_AGENT”/>
<filter>
<case match=”string1|string2|string3”>
property=value
</case>
</filter>
</browserCaps>