Component self-deactivation while client holds a returned reference

• US 7,043,734 B2
• Filed: 02/15/2005
• Issued: 05/09/2006
• Est. Priority Date: 10/28/1997
• Status: Expired due to Fees

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Limprecht, Rodney T., Agsen, Mohsen M., Helland, Patrick James
• Primary Examiner(s): Thompson, William
• Assistant Examiner(s): Opie, George L.
• Application Number:
  US11/059,033
• Publication Number:
  US 20050149953A1
• Time in Patent Office: 448 Days
• Field of Search: 719/315, 719/316, 719/328, 719/310, 719/313, 718/101, 718/104, 718/107, 718/108, 718/100, 707/8, 707/103, 707/206, 707/203
• US Class Current: 719/315
• CPC Class Codes: G06F 12/0261 using reference counting
• CPC Class Codes: G06F 2209/541 Client-server
• CPC Class Codes: G06F 9/5016 the resource being the memory
• CPC Class Codes: G06F 9/5022 Mechanisms to release resources
• CPC Class Codes: G06F 9/54 Interprogram communication

Abstract

A component-based framework includes system services and component integration interfaces that provide a run-time environment for component-based server application in which server application components have control over the duration of their state independent of client action. The framework provides functions that a server application component calls to indicate its work for a client is complete, and its state is to be destroyed. On the component'"'"'s return from the client'"'"'s method call, the framework destroys the component'"'"'s state thus releasing any server computer resources held by the component. This allows the server application components to be programmed so as to minimize the duration that their state remains in memory consuming server computer resources, and which enhances scalability of the server application.

Claims

1. In a computer device having a main memory, a method of enhancing scalability of server applications, the method being implemented at least in part by the computer device, the method comprising:

returning a reference to a client responsive to receiving a request for creation of an application component;

executing the application component under control of an operating service, the application component having a state and function code for performing work responsive to method invocations from the client;

providing an interface for the operating service to receive an indication from the application component that the work is complete;

maintaining the state in the main memory between the method invocations of the function code by the client in the absence of the indication from the application component that the work is complete; and

while the client that requested creation of the application component retains the returned reference, destroying the state of the application component in response to the indication from the application component to the operating service at the provided interface that the work is complete.

2. The method of claim 1 wherein the operating service retains an operating service'"'"'s reference to the application component and the step of destroying the state comprises releasing the operating service'"'"'s reference to the application component by the operating service without a deactivation request from the client.

3. The method of claim 1 wherein the step of destroying the state comprises resetting the state to the initial post-creation state.

4. The method of claim 1 wherein said destroying the state is performed by the operating service upon a return of the application component from a client'"'"'s method invocation call following the indication from the application component that the work is complete.

5. The method of claim 1 wherein the application component'"'"'s state is destroyed before receiving any indication from the client that the application component'"'"'s work is complete.

6. The method of claim 1 wherein the application component'"'"'s state is destroying upon a next return of the application component from a call of the client following the indication from the application component that the work is complete.

7. The method of claim 1, further comprising:

subsequent to destroying the state of the application component, restoring the state of the application component in main memory upon receiving a method invocation from the client via the reference.

8. In a computer device, a computer operating environment for executing scalable, component-based server applications, comprising:

a run-time service for executing an application component in a process, the application component having a state and implementing a set of functions;

an instance creation service operative, responsive to a request of a client, to return a reference to the application component through the run-time service to the client, whereby the client calls functions of the application component indirectly through the run-time service using the reference to initiate work by the application component; and

the run-time service being operative, responsive to an indication from the application component that work is complete, to destroy the application component'"'"'s state upon returning from a call by the client, wherein the run-time service destroys the application component'"'"'s state while the client maintains the reference returned to the application component.

9. The computer operating environment of claim 8 wherein a component context is associated by the run-time service with the application component and the component context provides an interface having a member function that the application component calls to initiate the indication.

10. The computer operating environment of claim 9 wherein the application component performs work within a transaction and wherein calling the member function of the component context causes the transaction to abort.

11. The computer operating environment of claim 9 wherein the application component performs work within a transaction and wherein calling the member function of the component context permits the transaction to commit.

12. The computer operating environment of claim 8 wherein the run-time service holds a reference to an instance of the application component, and destroys the application component'"'"'s state by releasing the reference to the instance.

13. The computer operating environment of claim 8 wherein the run-time service destroys the application component'"'"'s state by resetting the state.

14. The computer operating environment of claim 8 wherein the run-time destroys other application component'"'"'s state without an indication from the client allowing the application component'"'"'s state to be destroyed.

15. The computer operating environment of claim 8, wherein destroying the application component'"'"'s state does not include notifying the client that the application component'"'"'s state is destroyed.

16. One or more tangible computer-readable media comprising computer executable instructions comprising:

code responsive to a request from a client program to create an application component for returning to the client program a reference through a system service to the application component;

code responsive to a call from the client program using the reference for initiating processing of work by the application component, the application component producing a processing state during processing the work;

code for receiving an indication from the application component that processing by the application component of the work is complete; and

code for, while the client program retains the reference, destroying the processing state of the application component responsive to the indication from the application component that processing by the application component of the work is complete.

17. The computer-readable media of claim 16 further comprising:

code for producing an instance of the application component and retaining a reference to the instance, the instance containing the processing state; and

wherein the code for destroying the processing state comprises code for releasing the reference to the instance without action from the client program to thereby cause the processing state to be destroyed.

18. The computer-readable media of claim 16 wherein the system service destroys the processing state by resetting the processing state.

19. The computer-readable media of claim 16 wherein the application component initiates the indication before returning from a client program'"'"'s call to initiate processing of the work.

20. The computer-readable media of claim 16 wherein after the processing state of the application component is destroyed, the client program requests processing of work using the retained reference.