EP1164482A2

EP1164482A2 - System and method for interactive communication between objects in a distributed computing environment

Info

Publication number: EP1164482A2
Application number: EP01109770A
Authority: EP
Inventors: Bradley John Graziadio; David Ethan Zoller; Adam Overton; Nadim Abdo
Original assignee: Microsoft Corp
Current assignee: Microsoft Corp
Priority date: 2000-06-16
Filing date: 2001-04-20
Publication date: 2001-12-19
Anticipated expiration: 2021-04-20
Also published as: EP1164482B1; EP1164482A3; DE60136247D1; ATE412214T1; JP2002041309A

Abstract

A system and method enables interactive communication between a host object-oriented component running on client computer and a remote object-oriented component running on a remote computer in a distributed computing environment. The host object-oriented component has an object embedded therein. The embedded object is associated with an object that is not resident on the client computer. In response to invoking the embedded object at the client computer, a remote instance of the embedded object is created at the remote computer in the form of the remote object-oriented component. An interface also is dynamically created between the remote object-oriented component and the client computer to facilitate communication of both programmatic data and user interface data therebetween. As a result, the remote object may be manipulated as if it were local on the client computer.

Description

Technical Field

The present invention relates to communication between object-oriented applications. More particularly, the present invention relates to a system and method for interactive communication between a host object-oriented component on a host computer and a remote object-oriented component running on a remote computer in a distributed computing environment.

Background of the Invention

Object-oriented programming has been developed to facilitate creation of new, reusable components as well as to make convenient and flexible upgrades to existing applications. Object-oriented software provides data abstraction, which hides the implementation details within objects, and thus lessens the impact of changes when modifications are made to the software. Object-oriented programming also provides data encapsulation and data type inheritance. Data encapsulation relates to coupling data to the functions that operate on the data. Inheritance refers to the ability to define a data type as an extension of other data types. An instance of a data type that couples data and functions is referred to as an object.
The Component Object Model (COM) developed by Microsoft Corporation of Redmond, Washington, is an object-oriented programming model that provides a standard as to how objects within a single application or between applications (e.g. client/server applications) interact and communicate. COM defines a set of standard interfaces, which are groupings of semantically related functions through which a client application accesses the services of, for example, a server application.
Object Linking and Embedding (OLE), such as OLE Version 2 and ACTIVEX® controls (network activation controls) developed by Microsoft Corporation of Redmond, Washington, are based on COM and allow the creation of objects of different formats which operate on data through defined interfaces, rather than operating on the applications responsible for the data. ACTIVEX® controls are based in part on OLE technologies, which enable object data to be embedded within an object, or linked to it, so that only a reference to the object data is stored in the object.
One aspect of the OLE object system enables a client object-oriented application to have a reference to an object in an object application that does not share computer process memory (e.g., it operates in a different execution context) with the client application. In many client/server systems, both the client and server application exist within the same operating system process and, therefore, are able to share process memory. In order to facilitate an object reference to a remote object, two additional interface objects (e.g., a proxy-stub pair) are created. The proxy object, which looks and acts just like the real object, intercepts and forwards all calls to the real object through the channel to the stub object. The stub object, in turn, calls the real object. The communication between the proxy and stub is managed by a channel object, which sends information between the client and server processes. A standard interface, such as IDispatch, may be employed to facilitate remote automation across a network.
With increasing network bandwidth, sophisticated distributed computing models and software applications are becoming available. The applications follow an object-oriented or component model, with larger applications often being divided into small containers or objects of program code and data. In a distributed computing environment, program objects are distributed to both server and clients, with the details of the network environment being hidden relative to the objects through the use of proxy and stub objects for transferring information over the network. Two competing standards for a distributed computing model are the Distributed Component Object Model (DCOM), developed by the Microsoft Corporation, and the Common Object Request Broker Architecture (CORBA), developed by the Object Management Group. These models specify how objects within a single application or between applications (e.g., client/server applications) interact and communicate by defining a set of standard interfaces.

Summary

The present invention relates to a system and method for enabling interactive communication between a host object-oriented component running on client computer and a remote object-oriented component running on a remote computer in a distributed computing environment. The host object-oriented component has an object therein. An application or another object associated with the object, however, is not resident on the client computer. A remote instance of the object is created at the remote computer in the form of the remote object-oriented component. An interface also is dynamically created between the remote object-oriented component and the client computer to facilitate communication of both programmatic data and user interface data. As a result, the remote object may be manipulated as if it were local on the client computer.
By way of example, the host object-oriented component may be a MICROSOFT® word processing document running on the client computer, which has an object in the form of a VISEO® document embedded therein, although no corresponding VISEO® application is resident on the client computer. A remote computer, however, does have a VISEO® application. When the embedded VISEO® document is invoked from within the word processing document running on the client computer, a remote instance of the embedded VISEO® document is created and associated with the VISEO® application running on the remote computer. An interface is dynamically created to facilitate communication of both programmatic data and user interface between the host-word processing document and the remote instance of the VISEO® document. The interface permits a user to manipulate the remote instance of the VISEO® document and view changes as if it were running locally on the client computer.
According to another aspect of the present invention, a client is connected to a session of a remote server in a distributed computing environment. The client includes an object, which is associated with an application or another object resident on the server. The client also includes a component programmed to create a remote instance of the object in the server session to which the client is connected. This may occur, for example, in response to invoking or referencing the object at the client. The server component creates the remote instance of the object and dynamically creates a stub for interfacing with the remote instance of the embedded object. The client component, in turn, dynamically creates a proxy operatively associated with the stub. The proxy/stub pair marshals programmatic data (e.g., instructions to the computer and/or user and other parameters) between the remote instance of the object and the client. A user interface for the remote object is generated in the server session and returned to the client for providing a visual representation indicative of the condition of the remote object. As a result, a mechanism transparent to the client and the remote object is provided, which permits remote interaction from the client with the remote object running in the server session, as well as provides visual feedback of the remote object including based on the client interaction. Advantageously, the user interface and the programmatic data enable the remote object to be interacted with and/or controlled as if the remote object were running on the client.
Another aspect of the present invention provides a system that includes a first computer running a first object having a second object that is associated with a remote object. In response to invoking the second object, the first computer operatively couples to a second computer running the remote object and virtualizes at the first computer a remote instance of the second object running in the remote object and a user interface related thereto via a dynamically created interface.
Still another aspect of the present invention provides a system that includes a client execution context on a first computer. The client execution context has an object that is associated with a remote host not resident on the first computer. The first computer includes computer executable instructions for dynamically creating a remote instance of the object in the remote host in response to invoking the object at the first computer. The remote host generates a user interface for the remote instance of the object. User interface data is communicated between the first computer and the remote instance of the object via an interactive bi-directional communications channel between the client execution context and the remote host. Programmatic data also is communicated between the first computer and the remote instance of the object via the communications channel. As a result, interactive communications between the client execution context and the remote instance of the object is provided.
Another aspect of the present invention provides an interactive distributed component object model. The model includes a host object resident on a host computer having an object embedded therein. A remote instance of the embedded object is created in response to invoking the object embedded in the first object. A remote object on the remote computer that is operative to create the remote instance of the embedded object at the remote computer in response to invoking the embedded object. A user interface for the remote instance of the embedded object is generated at the remote computer. The host computer interactively couples to the remote instance of the embedded object via a dynamically created interface for bi-directional communications of programmatic and user interface data between the remote instance of the embedded object and the host computer. As a result of remoting the user interface (which provides visual feedback of the condition of the remote object) and communicating the programmatic data, interaction between the host application and the remote instance of embedded object running on the remote computer is facilitated.
Yet another aspect of the present invention relates to a method for facilitating interactive communications between a client and server in a distributed computing environment. The method includes running on the client a host object having an embedded object associated with a second object resident on the server. The embedded object is invoked at the client and a remote instance of the embedded object is created at the server. An interface between the client and the remote instance of the embedded object is created in response to invoking the embedded object. User interface and programmatic data are communicated between the remote instance of the embedded object and the client.
Another aspect of the present invention provides an electronic signal adapted to be transmitted between at least two computers. The electronic signal includes computer-executable instructions for, in response to invoking a first object operatively associated with a second object running at a first of the at least two computers, creating at a second of the at least two computers a remote object corresponding to the first object. The electronic signal includes further computer-executable instructions for virtualizing at the first computer a user interface for the remote object via a dynamically created interface between the first and second of the at least two computers.
Still another aspect of the present invention provides a computer-readable medium having computer-executable instructions for performing the acts running on a first computer a first object having a second object therein associated with a remote object not resident on the first computer. In response to invoking the first object, the first object is programmatically interfaced with the remote object on a remote computer to create a remote instance of the second object on the remote computer. User interface and programmatic data are communicated between the remote instance of the second object and the first computer.
To the accomplishment of the foregoing and related ends, the invention, then, comprises the features hereinafter fully described and particularly pointed out in the claims. The following description and the annexed drawings set forth in detail certain illustrative aspects of the invention. These aspects are indicative, however, of but a few of the various ways in which the principles of the invention may be employed. Other objects, advantages and novel features of the invention will become apparent from the following detailed description of the invention when considered in conjunction with the drawings.

Brief Description of the Drawings

Fig. 1 is a functional block diagram of a distributed computing system, illustrating interactive communications between a client object and server object, in accordance with the present invention;
Fig. 2a is a functional block diagram of a distributed computing system, illustrating a first condition of the system, in accordance with an aspect of present invention;
Fig. 2b is a functional block diagram of the system of Fig. 2a, illustrating a second condition of the system, in accordance with the present invention;
Fig. 2c is a functional block diagram of the system of Fig. 2a, illustrating a third condition of the system, in accordance with the present invention
Fig. 3 is a functional block diagram of a distributed computing system illustrating interactive communications between a client and multiple remote objects in accordance with the present invention;
Fig. 4 is an exemplary operating environment for a system which may be configured to implement the present invention; and
Fig. 5 is a flow diagram of an exemplary methodology in accordance with an aspect of present invention.

Detailed Description of the Invention

The present invention relates to a system and method for enabling interactive communication between a host object-oriented component running on client computer and a remote object-oriented component running on a remote computer in a distributed computing environment. The host object-oriented component has an object embedded therein, although an application associated with the embedded object is not resident on the client computer. The associated application is resident on the remote computer.
Fig. 1 is a block diagram which schematically illustrates an example of a distributed computing system 10 for providing interactive communication between component objects located on different computers in accordance with the present invention. The system 10 includes a local or client computer 12, such as a personal computer, a workstation, etc. The client computer 12 is operatively coupled to a remote computer or server 14 via a communications link or channel, indicated at 16. The computers 12 and 14 communicate via the channel 16 by employing an agreed upon network communications protocol.
The communications channel 16, for example, connects the client computer 12 to a Terminal Server session of the server 14. As is known in the art, Terminal Server provides a multi-user core that supports the ability to host multiple, concurrent client sessions on an operating system, such as versions 4.0 and higher of the WINDOWS NT SERVER® operating systems developed by Microsoft Corporation of Redmond, Washington. Terminal Server employs a Remote Desktop Protocol (RDP), which allows a client to communicate with the Terminal Server over the network connection. Briefly stated, the Terminal Server session enables applications to execute on the server and communicate the remotely generated user interface over a connection which is displayed locally at the client. For additional information on Terminal Server, reference may be made to the Terminal Server Website at http:\\www.microsoft\com\ntserver\basics\terminalserver. It is to be understood and appreciated that the present invention is platform and operating system independent; other operating systems and other communications protocols may be employed to implement the present invention.
By way of example, a Distributed Computing Environment (DCE) Object Remote Procedure Call (ORPC) facility may be employed to connect the remote computer 14 with the client computer 12 via the channel 16, although other facilities may also be used. WINDOWS NT ® operating system from Microsoft of Redmond, Washington, for example, provides DCE ORPC functionality via an ORPC channel object that encapsulates the details about the underlying cross-process and cross-network transport. The DCE ORPC channel object employs a generic ORPC transport provider interface to communicate with a remote transport protocol. The transport provider interface acts as thin layer between the DCE ORPC facility and the network transport, mapping ORPC operations onto the functions provided by the network transport. The ORPC facility implements transport providers (e.g., DLLs) for named pipes, NetBIOS, TCP/IP, DECnet, and others. Additional transports also may be supported by writing new provider DLLs that interface with the ORPC channel object.
Referring back to Fig. 1, the client computer 12 has a local host object 20, such as an application running resident on the client computer. The local host 20 also includes an object 22 embedded therein. The embedded object 22 cannot run locally at the client computer 12, however, as there is no corresponding host container or application resident on the client computer. The embedded object 22 is associated with a remote host 26, which may be an object such as an application resident on the server computer 14. The remote host 26 operates as a surrogate container object for remote objects, including the object 22.
By way of example, the object 22 is embedded in the host application (or object) by employing Object Linking and Embedding (OLE), such as OLE Version 2 by Microsoft Corporation of Redmond, Washington. As mentioned briefly above, OLE is based on COM and allows the creation of objects of different formats that operate on object data through defined interfaces. Using OLE enables object data to be embedded within an application or object (or linked to it), so that only a reference to the object data is stored in the object. While the following description refers to OLE, those skilled in the art will appreciate that a system and method, in accordance with the present invention, may utilize other linking and/or embedding technologies.
In accordance with an aspect of the present invention, invoking the embedded object 22 results in a remote instance 32 of the embedded object to be created at the server 14. For example, invocation of the embedded object 22 effects a request for an interface associated with the second application. In response to the request, a control container 34 is created in the execution context of the local host 20 that contains a control object. The control object includes an interface 36, which is treated internally at the client 12 just like an interface to the actual object. The control object of the container 34, for example, exposes a method that permits client-side code to create the remote object 32 in the Terminal Server session to which the client 12 is connected to the server 14 via communications channel 16. A user interface is generated at the server computer 14 for the remote object 32. The remote object 32 (e.g., its application context) and its user interface are virtualized (indicated as 38) at the client computer 12 via a dynamically created interface. The virtualization 38 of the remote object 32 at the client computer includes programmatic data and user interface (UI) information, as if the remote object were running locally on the client computer 12. Programmatic data may include instructions to the computer and user, computer-executable instructions created or modified in response to other instructions, and/or other parameters/data which may be employed in a computing process.
The communications channel 16 includes two channel parts, which may employ the same or different communications protocol(s). The communications channel 16 may be programmable so as to map policies between the caller's context and the object's context. A first part of the channel 16 employs an appropriate communications protocol over the channel 16 so that the cross-network and cross-context communications appear transparent to both the client computer 12 and the remote object 32. In particular, the first part of the channel 16 is employed to communicate parameters and other data (e.g., input parameters, status, exception information, etc.) between the remote object 32 and the client computer 12. As a result, cross-context method calls may be made on the remote object 32 via the first channel part as if the object was local relative to the local host 20.
Another part of the channel 16 is used to communicate UI data between the remote object 32 and the client computer 12. In particular, the UI information is generated at the server computer 14 by the remote object 32 and is provided to the client computer 12, such as by employing RDP. The UI information may include data indicative of a graphical interface as well as associated program data (e.g., an application or instructions) for controlling a display 40 at the client computer 12. The UI information provides the local host 20 with UI capabilities, including display, keyboard and/or pointer redirection. That is, program instructions, such as based on client-side code or user interactions, may interact with and manipulate the remote object 32 via the first channel part, with the interactions being reflected in the UI that is generated at the server 14 and remoted to the client 12 via the second channel part. The control 34 facilitates communication of the remote UI data from the remote computer 14 so that a visual indication of the remote UI is provided to the display 40. As a result, the graphical UI for the remote object 32 running on the server 14 and graphics of the local host 20 running on the client computer 12 are able to share a window area of the display 40 at the client computer. For example, the remotely generated UI draws to a known window address at the client computer 12 by employing a suitable protocol in the second part of the channel 16. As a result, the remotely generated UI appears embedded in the local host 20 in substantially the same manner as if the remote object were running locally at the client computer 12. Any changes to the remote object 32 thus may be stored locally at the client 12 as a modified version of the object embedded within the local host 20, which saving may occur in the form of programmatic data communicated via the channel 16.
Figs. 2a-2c illustrate a system 100 for providing interactive communications between a client and a remote object in accordance with an aspect of the present invention. More particularly, Figs. 2a-2c provide a step-by-step representation of how an interactive communications channel is established and maintained between the remote object and the client or caller in accordance with an aspect of the present invention.
With reference to Fig. 2a, the system 100 includes a client computer 102 operatively coupled to a server computer 104 via a communications link 106. The client computer 102 is connected to a session 107 (e.g., a Terminal Server session) at the server computer 104. Accordingly, appropriate protocol is employed for communications between the client computer 102 and the server computer 104, such as the ORPC described above. The client computer 102 includes a local host 108, such as an object (e.g., an application) running resident on the client computer. The host 108 has an object 110, such as an OLE object, embedded in the host application. The object 110 is associated with another object or component (e.g. an application) that is not resident on the client computer 102, but that is available on the server computer 104.
The client computer 102, for example, is programmed to include an object, such as in the form of a control. The object facilitates the creation of a remote object in a different execution context. By way of example, the object may be a function or method, such as a RemoteCreateObject method, which is operative to create a remote object on a remote computer, such as in response to invoking an object at the client 102 requiring an object or application in a different execution context. The RemoteCreateObject method may employ parameters indicative of the object that is to be created to specify which object is to be created in response to the invocation. For example, the parameter may include: a unique object identifier (e.g., PROGID); a unique identifier to an interface of a specific object (e.g., UUID); and/or a moniker for a document/data object on a remote computer, in which case the appropriate object to interact with that document will be remotely created. The RemoteCreateObject method extends the creation mechanism for an object to allow creation of objects on the remote computer 104. Since, in this example, only OLE or other control data is modified, the methodology is compatible with existing OLE client/server applications. As a result, existing OLE objects do not have to be changed or recompiled to be compatible with the system 100.
It is to be appreciated that other parameters or criteria indicative of the object, which is to be created in response to invoking the embedded object, also may be utilized in accordance with the present invention. Such parameters, for example, may vary depending on the operating system and platform in which the system 100 is being implemented.
On each host client/server operating system, an operating system registry (e.g., the registration database) stores relevant information about object components according to their Globally Unique Identifiers (GUIDs) or PROGram IDentifiers (PROGIDs). In particular, the client computer 102 stores information related to the GUID or PROGID of the embedded object 110, which enables the client to locate executable code associated with the embedded object. The local system also may query a remote (or local) database to determine a suitable remote server for creating the remote object. For example, the client computer may search the Internet to locate a particular object (e.g., "Where can I find a VISIO® object?"). In response to invoking the embedded object (e.g., by user interaction or script referencing the object), the client computer 102 calls the RemoteCreateObject application to pass the GUID or PROGID of the embedded object to an interface 112 for creating an instance of application associated with the embedded object.
Alternatively, invoking (or referencing) the object 110 may, in accordance with an aspect of the present invention, cause a local control object (or a method or function) within the system to locate an appropriate mechanism capable of creating an instance of the object. The discovery mechanism, in turn, dynamically establishes an appropriate proxy/stub pair to enable bi-directional and interactive communication between the client computer and a remote instance of the object on the server computer 104 located by the discovery mechanism.
The client computer 102 further is programmed to include a control container 114 having one or more control objects that may implement the request. The control container 114 is operatively associated with (or linked to) the interface 112. An example of a suitable control object is an ACTIVEX® control, which is well known to those skilled in the art. ACTIVEX® controls provide an effective way of encapsulating functionality in a variety of platforms. Advantageously, ACTIVEX® controls may be written in any number of programming languages. ACTIVEX® controls are based on OLE controls and are COM based components (or objects), which may be inserted into an application or other object to reuse preprogrammed packaged functionality. For additional information concerning ACTIVEX® controls, see "ActiveX Controls Inside Out, Second Edition" by Adam Denning, Microsoft Press, Redmond, Washington, 1997, which is incorporated herein by reference.
The server computer 104 includes a remote host application 116 (or component), which runs in the Terminal Server session to which the client 102 is connected. The remote host application 116 is employed as a host for creating remote objects in accordance with an aspect of present invention.
With reference to Fig. 2b, the control object 114 sends a request data packet to the remote host application 116 via the communications link requesting creation of a remote instance of the embedded object 110. The request includes the GUID or PROGID (or other data) of the embedded object 110 to identify the specific embedded object.
The remote host application 116 creates a remote object 120 in the remote session 107 corresponding to the embedded object 110 at the client 102. The remote object 120 includes an interface 122, such as, for example, an IDispatch interface. IDispatch is a Microsoft COM interface which supports methods that make calls to objects, such as the remote object 120 created by the remote host application 116. The IDispatch interface is described in greater detail in U.S. Patent No. 5,515,536, which is entitled "Method and System for Invoking Methods of an Object Through a Dispatching Interface," which is incorporated herein by reference.
In order to provide for substantially transparent communication of programmatic data across context boundaries defined by the remote object 120 and the host 108 at the client 102, the remote host application 116 also dynamically creates a stub object 124 for the remote object's IDispatch interface 122. The control object 114 at client 102 also dynamically creates a proxy object 126 for the remote IDispatch interface 122 and binds it to the stub 124 associated with the remote object 120.
According to one aspect of the present invention, the communications channel 106 includes two parts. A first channel part 130 is for communicating programmatic data between the proxy/stub pair, and the second channel part 132 is for communicating UI data between the client computer 102 and the remote object 120. The communications channel 106 may be programmable, such as employing a DCE ORPC facility, to facilitate inter-context communication between the remote object 120 and the client 102. The channel 106 also may selectively allocate the channel bandwidth for the UI information (channel part 132) and the programmatic data (channel part 130) being communicated. The communications channel 132, for example, employs a communications protocol, such as the Remote Desktop Protocol (RDP) developed by Microsoft Corporation of Redmond, Washington. The RDP protocol provides for bi-directional communications of UI data between the client 102 and the remote object at the server 104 via part 132 of the communications channel 106. For example, the channel part 132 may further subdivide its communications of UI into separate channels for different types of UI information (e.g., one channel for mouse and keyboard information and another for video communicated back to the client computer). It is to be appreciated that any communications protocol (or a combination of different protocols) may be employed that enables communication of programmatic data in conjunction with the communication of a UI data so that the remote object 120 and associated controls may be manipulated at the client 102 by code or user interaction with the UI as if the components were installed locally.
With reference to Fig. 2c, the proxy/stub pair employs a well-defined request/response protocol via an associated communications channel 130 that is transparent to both the caller (the host 108 at the client 102) and the remote object 120. The communications channel 130 is part of the communications channel 106 between the client 102 and the remote server session 107. By way of example, the proxy object 126 marshalls the call context (e.g., input parameters from the client) of each method and forwards them to the stub 124 as a request message. The stub object 124 receives the request, unmarshalls the call context, and calls the remote object 120 for executing the request. Any results, exceptions, and/or output parameters are marshalled by the stub 124 and are sent back to the proxy 126 in a response message. Finally, the proxy object 126 takes the response, unmarshalls the return value and any output parameters, and provides them to the client 102. From the client's perspective, the proxy object 126 looks just like the remote object 120, as the proxy knows the policies of the caller's context. As a result, the client 102 interacts with proxy object 126 as if it were executing locally in the host application's context. Because the remote object 120 is being called in its context by a stub object 124 that knows the policies of the remote object's context, the object also "thinks" the client 102 has made the call in the remote object's context.
In accordance with the present invention, a UI is generated at the server 104 for the remote object 120. The UI includes a graphical UI (GUI) and associated programmatic data. The UI information is generated in the context of the remote object 120 and communicated to the client computer 102 via another part 132 of the communications channel 106. The channel part 132 also communicates UI instructions, such as based on user interaction at the client, from the client computer 102 to the remote object 120 via, for example, the remote host 116.
The client computer 102 includes a display 140 in which graphical features and user interfaces associated with programs running locally on the client, including the host 108, and those of the remote object 120 may be displayed. In addition, the UI information communicated via the second channel part 132 may be passed to a window address at the client 102. As result, both the local host 108 and the remote object 120 may share one area of the display 140 at the client 102 in a real time manner. As a result, the remotely generated UI appears embedded in the local host 108 in substantially the same manner as if the remote object were running locally at the client computer 102. Any changes to the remote object 120 may be stored locally at the client 102 as a modified version of the object 110 embedded within the local host 108, with the data to be stored at the client being communicated as programmatic data via the channel 130.
Traditionally, in order for a host computer to manipulate an embedded object, an application (or object) associated with the embedded object may need to be installed locally. In accordance with the present invention, however, script or other controls associated with the client 102 may be employed to enable interaction with a remote instance of the embedded object as if the application were running locally. Moreover, any compiled code may be utilized to access a remote object provided that the code uses standard interfaces, such as, for example, the IDispatch interface described above. Advantageously, the system 100, in accordance with the present invention, also enables the user to interact with the remote object 120 and visually see the results of the interactions even though the application is not running locally. As mentioned above, this is a result of the interactive communications channel 106, which permits real time bi-directional communication of both programmatic data (marshalled between the host and remote object) and UI information. While for purposes of illustration, the channel parts 130 and 132 have been described as separate parts of the channel 106 that employ different protocols, it is to be appreciated that both the programmatic data and the UI information may be merged into a single stream, in which the UI and programmatic data are combined and communicated with the same protocol (e.g., RDP protocol).
Fig. 3 illustrates an example of a distributed computing environment 200, in which a client computer 202 is operatively connected to multiple remote servers 204 and 206. The client computer 202 includes a host application context 210 having one or more embedded objects (not shown), such as OLE objects or ACTIVEX® controls. In this particular example, at least some of the embedded objects are associated with applications that are not resident on the client computer 202. The client computer 202 is programmed to include a control (e.g., an ACTIVEX® control) that is called into the host application context in response to invoking an object (e.g., by referencing) at the client computer.
By way of example, an object is associated with an HTML document that is in the execution context 210 at the client computer 202. A corresponding application for the object resides in the Internet server 206. The client 202 is operatively coupled to the Internet server 206 through a network 216, such as the World Wide Web via conventional communications links 218 and 220. Typically a plurality of servers 206, 222 and 224 are coupled to the network 216. The client computer 202 is connected to the network 216 via the communications link 218, such as by a modem or other appropriate connection device. Accordingly, low-level communications between the remote server 206 and the client computer 202 may occur in a conventional manner.
Client-side script 214, for example, may be programmed to call a first control 226 to create a remote instance 230 of the object at the server 206 and establish a transparent interactive communications channel between the client 202 and the remote object. More particularly, in response to invocation of the first object (e.g., by referencing the embedded object), the script 214 calls the control 226 into its context. Alternatively, the control 226 may automatically be called into context in response to invoking the object, such as being preprogrammed as part of the host computer's operating system. The alternative approach also makes the entire virtualization of the remote object 230 at the client computer 210 transparent to the controls involved in establishing and maintaining the communications. The control 226, in turn, exposes a method that sends a request (e.g., including GUID or PROGID of the embedded object) to the remote server 206 requesting creation of a remote object 230.
A proxy/stub pair is dynamically created to marshall requests, response, and other control information between the client 202 and the remote object 230. A UI for the remote object 230 also is manufactured at the remote server 206 and communicated to the client 202 by employing an appropriate protocol via an established communications channel implemented within the communications path 218, 216, 220. The channel, for example, may be programmable to facilitate data communications between the context of the host application 210 and the context of the remote object 230. From the perspective of the host application 210 (and a user of the client computer 202), the remote object 230 appears to be running locally on the client computer as the interfaces provided by the control 226 implement policies corresponding to the remote object 230. As described herein, code and user interactions implemented at the client computer 202 are communicated as programmatic data via the communications channel between the remote object 230 and the client. The UI of the remote object 230 also may vary in response to the programmatic data received from the client 202, such as based on client-side scripting and/or user interactions). A graphical portion of the UI transmitted to the client 202 is provided to a display 232 of the client. Accordingly, the remotely generated UI and the host application may share an area of the client display 232.
The host application 210 (or another object on the client computer 202), for example, has another embedded object associated with an application resident on the remote server 204. In this situation, the remote server 204 is operatively coupled to the client computer 202 through a local area network (LAN), indicated schematically at 234. The client 202 is connected, for example, to a Terminal Server session on the server 204. A control 236 is called into the host application context 210 in response to invocation of the other embedded object. The control object 236 exposes a method, which sends a request packet to the remote server 204 requesting creation of an instance 238 of the embedded object according to the attributes of the embedded object. A proxy/stub pair (or another set of suitable interfaces) also is created to marshall programmatic data between the client 202 and the remote object 238. A UI also is manufactured at the remote server 204 for the remote object 238, which UI varies in response to the programmatic data communicated between the proxy/stub pair. The remotely manufactured UI is communicated from the remote server 204 to the client 202 by employing an appropriate protocol (e.g., RDP) via the communications channel connecting the remote session at the server 204 and the client 202. A graphical portion of the UI is displayed on the display 232, with the display showing variations of the remote object 238 in response to UI and/or programmatic data communicated from the client 202 to the remote object. Any changes to the remote object 238 may be stored locally at the client 202 as a modified version of the object embedded within the host application 210.
In addition to interactive communication with remote objects 230 and 238, the system 200 also may employ a conventional mechanism (e.g., COM) to create an object 240 in another execution context 242 within the client computer 202 for an object embedded in the host application. The object 240 is a conventional COM object, with conventional communication mechanisms being employed to relate information between the execution context of the remote object 240 and the host application 210. Briefly stated, a control 244 is exposed for the embedded object, but instead of the control 244 creating a remote instance of the object across a network communications link in accordance with the present invention, the control 244 creates a remote instance of the object in another execution context 242 of the client computer 202. A proxy/stub pair also is created to marshall programmatic data between execution contexts 210 and 242. Additionally, the UI from the remote object may be sent directly to the display 232 in a conventional manner, as it is created locally at the client 202.
It is to be appreciated that any of the objects 230, 238, and 240 also may contain one or more embedded objects that require an application not resident on their corresponding computer. Activation of such embedded objects in the distributed computing environment 200 may, in accordance with an aspect of the present invention described herein, result in establishing an interactive communications channel (for programmatic data and UI information) between each host application context and a remote instance of the object. As result, there may be a chaining effect, in which multiple remote objects have remote instances of embedded objects operating at various computers in the distributed system 200.
By way of example, an email application running locally at the client computer 202 may, in accordance with the present invention, create an object 230, such as a word processing document object, which runs in a word processing application on the remote server 206. The object 230 may, in turn, contain another object embedded therein, such as a spreadsheet object associated with a spreadsheet application not resident on the remote server 206. If the word processing application at the remote server 206 invokes the spreadsheet application that is not local to the remote server, a remote instance of the spreadsheet may be created in accordance with an aspect of the present invention, such as either at the client 202 or at another remote server (e.g., the server 222 or 224).
In order to provide context for the various aspects of the present invention, Fig. 4 and the following discussion are intended to provide a brief, general description of a suitable computing environment 300 in which the various aspects of the present invention may be implemented. While various aspects of the invention have been described above in the general context of computer-executable instructions of a computer program that runs on a local computer and/or remote computer, those skilled in the art will recognize that the invention also may be implemented in combination with other program modules. Generally, program modules include routines, programs, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Moreover, those skilled in the art will appreciate that the inventive methods may be practiced with other computer system configurations, including single-processor or multiprocessor computer systems, minicomputers, mainframe computers, as well as personal computers, hand-held computing devices, microprocessor-based or programmable consumer electronics, and the like.
With reference to Fig. 4, an exemplary distributed computer system environment 300 for implementing the various aspects of the invention includes a conventional computer 302, including a processing unit 304, a system memory 306, and a system bus 308 that couples various system components including the system memory to the processing unit 304. The processing unit 304 may be any of various commercially available processors, including but not limited to Intel x86, Pentium and compatible microprocessors from Intel and others, including Cyrix, AMD and Nexgen; Alpha from Digital; MIPS from MIPS Technology, NEC, IDT, Siemens, and others; and the PowerPC from IBM and Motorola. Dual microprocessors and other multi-processor architectures also may be used as the processing unit 304.
The system bus 308 may be any of several types of bus structure including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of conventional bus architectures such as PCI, VESA, Microchannel, ISA, and EISA, to name a few. The system memory 306 includes read only memory (ROM) 310 and random access memory (RAM) 312. A basic input/output system (BIOS), containing the basic routines that help to transfer information between elements within the computer 302, such as during start-up, is stored in ROM 310.
The computer 302 also may include, for example, a hard disk drive 314, a magnetic disk drive 316, e.g., to read from or write to a removable disk 318, and an optical disk drive 320, e.g., for reading a CD-ROM disk 322 or to read from or write to other optical media. The hard disk drive 314, magnetic disk drive 316, and optical disk drive 320 are connected to the system bus 308 by a hard disk drive interface 324, a magnetic disk drive interface 326, and an optical drive interface 328, respectively. The drives and their associated computer-readable media provide nonvolatile storage of data, data structures, computer-executable instructions, etc. for the computer 302. Although the description of computer-readable media above refers to a hard disk, a removable magnetic disk and a CD, it should be appreciated by those skilled in the art that other types of media which are readable by a computer, such as magnetic cassettes, flash memory cards, digital video disks, Bernoulli cartridges, and the like, may also be used in the exemplary operating environment 300, and further that any such media may contain computer-executable instructions for performing the methods of the present invention.
A number of program modules may be stored in the drives and RAM 312, including an operating system 330, one or more application programs 332, other program modules 334, and program data 336. The operating system 330 in the illustrated computer is, for example, the MICROSOFT WINDOWS NT® operating system available from Microsoft Corporation, of Redmond, Washington, although it is to be appreciated that the present invention may be implemented with other operating systems or combinations of operating systems.
A user may enter commands and information into the computer 302 through one or more user input devices, such as a keyboard 338 and a pointing device (e.g., a mouse 340). Other input devices (not shown) may include a microphone, a joystick, a game pad, a satellite dish, a scanner, or the like. These and other input devices are often connected to the processing unit 304 through a serial port interface 342 that is coupled to the system bus 308, but may be connected by other interfaces, such as a parallel port, a game port or a universal serial bus (USB). A monitor 344 or other type of display device is also connected to the system bus 308 via an interface, such as a video adapter 346. In addition to the monitor, a computer typically includes other peripheral output devices (not shown), such as speakers, printers etc.
The computer 302 operates in a networked environment using logical connections to one or more remote computers, such as a remote computer 348. The remote computer 348 may be a workstation, a server computer, a router, a peer device or other common network node, and typically includes many or all of the elements described relative to the computer 302, although, for purposes of brevity, only a memory storage device 362 is illustrated in Fig. 4. The logical connections depicted in Fig. 4 include a local area network (LAN) 364 and a wide area network (WAN) 366. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet for providing a distributed computing environment.
When used in a LAN networking environment, the computer 302 is connected to the local network 364 through a network interface or adapter 368. When used in a WAN networking environment, the computer 302 typically includes a modem 370, or is connected to a communications server on the LAN 364, or has other means for establishing communications over the WAN 366, such as the Internet. The modem 370, which may be internal or external, is connected to the system bus 308 via the serial port interface 342. In a networked environment, program modules or components depicted relative to the computer 302, or portions thereof, may be stored in the remote memory storage device 362 at the remote computer 348. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers 302 and 348 may be used.
In accordance with the practices of persons skilled in the art of computer programming, the present invention has been described with reference to acts and symbolic representations of operations that are performed by a computer, such as the computer 302 or remote computer 348, unless otherwise indicated. Such acts and operations are sometimes referred to as being computer-executed. It will be appreciated that the acts and symbolically represented operations include the manipulation by the processing unit 304 of electrical signals representing data bits which causes a resulting transformation or reduction of the electrical signal representation, and the maintenance of data bits at memory locations in the memory system (including the system memory 306, hard drive 314, floppy disks 318, and CD-ROM 322) to thereby reconfigure or otherwise alter the computer system's operation, as well as other processing of signals. In a distributed computing environment, selected portions of the computer executable instructions may, in accordance with an aspect of the present invention, be performed at either computer 302, 348, according to the component objects associated with each computer, based on method calls at each computer. The memory locations where such data bits are maintained are physical locations that have particular electrical, magnetic, or optical properties corresponding to the data bits.
According to an aspect of the present invention, processes and program modules are implemented as objects in each computer 302, 348. A process object comprises the following elements: an executable program; a private address space; system resources (e.g., communication ports and files) that the operating system allocates to the process as the program executes; and at least one "thread of execution." A "thread" is the entity within a process that the operating system kernel schedules for execution. As is well known in the art, each thread has an associated "context" which is the volatile data associated with the execution of the thread. A thread's context includes the contents of system registers and the virtual address belonging to the thread's process. Thus, the actual data comprising a thread's context varies as it executes.
As mentioned above, COM and DCOM are models used for object-oriented programming. COM specifies how objects within a single application or between applications (e.g. client/server applications) interact and communicate by defining a set of standard interfaces. Interfaces are groupings of semantically related functions through which a client application accesses the services of a server application.
Object Linking and Embedding (OLE), such as OLE Version 2 and ACTIVEX® controls developed by the Microsoft Corporation of Redmond, Washington, is based on COM and allows the creation of objects of different formats that operate on data through defined interfaces, rather than operating on the applications responsible for the data. The object data can be embedded within an object, or linked to it, so that only a link reference to the data is stored in the object.
In view of the exemplary operating environments shown and described above, a methodology, which may be implemented in accordance with the present invention, will be better appreciated with reference to the flow diagram of Fig. 5. While, for purposes of simplicity of explanation, the methodology of Fig. 5 is shown and described as a series of steps, it is to be understood and appreciated that the present invention is not limited by the order of steps, as some steps may, in accordance with the present invention, occur in different orders and/or concurrently with other steps from that shown and described herein. Moreover, not all illustrated steps may be required to implement a methodology in accordance with the present invention.
Referring to Fig. 5, the process begins at step 400 in which a host application (or object) is running in an associated execution context at a client computer. The host application includes an object embedded therein, which is associated with an application or other object, such as a control, not resident on the client computer. The application to which the embedded object is associated is resident at the remote computer. The client computer may be programmed with data (e.g., in system registry) to know the location of a specific object corresponding to the embedded object. Alternatively or additionally, the client may be programmed with appropriate functionality (controls and interfaces) to determine a location of an appropriate application context for creating a remote instance of the embedded object, such as based on its GUID or PROGID associated with the embedded object.
From step 400, the process proceeds to step 410 in which the embedded object is invoked, such as in response to making a reference to the object (by user interaction or client-side script). The process proceeds to step 420, in which an appropriate control container, such as an ACTIVEX® control container is called into context of the host application. The ACTIVEX® control container provides an environment that can host a remote object. This may be implemented, for example, by a client-side script passing the GUID or PROGID of the object to an appropriate control in response to referencing the embedded object. From step 420, the process proceeds to step 430.
At step 430, a connection is established between the client and a session at a remote server, such as a Terminal Server session. The connection includes a communications channel that employs an appropriate communications protocol. By way of example, the communications channel includes an ORPC channel facility that encapsulates the details of the cross-process and cross-network transport. The communications channel also may employ an appropriate protocol (e.g., RDP) for facilitating UI features generated in the Terminal Server session to appear locally at the client via the communications channel. It is to be appreciated that the Terminal Server session may exist between the client and the remote server prior to invoking the embedded object. In addition, a common protocol may be employed to communicating both UI and programmatic data between the client and the remote object.
Next, at step 440, a request is sent to the remote server to create a remote instance of the object. The request also may specify which interface of the remote object is requested. This may be implemented, for example, by the control sending an appropriate request or method call to a remote host application. At step 450, in response to the request, the remote host creates the remote object, which, for example, has an associated IDispatch interface through which the instantiated remote object may be accessed. Next, at step 460, the remote host dynamically creates a stub for the IDispatch interface. At step 470, the control at the client dynamically creates a proxy and binds the proxy to the stub. The transparent communications layer provided by the proxy/stub pair in conjunction with the part of the communications channel for remoting UI information, provide an interactive communication channel between the remote object and the client in accordance with an aspect of the present invention (step 480).
With the interactive communications channel in place, the proxy/stub pair provides a transparent communications layer between the context of the remote object and the client. That is, the proxy/stub pair marshalls and unmarshalls programmatic data (step 490) between the client and remote object. By way of example, the proxy is an object that marshalls call context of each method or request from the client and forwards an invocation request to the stub. The stub, in turn, unmarshalls the parameters from the invocation request and executes the call with the remote object in its execution context. The stub further marshalls status information (e.g., return code, exception information, etc.) from the remote object, which information is returned to the client proxy. The client proxy, in turn, unmarshalls the programmatic data from the stub and provides it to the appropriate execution context of the client. The proxy/stub pair enables the communication of programmatic data to occur to the client and remote object as if being performed locally within their respective computers.
Next, the process proceeds to step 500 in which a determination is made as to whether the unmarshalled parameter(s) is an interface pointer. An interface pointer, for example, corresponds to an instance of another object that is being or has been created. The object associated with the pointer may, in accordance with the present invention, be created at the client computer, the remote computer, or at another computer that is operatively coupled to the host (client or server computer) requesting creation of the object. If the parameter is an interface pointer, the process proceeds to step 510.
At step 510, a determination is made as to whether a proxy/stub pair already exists for the interface pointer. If a proxy/stub pair does exist, the process proceeds to step 520. If a proxy stub pair does not exist for the interface pointer, however, a new proxy stub pair is created at step 530. This may be substantially similar to the methodology described with respect to steps 460 and 470. It is to be appreciated that any number of proxy/stub pairs may be created in accordance with the present invention, such as to provide a chaining effect between hosts and corresponding remote objects. A proxy/stub pair also may be created for inter-context communication between a host object and another object located in a different execution context of the same computer (e.g., the client or server). If the determination at step 500 is negative, indicating that the parameter is not an interface pointer, the process also proceeds to step 520.
At step 520, the remote server generates UI information indicative of the condition and/or status of the remote object. The process then proceeds to step 540, in which the remotely generated UI information is communicated to the client via the communications channel. The UI information varies based on the user interactions and code manipulation of the remote object, which is communicated as programmatic data from client proxy and unmarshalled by the stub (step 490).
By way of example, client-side script and/or user interaction at the client, such as with a pointer device (e.g., a mouse) or keyboard, may control and/or modify the condition of the remote object as if the object were local. The client-side interactions are communicated to the remote object as programmatic data via the proxy/stub pair for execution by the remote object, which may (depending on the interactions) effect changes in the UI associated with the remote object. As mentioned above, the UI and programmatic data may be merged into a single, bi-directional data stream that employs a common protocol (e.g., RDP). The UI is modified and, in turn, updated UI information is communicated to the client for implementation as part of the client-side display of the remote object. As a result, the UI displayed locally reflects real-time changes in the UI that occur based on client-side interactions so that the remote object may be manipulated as if it were local on the client computer. In addition, the remote object and the host application may share the same display at the client computer. The remotely generated UI even may be directed to an appropriate window address.
At step 550, a determination is made as to whether the client has requested release of the remote object. The release, for example, is based on the value of a reference counter maintained at the client. When the reference counter reaches zero, indicating that no outstanding references exist for the remote object, a release packet is sent to the stub to release the remote object. If this determination (step 550) is negative, the process returns to step 490 to enable interactive communication of both programmatic and UI data between the client and the remote object.
If the determination at step 550 is affirmative, indicating that a client has sent a release packet to the remote server to release the remote object, the process proceeds to step 560 in which the remote object is released. As a result of removing the remote object from the execution context of the remote session, the proxy/stub pair also is removed from their respective contexts. From step 560, the process proceeds to step 570 in which the process ends.
While the foregoing process has been described as a series of steps for implementing communications channels for both programmatic and UI data, it is to be understood and appreciated that such channels typically are not interdependent. For example, changes in the UI may occur asynchronously over the UI channel (or channels) relative to the looped structure illustrated in the flow diagram of Fig. 5. That is, each of the programmatic and UI data channels may be implemented in parallel to each other, but for simplicity of explanation has been shown and described with respect to a common flow diagram.
In view of the foregoing, it is to be appreciated that a system or method in accordance with the present invention facilitates management of container applications, as it allows a remote instance of a COM object embedded in a host application to be created and maintained at a remote server (e.g., in a Terminal Server session) for manipulating the remote object. Moreover, load balancing also is facilitated as COM applications may be employed at a few selected servers to enable a multitude of clients to create a plurality of fully interactive remote objects on the selected servers.
Another benefit of the present invention is that is also permits powerful hybrid applications to be implemented across a network, with the more complex and/or sophisticated programming being resident on one or more remote servers to which the client has access. Each time an embedded object is invoked for which no associated application is resident on the client, a remote instance therefore may be created dynamically at an appropriate server. By way of example, a web page or word processing application may be running locally on a client, but have an embedded object associated with an application not resident on the client. The required application may be a newer version than installed on the client or be an application simply not installed on the client, such as a spreadsheet application or a technical drawing package. In accordance with an aspect of the present invention, invoking the embedded object results in an interactive remote instance of the embedded object to be created remotely at a server to which the client is connected. UI and programmatic data is communicated between the client and the remote instance of the object, thereby enabling full interaction between the client and the remote object as if it were local on the client. Advantageously, from the perspective of the client, the remote object appears to be running locally on the client. Similarly, the remote object "thinks" that the host application that called the application is in the context of the remote object. The client may interact with and manipulate the remote instance of the embedded object, with the UI thereof being provided to the client's display.
Additionally, because only the object creation mechanism may need to be modified to implement a system in accordance with the present invention, the method is compatible with existing and previously written client and server object-oriented applications, and, therefore, can be used without modifying these existing applications. In addition, object references to objects not resident on a host computer can now be added to network object applications (e.g., in HTML or HTML URLs), greatly enhancing the variety and format of information available to network object applications. Accordingly, developers may quickly and cleanly create distributed client/server object applications, using a known and familiar object-oriented programming environment (e.g., OLE), which decreases development time, and lowers overall development costs.
What has been described above are examples of the present invention. It is, of course, not possible to describe every conceivable combination of components or methodologies for purposes of describing the present invention, but one of ordinary skill in the art will recognize that many further combinations and permutations of the present invention are possible. Accordingly, the present invention is intended to embrace all such alterations, modifications and variations that fall within the spirit and scope of the appended claims. Furthermore, to the extent that the term "includes" is used in either the detailed description or the claims, such term is intended to be inclusive in a manner similar to the term "comprising."

Claims

A system comprising:

a first computer running a first object having a second object associated with a remote object;

wherein, in response to invoking the second object at the first computer, the first computer operatively couples to a second computer running the remote object and virtualizes at the first computer a remote instance of the second object running in the remote object and further virtualizes a user interface related thereto via a dynamically created interface.
The system of claim 1, wherein the remote object is an application and the user interface is indicative of a condition of the remote instance of the second object running on the second computer.
The system of claim 2, wherein the remote instance of the second object is a Component Object Model object.
The system of claim 2, wherein the second object is an Object Linking and Embedding object reference.
The system of claim 2, wherein the remote object is an Object Linking and Embedding object reference.
The system of claim 2, wherein a communications channel is created between the remote instance of the second object and the first computer, the communications channel including a first channel part through which programmatic data is communicated between the first computer and the remote instance of the second object, the communications channel including a second channel part through which the user interface is communicated from the remote instance of the second object to the first computer.
The system of claim 6, wherein the first channel part further includes a proxy object at the first computer and a stub object at the second computer operatively associated with interfaces of the remote instance of the second object, the proxy object and stub object marshalling the programmatic data between the first computer and the remote instance of the second object.
The system of claim 2, further including a programmatic mechanism at the first computer for specifying criteria indicative of which object to create in response to invoking the second object at the first computer.
The system of claim 1, further including a control operating at the first computer associated with the first application, the control exposing a method that establishes a communications channel to operatively couple the first computer and the second application in response to invoking the second object.
The system of claim 9, wherein the control is a Component Object Model object.
The system of claim 9, wherein the control is an Object Linking and Embedding object.
The system of claim 1, wherein the first computer is connected to a server session of the second computer, the second application operating in an execution context of the server session.
A system comprising:

a client execution context on a first computer, the client execution context having an object that is associated with a remote host not resident on the first computer;

wherein the first computer includes computer executable instructions for dynamically creating a remote instance of the object in the remote host in response to invoking the object at the first computer, the remote host generating a user interface for the remote instance of the object, the user interface being communicated between the first computer and the remote instance of the object via an interactive bi-directional communications channel between the client execution context and the remote host, programmatic data being communicated between the first computer and the remote instance of the object via the communications channel, whereby interactive communications between the client execution context and the remote instance of the object is provided.
The system of claim 13, wherein the remote instance of the object is a Component Object Model object.
The system of claim 13, wherein the remote instance of the object is an Object Linking and Embedding object.
The system of claim 13, wherein the communications channel includes a first channel part through which the programmatic data is communicated between the first computer and the remote instance of the object, the communications channel including a second channel part through which the user interface is communicated between the remote instance of the object and the first computer.
The system of claim 16, further including a proxy object at the first computer and a stub object at the second computer operatively associated with the remote instance of the object, the proxy object and stub object marshalling the programmatic data between the first computer and the remote instance of the object, thereby enabling bi-directional communications over the first channel part transparent to the client execution context and the remote host.
The system of claim 13, further including a control operating at the first computer associated with the client application, the control exposing a method that establishes the communications channel to operatively couple the first computer and the remote host in response to referencing the object at the client computer.
The system of claim 18, wherein the control is a Component Object Model object.
The system of claim 18, wherein the control is an Object Linking and Embedding object.
The system of claim 13, wherein the first computer is connected to a server session of the second computer via the communications channel, the remote host and the remote instance of the object operating in the server session.
The system of claim 13, further including a programmatic mechanism at the first computer for providing to the remote computer a parameter indicative of which object to create in response to invoking the object at the first computer.
An interactive distributed component object model, comprising:

a host object resident on a host computer having an object embedded therein, a remote instance of the embedded object being created in response to invoking the embedded object; and

a remote object on a remote computer, the remote object being operative to create the remote instance of the embedded object at the remote computer in response to invoking the embedded object, a user interface for the remote instance of the embedded object being generated at the remote computer;

wherein the host computer interactively couples to the remote instance of the embedded object via a dynamically created interface for bi-directional communications of programmatic data and user interface data between the remote instance of the embedded object and the host computer.
The system of claim 23, wherein the remote instance of the embedded object is a Component Object Model object.
The system of claim 23, wherein the remote instance of the embedded object is an Object Linking and Embedding object
The system of claim 23, wherein the embedded object is an Object Linking and Embedding object reference.
The system of claim 23, wherein the embedded object is a Component Object Model object.
The system of claim 23, wherein a communications channel is created between the remote instance of the embedded object and the host computer, the communications channel including a first channel part through which the programmatic data is communicated between the host computer and the remote instance of the embedded object, the communications channel including a second channel part through which user interface data is communicated between the remote instance of the embedded object and the host computer.
The system of claim 28, wherein further including a proxy object associated with the first channel part at the host computer and a stub object associated with the first channel part at the remote computer and operatively associated with the remote instance of the embedded object, the proxy object and stub object marshalling the programmatic data between the host computer and the remote instance of the embedded object.
The system of claim 23, wherein the host computer is programmed to expose a method in response to invoking the embedded object for establishing a communications channel to interactively couple the host computer and the remote instance of the embedded object.
The system of claim 30, further including another object at the host computer for exposing the method.
The system of claim 23, wherein the host computer is connected to a server session of the remote computer, the remote instance of the embedded object operating in an execution context of the server.
The system of claim 23, further including a programmatic mechanism at the host computer for specifying criteria indicative of which object to create in response to invoking the embedded object at the first computer.
The system of claim 23, wherein the host computer includes computer-executable instructions for requesting creation of the remote instance of the embedded object in response to invoking the embedded object.
A computer-readable medium having computer-executable instructions for performing the acts of comprising:

running on a first computer a first object having a second object therein associated with a remote object not resident on the first computer;

in response to invoking the first object, programmatically interfacing the first object with the remote object on a remote computer to create a remote instance of the second object on the remote computer; and

communicating user interface and programmatic data between the remote instance of the second object and the first computer.
The computer-readable medium of claim 35 having further computer-executable instructions for performing the act of creating a communications channel between the remote instance of the second object and the first computer, the communications channel including a first channel part through which the programmatic data is communicated between the first computer and the remote instance of the second object, the communications channel including a second channel part through which the user interface is communicated between the remote instance of the second object and the first computer.
The computer-readable medium of claim 36 having further computer-executable instructions for performing the act of marshalling the programmatic data between the first computer and the remote instance of the second object over the first channel part, thereby enabling communications over the first channel part which is transparent to the first object and the remote object.
The computer-readable medium of claim 36 having further computer-executable instructions for performing the act of exposing a control object that establishes the communications channel to interactively couple the first computer and the remote instance of the second object via a dynamically created interface in response to invoking the object.
The computer-readable medium of claim 35 having further computer-executable instructions for performing the act of specifying criteria indicative of which object to create in response to invoking the second object at the first computer.
The computer-readable medium of claim 39 having further computer-executable instructions for performing the acts of determining a parameter indicative of which object to create in response to invoking the second object at the first computer and sending the parameter to the remote host to effect creation of the remote instance of the second object.
The computer-readable medium of claim 35 having computer-executable instructions for performing the act of requesting creation of the remote instance of the second object in response to invoking the second object at the first computer.
A method for facilitating interactive communications between a client and server in a distributed computing environment, the method comprising:

running on the client a host object having an embedded object associated with a second object resident on the server;

invoking at the client the embedded object;

creating at the server a remote instance of the embedded object in response to invoking the embedded object;

creating an interface between the client and the remote instance of the embedded object in response to invoking the embedded object; and

communicating user interface and programmatic data between the remote instance of the embedded object and the client.
The method of claim 42, wherein the remote instance of the embedded object varies in response to programmatic and user interface data communicated from the client to the server.
The method of claim 42, further including creating a bi-directional communications channel between the remote instance of the embedded object and the client for communicating the user interface and programmatic data between the client and the remote instance of the embedded object.
The method of claim 44, further including communicating programmatic data between the client and the remote instance of the embedded object via a first part of the communications channel , and communicating user interface data between the remote instance of the embedded object and the client via a second part of the communications channel .
The method of claim 45, further including marshalling the programmatic data between the client and the remote instance of the embedded object over the first channel part, the communications over the first channel part being transparent to the client and the remote instance of the embedded object.
The method of claim 42, further including exposing a control object for establishing the communications channel to interactively couple the client and the remote instance of the embedded object in response to the step of invoking.
The method of claim 42, further including specifying which object to create in response to invoking the embedded object.
The method of claim 48, wherein the step of specifying further includes identifying a parameter indicative of which object to create in response to the step of invoking and sending the parameter to a remote host to effect creation of the remote instance of the embedded object.
The method of claim 42, further including the step of requesting creation of the remote instance of the object in response to the step of invoking.
A computer-readable medium having computer-executable instructions for performing the steps set forth in claim 42.
A system comprising:

a first computer running a first object having a second object associated with a remote object;

wherein, in response to invoking the second object at the first computer, the first computer transmits a signal to a second computer having the remote object, the first computer virtualizing a remote instance of the second object and a user interface related thereto via a dynamically created interface in response to signals received from the second computer indicative of the remote instance of the second object running in the remote object at the second computer.
An electronic signal adapted to be transmitted between at least two computers, comprising computer-executable instructions for, in response to invoking a first object operatively associated with a second object running at a first of the at least two computers, creating at a second of the at least two computers a remote object corresponding to the first object, and virtualizing at the first computer a user interface for the remote object via a dynamically created interface between the first and second of the at least two computers.