Version-resilient loader for custom code runtimes

1. A computing system for dynamically identifying and loading a version of a runtime for custom code, the custom code for execution within a host process of a host application, the computing system comprising:

a memory storing computer-executable instructions of:

a host application that hosts custom code for execution within the host process; and

a loader component for execution within the host process that:

receives from the host application executing within the host process a request to load custom code identified by a custom code identifier;

executes an algorithm that identifies a version of a runtime for the custom code, the algorithm

collects system information including information relating to different versions of the runtime that are available to be loaded and executed within the host process; and

identifies, based on the system information, a version of the runtime to load;

loads the identified version of the runtime for execution within the host process;

requests a load component of the loaded version of the runtime to load the custom code identified by the custom code identifier; and

invokes the loaded custom code for execution within the host process of the host application as hosted custom code so that different runtimes are loaded into the hosted application depending of the version of the runtime needed by each custom code;

wherein the loader component is dynamically linked to the host application so that the algorithm that identifies the version of the runtime can be modified without modifying the host application and

wherein the components are stored in a dynamic-link library and

a processor that executes the computer-executable instructions stored in the memory.

2. The computing system of claim 1 wherein the system information includes operating system information.

3. The computing system of claim 1 wherein the components are implemented using unmanaged code.

4. The computing system of claim 1 including a component that collects custom code information relating to the custom code to be loaded and wherein the component that identifies a version of the runtime performs the identification based on the custom code information.

5. The computing system of claim 4 wherein the custom code information specifies a version of the runtime to load.

6. The computing system of claim 5 wherein the component that identifies overrides the specification of the version by the custom code information when it is determined that a later version of the runtime is compatible with the custom code.

7. The computing system of claim 1 wherein the load component of the runtime dynamically deploys the custom code.

8. The computing system of claim 1 wherein system information specifies compatibility between versions of the host application and versions of the runtime.

9. A computer-readable memory embedded with computer-readable instructions for controlling a computing system to load custom code, the custom code for providing customization of a host application, the custom code using a runtime that supports the customization of the host application, by a method comprising:

under control of the host application executing within a host process as unmanaged code,

loading a custom code loader proxy for execution within the host process of the host application as unmanaged code, wherein the custom code loader proxy is stored in a dynamic-link library; and

requesting the loaded custom code loader proxy to load the custom code;

under control of the custom code loader proxy executing within the host process,

identifying a version of the runtime that is compatible with the host application and the custom code to be loaded;

loading the identified version of the runtime for execution within the host process; and

requesting an unmanaged custom code loader of the loaded runtime to load the custom code;

under control the unmanaged custom code loader of the runtime executing within the host process as unmanaged code,

starting execution of the runtime for execution of managed code;

requesting a managed custom code loader of the runtime to load the custom code;

under control of the managed custom code loader of the loaded runtime executing within the host process as managed code, loading the custom code for execution with the host process as managed code; and

under control of the custom code executing within the host process as managed code, using services provided by the runtime to effect customization of the host application.

10. The computer-readable memory of claim 9 wherein the identifying is based on compatibility between version of the host application, version of the custom code installed on the computing system, and version of an operating system under which the host application executes.

11. The computer-readable memory of claim 9 wherein a new custom code loader proxy is installed by replacing the dynamic-link library on which is stored an old custom code loader proxy with a dynamic-link library on which is stored the new custom code loader proxy.

12. The computer-readable memory of claim 9 wherein the custom code specifies a version of the runtime.

13. The computer-readable memory of claim 12 wherein the identifying overrides the specification of the version when a later version of the runtime is compatible with the custom code.

14. The computer-readable memory of claim 9 wherein the loading of the custom code includes deploying of the custom code from a server.