Asynchronous binding of named objects

• US 6,401,099 B1
• Filed: 12/06/1996
• Issued: 06/04/2002
• Est. Priority Date: 12/06/1996
• Status: Expired due to Term

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Williams, Antony S., Koppolu, Srinivasa R., Stone, Victor, Posch, Johann
• Primary Examiner(s): Coby, Frantz
• Application Number:
  US08/760,924
• Time in Patent Office: 2,006 Days
• Field of Search: 707/103, 707/104, 707/200, 395/200.06, 395/701, 395/703, 395/200, 395/500, 370/249
• US Class Current: 1/1
• CPC Class Codes: G06F 9/543 User-generated data transfer, e.g. clipboards, dynamic data exchange [DDE], object linking and embedding [OLE]
• CPC Class Codes: Y10S 707/99944 Object-oriented database structure
• CPC Class Codes: Y10S 707/99945 Object-oriented database structure processing

Abstract

An object-oriented framework unifies retrieval and browsing of data locally and from remote computer networks. The framework includes a class of monikers that operate on behalf of a client program to asynchronously bind or retrieve data referenced by a name without blocking execution of the client. This allows the client to provide responsive user interaction including when remotely retrieving data.

Claims

1. An object-oriented framework for providing asynchronous retrieval of data from a storage site for a client, wherein the client comprises plural instructions for executing, the object-oriented framework comprising:

a naming object having a reference to the data; and

a binding function callable from the client to initiate asynchronous retrieval of the data from the storage site, the client continuing instruction execution independently of the retrieval of the data from the storage site.

2. The object-oriented framework of claim 1 comprising:

a bind context object for the client to register a call back interface callable from the naming object, wherein the call back interface exposes one or more functions supported by the client for the naming object to invoke in order to initiate communication with the client.

3. The object-oriented framework of claim 2 wherein the call back interface exposes a function operable to notify the client about progress of the data retrieval.

4. The object-oriented framework of claim 2 wherein the call back interface exposes a function for the naming object to get parameters relating to the data retrieval from the client, whereby the client controls aspects of the data retrieval.

5. The object-oriented framework of claim 1 wherein the naming object operates in a data pull mode to retrieve the data from the storage site when the client reads the data.

6. The object-oriented framework of claim 1 wherein the naming object operates in a data push mode to retrieve the data from the storage site and notify the client when the data is available for reading.

7. The object-oriented framework of claim 1 comprising:

an asynchronous storage object provided by the naming object for storing the data retrieved from the storage site, and for allowing access by the client to a part of the data already retrieved from the storage site during the data retrieval before the data retrieval is completed.

8. The object-oriented framework of claim 7 wherein the asynchronous storage object has a non-blocking mode in which execution of the client is not blocked when accessing a part of the data not yet retrieved from the storage site, and a blocking mode in which execution of the client is blocked when accessing the part of the data not yet retrieved from the storage site, the asynchronous storage object operating in the blocking or non-blocking mode as set by the client.

9. The object-oriented framework of claim 1 wherein the naming object is operative to perform asynchronous or synchronous data retrieval depending on a flag set by the client.

10. The object-oriented framework of claim 1 comprising:

a function provided by the naming object for the client to interrupt the data retrieval.

11. The object-oriented framework of claim 1 comprising:

a binding interface provided by the naming object and having functions callable from the client to cause the data retrieval to abort, suspend, and resume.

12. The object-oriented framework of claim 1 comprising:

a plurality of other naming objects for retrieving data from storage sites;

the naming object performing the data retrieval according to a priority set by the client relative to data retrievals performed by the other naming objects.

13. The object-oriented framework of claim 1 wherein the reference is a resource identifier of data residing on a remote computer network, the naming object operating to asynchronously retrieve the data for the client from the remote computer network.

14. The object-oriented framework of claim 13 in which the naming object obtains information of any preferred formats for the data from the client, and retrieves the data from the remote computer network in an available one of the preferred data formats.

15. The object-oriented framework of claim 13 in which the naming object performs media type negotiation between the client and the remote computer network of a format in which the naming object retrieves the data.

16. The object-oriented framework of claim 13 comprising:

a bind context object for the client to register an interface provided by the client having a format enumeration function callable from the naming object for the client to request any preferred formats for the data, the naming object operating to retrieve the data in an available one of the preferred formats from the remote computer network.

17. The object-oriented framework of claim 13 comprising:

a bind context object for the client to register an interface provided by the client having an authentication function callable from the naming object for the client to provide authentication of the data retrieval from the remote computer network.

18. The object-oriented framework of claim 13 in which the naming object performs parameter negotiation between the client and the remote computer network of a transport protocol with which the naming object retrieves the data from the remote computer network.

19. The object-oriented framework of claim 13 comprising:

a bind context object for the client to register an interface provided by the client having functions callable from the naming object for the client to negotiate parameters of a transport protocol for retrieving the data from the remote computer network.

41. The object-oriented framework of claim 1 wherein the data retrieval and the client instruction execution occur concurrently.

42. The object-oriented framework of claim 1 wherein the data retrieval occurs as a background process.

20. A method of retrieving data in a computer system, comprising:

providing an interface of a naming object having a reference designating stored data to a client application, wherein the client application comprises plural instructions for executing, the interface exposing a binding function of the naming object operative to perform a binding operation on the stored data; and

on a call from the client application to the binding function, initiating binding the stored data as a background process while returning execution to the client application, the client application continuing instruction execution independently of the binding operation on the stored data.

21. The method of claim 20 comprising receiving a call back interface on the client application, the call back interface exposing at least one function supported by the client application callable from the naming object for sending notifications relating to the binding operation of the stored data from the naming object to the client application.

22. The method of claim 21 comprising:

repeatedly calling a progress notification function of the call back interface during the binding operation to provide an indication of the progress of the binding operation to the client application.

23. The method of claim 21 comprising:

calling a data available notification function of the call back interface to notify the client application at a time before the binding operation is completed that a retrieved part of the stored data is available for the client application to access.

24. The method of claim 21 comprising:

calling a stop binding notification function of the call back interface to notify the client application of a status of the binding operation at ending the binding operation.

25. The method of claim 20 comprising:

passing a binding interface by the naming object to the client application, the binding interface exposing an abort function; and

terminating the binding operation upon a call from the client application to the abort function.

26. The method of claim 20 comprising:

passing a binding interface by the naming object to the client application, the binding interface exposing a suspend function and a resume function;

suspending the binding operation upon a call from the client application to the suspend function; and

resuming the binding operation upon a call from the client application to the resume function.

27. The method of claim 20 comprising:

passing a binding interface by the naming object to the client application, the binding interface exposing a priority setting function; and

establishing a priority of a thread for executing the binding operation according to a value passed from the client application in a call to the priority setting function.

28. The method of claim 20 comprising:

providing an interface of a bind context object to the client application, the bind context object operative to register a call back interface of the client application, wherein the call back interface exposes functions supported by the client application callable from the naming object to initiate communication with the client application;

receiving the interface of the bind context object in the client application'"'"'s call to the binding function; and

calling functions on the call back interface to provide notifications to the client application relating to the binding operation.

29. The method of claim 20 comprising, in the binding operation:

creating a storage object having an interface which exposes a read function for reading data in the storage object;

passing the interface of the storage object to the client application; and

retrieving the stored data into the storage object by the background process, whereby the client application has access to the stored data in the storage object during the binding operation.

30. The method of claim 29 comprising:

returning a retrieval pending error notification to the client application when the client application calls the read function to access the stored data which is not yet retrieved into the storage object.

31. A method of creating a moniker object to retrieve data referenced by a name, the name having a prefix portion indicative of a transport protocol followed by a colon character, the method comprising:

registering a program identifier indicative of the transport protocol in association with a class identifier in a registry database, the class identifier being associated with a server application which supports a class of transport protocol object, objects of said class being operative to communicate using the transport protocol to retrieve named data and having a name parsing function operative to create monikers from names using the transport protocol;

parsing the prefix portion up to the colon character from the name;

searching the program identifiers in the registry for a match to the prefix portion;

on matching the prefix portion to the program identifier indicative indicative of the transport protocol, instantiating a transport protocol object of said class and calling the name parsing function on the name so as to create the moniker object.

32. A storage medium having instructions therein for causing a computer to perform a data retrieval method comprising the steps of:

creating a bind context object for storing information relating to a binding operation;

registering a call back interface supported by a client application with the bind context object, wherein the call back interface exposes functions supported by the client application callable from the naming object to initiate communication with the client application, and wherein the client application comprises plural instructions for executing;

creating a moniker object containing a name that references stored data and having a bind function;

initiating a binding operation in the bind function which executes asynchronously of the client application, the client application continuing instruction execution independently of the binding operation; and

providing notifications to the client application relating to the binding operation'"'"'s status with the call back interface.

33. The storage medium of claim 32 wherein the data retrieval method further comprises:

returning a bind interface from the moniker object to the client application, the bind interface having functions for at least one of aborting, suspending, resuming, and setting an execution priority of the binding operation.

34. The storage medium of claim 32 wherein the step of providing notifications in the method comprises:

repeatedly providing progress notifications during the binding operation to the client application indicative of which proportion of the binding operation is complete.

35. The storage medium of claim 32 wherein the method comprises:

registering information in the bind context of any media types acceptable to the client application for retrieving the stored data; and

retrieving the stored data in the binding operation in one of said acceptable media types.

36. In a computer system having at least one computer, a moniker object comprising:

a name element for storing a name that identifies data stored in the computer system;

an interface structure through which a client invokes method elements of the moniker object via synchronous calls that suspend instruction execution of the client pending return from the synchronous calls; and

a bind method element invoked by the client through such a synchronous call using the interface structure, the invoked bind method element operating to commence a retrieval operation to retrieve the data identified by the name and to return from said synchronous call during the retrieval operation, the return from said synchronous call permitting continued instruction execution of the client independent of the retrieval operation, whereby the continued instruction execution of the client occurs asynchronously of the retrieval operation.

37. The moniker object of claim 36 in combination with a bind context object for the client to register a call back interface callable from the moniker object, wherein the call back interface exposes one or more functions supported by the client for the moniker object to invoke in order to initiate communication with the client.

38. The moniker object of claim 36 in combination with an asynchronous storage object provided by the moniker object for storing retrieved data, and for allowing access by the client to a part of the retrieved data during the retrieval operation before the retrieval operation is completed.

39. The moniker object of claim 36 further comprising:

a flow control element invoked by the client through such a synchronous call using the interface structure, the invoked flow control element operating to affect the execution of the retrieval operation.

40. The moniker object and bind context object of claim 38 wherein the moniker object obtains information of any preferred data formats from the client, and retrieves the data from a remote computer in the computer system in an available one of the preferred data formats.

43. An object-oriented framework for providing asynchronous retrieval of data from a storage site for a client application program, wherein the client application program includes plural instructions for executing, and wherein the client application program further includes a name that references a named item, the object-oriented framework comprising:

association data defining an association of the name to the named item;

a system object that exposes a programming interface to the client application program, wherein the programming interface includes a retrieval function, wherein the client application program initiates asynchronous retrieval of data for the named item through the retrieval function, and wherein the client application program continues instruction execution independently of the asynchronous retrieval of data.

44. The object-oriented framework of claim 43 wherein the programming interface returns to the client application program a reference to a control interface, and wherein the client application program controls the asynchronous retrieval of data through the control interface.

45. The object-oriented framework of claim 43 wherein the name reflects a hierarchical name space.

46. The object-oriented framework of claim 43 wherein the name indicates a transport protocol, and wherein the initiated asynchronous retrieval of data occurs according to the indicated transport protocol.

47. The object-oriented framework of claim 43 wherein the system object places the asynchronously retrieved data in persistent storage.

48. The object-oriented framework of claim 43 wherein the system object places the asynchronously retrieved data in an object associated with the name.

49. An object-oriented framework for providing asynchronous retrieval of data from a storage site for client application program, wherein the client application program includes plural instructions for executing, and wherein the client application program furthr includes a name that references a named item, the object-oriented framework comprising:

association data defining an association of the name to the named item, wherein the name further indicates a transport protocol for retrieving data for the named item;

a retrieval object that implements the transport protocol indicated by the name, wherein the retrieval object handles asynchronous retrieval of data for the named item at the transport protocol level, and wherein the client application program continues instruction execution independently of the asynchronous retrieval of data.

50. The object-oriented framework of claim 49 wherein the retrieval object exposes control interface that includes one or more functions for controlling the asynchronous retrieval of data.

51. the object-oriented framework of claim 49 wherein a system object encompasses the association data and the retrieval object.

52. The object-oreiented framework of claim 49 wherein computer storage persistently stores the asynchronously retrieved data.

53. The object-oriented framework of claim 49 wherein an object associated with the name encapsulates the asynchronously retrieved data.

54. A method of communicating between a client application program and a system object to asynchronously retrieve data stored in a computer system, the method comprising:

initiating by client application program an asynchronous retrieval operation of stored data for a named item, wherein the asynchronous data retrieval operation executes as a background process, and wherein the client application program continues execution independently of the asynchronous retrieval operation; and

providing a control interface to the client application program, wherein the control interface includes functions for the client application program to call to control the asynchronous retrieval operation.

55. The method of claim 54 further comprising:

on a call from the client application program to an abort function of the control interface, aborting the asynchronous retrieval operation.

56. The method of claim 54 further comprising:

on a call from the client application to a suspend function of the control interface, suspending the asynchronous retrieval operation.

57. The method of claim 54 further comprising:

persistently storing asynchronously retrieved data in computer storage.

58. The method of claim 54 further comprising:

encapsulating asynchronously retrieved data within an object associated with the named item.

59. A method of communicating between a client application program and a system object to asynchronously retrieve data stored in a computer system, wherein the client application program includes a client object, the method comprising:

initiating by a client application program an asynchronous retrieval operation of stored data for a named item, wherein the a synchronous data retrieval operation executes as a background process, and wherein the client application program continues execution independently of the asynchronous retrieval operation; and

providing a callback interface to the system object, wherein the callback interface includes functions for the system object to call to notify the client object of events concerning the asynchronous retrieval operation.

60. The method of claim 59 comprising:

on a call to a completion function of the callback interface, notifying the client object of the completion of the asynchronous retrieval operation.

61. The method of claim 59 further comprising:

on a call to a partial completion function of the callback interface, notifying the client object of the partial completion of the asynchronous retrieval operation.

62. The method of claim 59 further comprising:

placing asynchronously retrieved data in persistent computer storage.

63. The method of claim 59 further comprising:

placing asynchronously retrieved data in an object associated with the named item.

64. An object-oriented framework for providing asynchronous retrieval of data for a named item for a client application program, wherein the client application program includes plural instructions for executing, and wherein the client application program further includes a name that references the named item, the object-oriented framework comprising:

a name parsing interface accessible to the client application program and operating to parse a name passed from the client application program in a request issued by the client application program to the interface, the name parsing interface identifying the type of the name and providing a name-type specific object to the client application program; and

the name-type specific system object exposing a programming interface to the client application program wherein the programming interface includes a retrieval function, wherein the client application program initiates asynchronous retrieval of data for the named item through the retrieval function, and wherein the client application program continues instruction execution independently of the asynchronous retrieval of data.

65. The object-oriented framework of claim 64 wherein the name-type specific system object encapsulates name to named item association data.

66. The object-oriented framework of claim 64 wherein the name-type specific system object is a moniker object.

67. An object-oriented framework for providing asynchronous data retrieval for a named item for a client application program, wherein the client application program includes plural instructions for executing, and wherein the client application program further includes a name that references the named item, the object-oriented framework comprising:

a service object that instantiates one or more system objects, wherein the service object is callable from a client applicatino program; and

a system object that exposes a programming interface to the client application program, wherein the service object instantiates the system object, wherein the programming interface includes a retrieval function, wherein the client application program initiates asynchronous retrieval of data for the named item through the retrieval function, and wherein the client application program continues instruction execution indenpendently of the asynchronous retrieval of data.

68. The object-oriented framework of claim 67 wherein the service object instantiates a name-type specific system object.

69. A method for encapsulating asynchronously retrieved data within an object for a client application program, wherein the client application program includes plural instructions for executing, the method comprising:

de-referencing a data type to an object type;

instantiating an object of the object type;

asynchronously retrieving the data, wherein the client application program continues instruction execution independently of the asynchronous retrieval of the data; and

encapsulating the asynchronously retrieved data within the instantiated object.