mwt UNIT-V

8/9/2019 mwt UNIT-V

1/11

Component Requirements

March 15, 2008 at 10:05 am (COM, Unit 5) (COM)

Component Requirements

The advantage of using components result directly from their ability to

dynamically plug into and unplug from an application. In order to achieve this

capability , components must meet two requirements.

1. Components must linkdynamically

2. Components must hide (orencapsulate) the details of how they were implemented.

1. Dynamic Linking

The ultimate goal of this is tohave an end user replace components in an application while that

application is running.

Support for changingcomponents at run time requires the ability of dynamically link

components together.

In distributed environmentthere is no assurance that the component will be idle for

modification. So, components should have facility to update or

replace them while it is used by other system in the network.

2. Encapsulation

A program or a componentthat uses another component is called the client. A client is

connected to a component through an interface.

If the component changeswithout changing the interface, the client doesnt have to change.

Similarly, if the client changes without changing the interface, the

component doesnt have to change.

However, if changing eitherthe component or the client changes the interface, the other side ofthe interface must also change.

Therefore, to take advantageof dynamic linking, components and clients must strive not to change

their interfaces. They must be encapsulated.

The more the interface isisolated from implementation details, the less likely the interface will

change as a result of changing the client or the component.

If the interface doesnt

8/9/2019 mwt UNIT-V

2/11

change, changing a component will have little effect on the rest of

the application.

Isolating the client from the components implementation puts some

important constraints on the component. The following is a list of these

constraints.

1. The component must hidethe computer language used for its implementation. Exposing the

implementation language creates new dependencies between the

client and the component.

2. Components must beshipped in a binary form. If components are to hide their

implementation language, they must be shipped already compiled,

linked and ready to use.

3. Components must beupgradable without breaking existing users. New versions of a

component should work with both old and new clients.

4. Components must betransparently relocatable on a network. A component and the

program that uses it should be able to run in the same process, in

different processes, or on different machines. The client should be

able to treat a remote component the same way it treats a local

component.

PermalinkLeave a Comment

COM : Fundamentals

March 15, 2008 at 9:21 am (COM, Unit 5) (COM)

COM

COM is a specification It specifies how to build components that can be

dynamically interchanged.

COM provides the standard that components andclients follow to ensure that they can operate together.

The COM specification is a document that sets thestandard for the component architecture.

What are COM Components?

8/9/2019 mwt UNIT-V

3/11

COM component consists of executable codedistributed either as Win32 dynamic link libraries (DLLs) or as executables (EXEs).

Components written to the COM standard meet allrequirements for component architecture.

COM components link dynamically using DLLs. COM components can be encapsulated easily

because:

oCOM components are fully language

independent. They can be developed using almost any procedural language Ada to

C to Java to Modula-3 to Oberon to Pascal.

oAny language can be modified to use COM

components, including Smalltalk and Visual Basic.

oCOM components can be shipped in binary

form.

oCOM components can be upgraded without

breaking old clients. Because it provides a standard way to implement different

versions of a component.

oCOM components can be transparently

relocated on a network. A component on a remote system is treated the same as a

component on the local system.

COM components announce their existence in a standard way.Using COMs publication scheme, clients can dynamically find the components they

need to use. COM components are a great way to provide object-oriented APIs or

services to other applications.

COM components are also great for buildinglanguage-independent component libraries from which applications can be rapidly built.

COM is not

COM is not a computer language.

COM does not compete with computer languages. COM tells how to write components. COM also does not compete with or replace DLLs. COM uses DLLs to provide components with the

ability to dynamically link.

COM is not primarily an API or a set of functionslike the Win32 API.

COM does not provide services such asMoveWindow or the like.

COM is not a C++ class library like the MicrosoftFoundation Classes (MFC).

8/9/2019 mwt UNIT-V

4/11

COM provides a way to develop language-independent component libraries, but COM does not provide any implementation.

The COM Library

COM has an API, the COM library, which providescomponent management services that are useful for all clients and components.

Most of the functions in the API are not toodifficult to implement when developing COM-style components on a non-Windowssystem.

The COM library was written to guarantee that themost important operations are done in the same way for all components.

The COM library also saves developers timeimplementing their own components and clients.

Most of the code in the COM library is support fordistributed or networked components.

The Distributed COM (DCOM) implementation onWindows System provides the code needed to communicate with components over anetwork.

This reduces to write the networking code.PermalinkLeave a Comment

COM and CORBA Side by SideMarch 14, 2008 at 11:31 am (COM, CORBA, Unit 5) (COM, CORBA)

.

Trait Similarities Differences

Interfaces Each uses their ownIDL to describe

interfaces.

CORBA IDL is simpler an elegant

than COM IDL

COM has better tool support for

creating and managing IDL thanCORBA

Datatypes Both support a rich setof data types

Both also support

constants, enumerated

types, structures and

arrays.

COM has automation types.

Automation compatible interfaces

are supported in more client

environments than non-compatible

interfaces. Because the non-

compatible interfaces are not

guaranteed to work other than C++.

Any CORBA interface can be used

8/9/2019 mwt UNIT-V

5/11

from any CORBA client

Proxies,

Stubs &

Skeletons

COM and CORBA rely

on client stubs and

server stubs to handle

remoting issues.COM & CORBA

generate client stubs

and server stubs from

IDL.

COM client & server stubs are called

as Proxy & Stub and in CORBA called

as Stub & Skeleton.COM proxy-stub DLLs are used by all

language environments. In CORBA, a

separate stub-skeleton must be

generated for each ORB/language

combination.Marshaling &

Unmarshaling

COM and CORBA

handle marshaling in

client stubs and serverstubs. Users do not

need to worry about

marshaling.

COM allows automation-compatible

interfaces to use type library

marshaling, thus eliminating theneed for customized stubs.

Object

HandlesCOM & CORBA support

reference counted

handles on object

instances.

COM calls object handles as

interface pointers and CORBA calls

as object references.CORBA supports multiple

inheritance in the interface

hierarchy. COM supports single

inheritance only; however a COM

object supports more than onedistinct interface.Object

CreationBoth use factories to

create objects

instances.

COM has a standard factory

interface called IClassFactory CORBA

factories are customized persistent

CORBA objects.Object

InvocationBoth allow for method

invocation similar to

native environment

method invocation.

COMs error-handling mechanism is

based on HRESULT return values.CORBA supports user-defined

exception types in IDL.

Object

DestructionCOM and CORBA rely

on reference counting

to determine when an

object can be

destroyed

COM supports distributed reference

counting and garbage collection.CORBA reference counts are

maintained separately in the client

and server.

Permalink1 Comment

DCOM CORBA Comparison

March 11, 2008 at 3:39 pm (COM, CORBA, Slides, Unit 5) (COM, CORBA, Slides)

8/9/2019 mwt UNIT-V

6/11

Click here to view the SlideShow

DCOM CORBA Comparison

DCOM Vs CORBA


DCOM Vs CORBA

March 10, 2008 at 3:35 pm (COM, CORBA, Unit 5) (COM, CORBA)

Differences DCOM CORBA

Focus Desktop first;enterprise

second

Enterprise first; desktopsecond

Platforms Windows NT;

support for

Windows (all),

Macintosh,

UNIX, MVA

MVS, UNIX, Windows (all),

Macintosh

Availability Single vendor;

availability from

other vendors

expected

Multi-vendor

Service

differences

ActiveX-

interactive

content standard

Significant number of

additional services, including

query, trader, transactions, as

well as facilities in the areas of

information management and

system management. Lastly,

services in areas such as

finance, distributed

simulation, and computer

integrated manufacturing

Maturity NT shipped in

1996; decade-

long evolution of

OLE and COM

products; most

services and

facilities under

construction

Products since 1992; many

services and facilities under

construction

8/9/2019 mwt UNIT-V

7/11

Language

Binding

C, C++; working

on JAVA, Visual

Basic, Ada

C++, Smalltalk, Ada95; JAVA

and COBOL

Interface

Inheritance

Supports

aggregation but

not inheritance;

interfaces are not

classes.

Multiple Inheritance;

interfaces are classes.


Similarities between DCOM and CORBA

March 10, 2008 at 3:29 pm (COM, CORBA, Unit 5) (COM, CORBA)

Similarities DCOM CORBA

Object Model Yes Yes

Standards

body

Recently made

formal; managed by

the Active Group, an

Open Group affiliate

Formal: managed by

the Object

Management Group

Interfacesimilarities

Microsoft IDL allowsfor specification of

interface and

implementation and

provides a repository

for storage of

interfaces.

CORBA IDL allows forseparation of interface

and implementation

and provides a

repository for storage

of interfaces.

Language

independenceYes Yes

Compound

document

model

Yes-OLE Yes-OpenDoc

Location

Transparency

Yes Yes


Marshaling and Remoting

March 4, 2008 at 5:33 pm (.NET, Unit 5) (.NET)

8/9/2019 mwt UNIT-V

8/11

The days of integrated programs all running in a single process on a single machine are, if not

dead, at least seriously wounded. Todays programs consist of complex components running inmultiple processes, often across the network. The Web has facilitated distributed applications in

a way that was unthinkable even a few years ago, and the trend is toward distribution ofresponsibility.

A second trend is toward centralizing business logic on large servers. Although these trends

appear to be contradictory, in fact they are synergistic: business objects are being centralized

while the user interface and even some middleware are being distributed.

The net effect is that objects need to be able to talk with one another at a distance. Objects

running on a server handling the web user interface need to be able to interact with business

objects living on centralized servers at corporate headquarters.

The process of moving an object across a boundary is called remoting. Boundaries exist atvarious levels of abstraction in your program. The most obvious boundary is between objects

running on different machines.

The process of preparing an object to be remoted is called marshaling. On a single machine,

objects might need to be marshaled across context, app domain, or process boundaries.

A process is essentially a running application. If an object in your word processor wants to

interact with an object in your spreadsheet, they must communicate across process boundaries.

Processes are divided into application domains (often called app domains); these in turn are

divided into various contexts. App domains act like lightweight processes, and contexts createboundaries that objects with similar rules can be contained within. At times, objects will be

marshaled across both context and app domain boundaries, as well as across process andmachine boundaries.

When an object is remoted, it appears to be sent through the wire from one computer to another.

The actual transmission of your message is done by a channel. The channel works with a

formatter. The formatter makes sure the message is in the right format.


Compilation and the MSIL


In .NET, programs are not compiled into executable files, they are compiled into Microsoft

Intermediate Language (MSIL) files, which the CLR then executes. The MSIL (often

shortened to IL) files C# produces are identical to the IL files that other .NET languages

produce; the platform is language-agnostic. A key fact about the CLR is that it is common: the

same runtime supports development in C# as well as in VB.NET.

8/9/2019 mwt UNIT-V

9/11

C# code is compiled into IL when you build your project. The IL is saved in a file on disk. When

you run your program, the IL is compiled again, using the Just In Time (JIT) compiler (aprocess often called JITing). The result is machine code, executed by the machines processor.

The standard JIT compiler runs on demand. When a method is called, the JIT compiler analyzes

the IL and produces highly efficient machine code, which runs very fast. The JIT compiler is

smart enough to recognize when the code has already been compiled, so as the application runs,

compilation happens only as needed. As .NET applications run, they tend to become faster and

faster, as the already compiled code is reused.

The CLS means that all .NET languages produce very similar IL code. As a result, objects

created in one language can be accessed and derived from another. Thus it is possible to create a

base class in VB.NET and derive from it in C#.

The .NET Framework


Microsoft .NET supports not only language independence, but also language integration. This

means that you can inherit from classes, catch exceptions, and take advantage of polymorphism

across different languages. The .NET Framework makes this possible with a specification calledthe Common Type System (CTS) that all .NET components must obey. For example,everything in .NET is an object of a specific class that derives from the root class called

System.Object. The CTS supports the general concept of classes, interfaces, delegates (which

support callbacks), reference types, and value types.

Additionally, .NET includes a Common Language Specification (CLS), which provides a

series of basic rules that are required for language integration. The CLS determines the minimum

requirements for being a .NET language. Compilers that conform to the CLS create objects that

can interoperate with one another. The entire Framework Class Library (FCL) can be used byany language that conforms to the CLS.

The .NET Framework sits on top of the operating system, which can be any flavor of Windows,

and consists of a number of components, currently including:

Four official languages: C#, VB.NET, Managed C++,and JScript.NET

The CLR, an object-oriented platform for Windows

and web development that all these languages share

A number of related class libraries, collectively

known as the FCL

Figure breaks down the .NET Framework into its system architectural components.

8/9/2019 mwt UNIT-V

10/11

The most important component of the .NET Framework is the CLR, which provides theenvironment in which programs are executed. The CLR includes a virtual machine, analogous in

many ways to the Java virtual machine. At a high level, the CLR activates objects, performs

security checks on them, lays them out in memory, executes them, and garbage-collects them.(The Common Type System is also part of the CLR.)

In Figure 1, the layer on top of the CLR is a set of framework base classes, followed by an

additional layer of data and XML classes, plus another layer of classes intended for web services,

Web Forms, and Windows Forms. Collectively, these classes make up the FCL, one of thelargest class libraries in history and one that provides an object-oriented API for all the

functionality that the .NET platform encapsulates. With more than 4,000 classes, the FCLfacilitates rapid development of desktop, client/server, and other web services and applications.

The set of Framework base classes, the lowest level of the FCL, is similar to the set of classes in

Java. These classes support rudimentary input and output, string manipulation, security

management, network communication, thread management, text manipulation, reflection and

collections functionality, etc.

Above this level is a tier of classes that extend the base classes to support data management and

XML manipulation. The data classes support persistent management of data that is maintainedon backend databases. These classes include the Structured Query Language (SQL) classes to let

you manipulate persistent data stores through a standard SQL interface. Additionally, a set ofclasses called ADO.NET allows you to manipulate persistent data. The .NET Framework also

supports a number of classes to let you manipulate XML data and perform XML searching and

translations.

Extending the Framework base classes and the data and XML classes is a tier of classes geared

toward building applications using three different technologies: Web Services, Web Forms, and

Windows Forms. Web services include a number of classes that support the development of

lightweight distributed components, which will work even in the face of firewalls and NAT

8/9/2019 mwt UNIT-V

11/11

software. Because web services employ standard HTTP and SOAP as underlying

communications protocols, these components support Plug and Play across cyberspace.

Web Forms and Windows Forms allow you to apply Rapid Application Development techniques

to building web and Windows applications. Simply drag and drop controls onto your form,

double-click a control, and write the code to respond to the associated event.

Permalink1 Comment

Introduction to .NET


The .NET Platform

The .NET platform is a new development framework that provides a fresh application

programming interface (API) to the services and APIs of classic Windows operating systems

(especially the Windows 2000 family), while bringing together a number of disparate

technologies. This includes COM+ component services, the ASP web development framework, acommitment to XML and object-oriented design, support for new web services protocols such as

SOAP, WSDL, and UDDI, and a focus on the Internet, all integrated within the DNA

architecture.

The platform consists of four separate product groups:

A set of languages, including C# and Visual Basic .NET, a set of development toolsincluding Visual Studio .NET, a comprehensive class library for building web services

and web and Windows applications, as well as the Common Language Runtime (CLR) toexecute objects built within this framework.

A set of .NET Enterprise Servers, formerly known as SQL Server 2000, Exchange 2000,BizTalk 2000, and so on, that provide specialized functionality for relational data storage,

email, B2B commerce, etc.

An offering of commercial web services, called .NET My Services. For a fee, developerscan use these services in building applications that require knowledge of user identity,

etc.

New .NET-enabled non-PC devices, from cell phones to game boxes.

mwt UNIT-V

Documents

Transcript of mwt UNIT-V