Server application components with control over state duration

• US 7,043,733 B2
• Filed: 06/14/2004
• 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, Helland, Patrick James, Al-Ghosein, Mohsen
• Primary Examiner(s): Thomson, William
• Assistant Examiner(s): OPIE, GEORGE L
• Application Number:
  US10/868,138
• Publication Number:
  US 20040230986A1
• Time in Patent Office: 694 Days
• Field of Search: 719/315, 719/316, 719/310, 719/313, 719/328, 718/100, 718/101, 707/103, 707/203, 707/206
• 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, a computer operating environment for 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 the application component has completed the work for the client, to destroy the application component'"'"'s state on the application component returning from a call by the client without action by the client.

2. The computer operating environment of claim 1 wherein the application component initiates the indication before returning from the call by the client, whereby the application component'"'"'s state is destroyed immediately on return from the client'"'"'s call without further action by the client.

3. The computer operating environment of claim 1 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.

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

5. The computer operating environment of claim 1 wherein the application component initiates the indication before returning from the call by the client and before the client releases the reference to the application component.

6. In a computer, a method of encapsulating state of processing work for a client by a server application in a component with improved scalability, comprising:

encapsulating function code and a processing state for the work in a component;

providing a reference through an operating service for a client to call the function code of the component to initiate processing of the work by the component;

receiving an indication from the component that the work by the component is complete; and

discarding the processing state of the component responsive to the component indicating completion of the work before receiving any indication from the client that the component'"'"'s work is complete.

7. The method of claim 6 wherein the indication that the work is complete is received from the component before the client releases the reference, whereby the processing state is discarded immediately upon return from the client'"'"'s call.

8. The method of claim 6 wherein the operating service holds a reference to an instance of the component, and destroys the component'"'"'s state by releasing the reference to the instance.

9. The method of claim 6 wherein the operating service destroys the processing state by resetting the processing state.

10. The method of claim 6 wherein the component initiates the indication before returning from a client'"'"'s call to initiate processing of the work.

11. In a computer, a system service for providing an execution environment for scalable application components, comprising:

code responsive to a request from a client program to create an application component for returning to the client program a reference through the 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 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 and without action from the client program.

12. The system service of claim 11 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.

13. The system service of claim 11 wherein the code for destroying the processing state comprises:

code for resetting the processing state to an initial state of the application component.

14. In a computer having a main memory, a method of enhancing scalability of server applications, comprising:

executing an 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 a client;

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

destroying the state by the operating service in response to an indication from the application component without action by the client, such that the destroyed state is not persistent.

15. A computer-readable medium comprising computer executable instructions comprising:

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

instructions 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;

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

instructions for 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 and without action from the client program.

16. The computer-readable medium of claim 15 further comprising computer executable instructions comprising:

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

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

17. The computer-readable medium of claim 16 wherein the instructions for destroying the processing state comprise instructions for resetting the processing state to an initial state of the application component.

18. The computer-readable medium of claim 16 wherein the instructions for receiving an indication from the application component that the processing is complete are received from the application component before the client program releases the reference, whereby the processing state is discarded immediately upon return from the client program'"'"'s call.

19. The computer-readable medium of claim 16 wherein the system service holds a reference to an instance of the application component, and destroys the processing state by releasing the reference to the instance.

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

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