zh
stringlengths 2
4.05k
| en
stringlengths 5
1.02k
| sco
float64 1
1
|
|---|---|---|
创建和注册一个直接连接到服务器代码的绑定句柄;以及
|
creating and registering a binding handle that connects directly to the server code; and
| 1
|
返回客户端进程一个引用创建的绑定句柄作为对执行服务器代码的引用。
|
returning to the client process a reference to the created binding handle as the reference to the executing server code.
| 1
|
计算机系统中用于调用存储在动态链接库中的服务器代码的方法,计算机系统具有请求调用服务器代码的客户端进程的计算机系统,该方法包括:
|
A method in a computer system for invoking server code that is stored in a dynamically linkable library, the computer system having a client process that requests invocation of the server code, the method comprising:
| 1
|
执行存储在加载动态链接库中的服务器代码;
|
executing the server code stored in the loaded dynamically linkable library;
| 1
|
在代理过程中,创建被请求类型的对象对象对象对象实例,该对象由存储在引用的动态链接库中的代码实现;以及
|
creating, in the surrogate process, an object instance of a requested type of object implemented by code stored in the referenced dynamically linkable library; and
| 1
|
返回 client 进程在代理进程中对已创建对象实例的请求接口的引用,客户端进程使用返回的引用访问代理进程中被创建对象实例的请求接口,通过执行相同的客户端代码,当在客户端进程中创建请求类型的对象实例时,用于访问请求的接口。
|
returning to the client process a reference to a requested interface of the created object instance in the surrogate process, the returned reference being used by the client process to access the requested interface of the created object instance in the surrogate process by executing the same client code that is used to access the requested interface when an instance of the requested type of object is created in the client process.
| 1
|
在客户流程的控制下,
|
under control of the client process,
| 1
|
使用返回的对请求接口的引用,请求调用请求接口的方法;以及
|
using the returned reference to the requested interface, requesting invocation of a method of the requested interface; and
| 1
|
透明地将方法调用请求转发到代理进程,该进程将方法调用请求透明地转发到创建的对象实例。
|
transparently forwarding the method invocation request to the surrogate process, which transparently forwards the method invocation request to the created object instance.
| 1
|
权利要求 9 的方法,返回客户端进程在代理进程中对创建对象实例所请求的接口的引用,进一步包括:
|
The method of claim 9, the returning to the client process the reference to the requested interface of the created object instance in the surrogate process further comprising:
| 1
|
创建和注册绑定句柄,该句柄直接连接到实现创建对象实例请求接口的服务器代码;以及
|
creating and registering a binding handle that connects directly to the server code that implements the requested interface of the created object instance; and
| 1
|
返回客户端进程一个对创建的绑定句柄的引用,作为对创建对象实例请求接口的引用。
|
returning to the client process a reference to the created binding handle as the reference to the requested interface of the created object instance.
| 1
|
计算机系统中用于调用存储在动态链接库中的服务器代码的方法,该方法包括:
|
A method in a computer system for invoking server code that is stored in a dynamically linkable library, the method comprising:
| 1
|
接收从第一个进程调用服务器代码的请求;
|
receiving from a first process a request to invoke the server code;
| 1
|
响应接收到的请求,调用代理进程,引用动态可链接库,该库存储服务器代码和类标识符,类标识符识别具有共同行为的对象类,对应于类工厂对象,存储服务器代码实现的类工厂对象,并具有创建方法,用于创建类标识符识别的对象类对象的对象的对象,其中代理进程是一个独立可执行的过程,用于加载存储在动态可链接库中的服务器代码,并且可以实例化一个对象;
|
in response to the received request, invoking a surrogate process with a reference to the dynamically linkable library that stores the server code and with a class identifier, the class identifier identifying a class of objects with common behavior and corresponding to a class factory object, the class factory object implemented by the stored server code and having a creation method for creating an object of the class of objects identified by the class identifier, wherein the surrogate process is an independently executable process for loading server code that is stored in a dynamically linkable library and that can instantiate an object;
| 1
|
创建一个类工厂对象的实例,该实例对应于调用的代理进程中的类标识符;以及
|
creating an instance of the class factory object that corresponds to the class identifier within the invoked surrogate process; and
| 1
|
注册已创建的 class 工厂对象实例,以便其他进程可以使用 creation 方法创建由 class 标识符识别的对象类的对象实例,而不知道 class 工厂对象实例在不同的进程中实例化,每个创建的对象实例都由存储在代理进程中加载的可链接库中的代码实现。
|
registering the created class factory object instance so that other processes can create object instances of the class of objects identified by the class identifier using the creation method without knowledge that the class factory object instance is instantiated in a different process, each created object instance being implemented by code that is stored in the linkable library that is loaded in the surrogate process.
| 1
|
接收请求代码的请求,以创建类标识符识别的对象类的对象的实例;以及
|
receiving a request from requesting code to create an object instance of the class of objects identified by the class identifier; and
| 1
|
在响应请求时,在代理进程中调用已注册的类工厂对象实例的创建方法,而请求的代码不知道创建方法正在代理进程中执行。
|
in response to the request, invoking the creation method of the registered class factory object instance within the surrogate process without the requesting code having knowledge that the creation method is being executed within the surrogate process.
| 1
|
权利要求 16 的方法,其中创建对象实例的请求代码是从代理过程以外的进程接收的,并进一步包括:
|
The method of claim 16 wherein the requesting code to create the object instance is received from a process other than the surrogate process, and further comprising:
| 1
|
在收到创建对象实例的请求后,确定与类标识符对应的类工厂对象是否注册;以及
|
after receiving the request to create the object instance, determining whether a class factory object corresponding to the class identifier is registered; and
| 1
|
只有当确定相应的 class 工厂对象已注册时,在代理进程中执行已注册的 class 工厂对象实例的 creation 方法。
|
only when it is determined that the corresponding class factory object is registered, performing the invoking of the creation method of the registered class factory object instance within the surrogate process.
| 1
|
计算机系统中用于调用具有服务器代码的服务器应用程序的方法,该方法包括计算机实现的步骤:
|
A method in a computer system for invoking a server application having server code, the method comprising the computer-implemented steps of:
| 1
|
接收从第一个进程调用服务器应用程序的请求;
|
receiving from a first process a request to invoke the server application;
| 1
|
响应接收到的请求,调用代理进程,引用动态链接库,该库包含服务器代码和类标识符,类标识符识别具有共同行为的对象类,对应于类工厂对象,由包含的服务器代码实现的类工厂对象,并包含创建方法,用于创建类标识符识别的对象类的对象的对象;
|
in response to the received request, invoking a surrogate process with a reference to a dynamically linkable library that contains the server code and with a class identifier, the class identifier identifying a class of objects with common behavior and corresponding to a class factory object, the class factory object implemented by the contained server code and containing a creation method for creating an object of the class of objects identified by the class identifier;
| 1
|
将引用的动态链接库加载到代理过程;
|
loading the referenced dynamically linkable library into the surrogate process;
| 1
|
执行加载的动态链接库中包含的服务器代码:
|
executing the server code contained in the loaded dynamically linkable library:
| 1
|
在代理过程中创建类工厂对象的实例,对应于类标识符;
|
creating an instance of the class factory object within the surrogate process corresponding to the class identifier;
| 1
|
注册已创建的 class 工厂对象实例,以便其他进程可以使用 creation 方法创建由 class 标识符识别的对象类的对象实例,而不知道 class 工厂对象实例在不同的进程中实例化,每个创建的对象实例都由代孕过程加载的可链接库中的代码实现;
|
registering the created class factory object instance so that other processes can create object instances of the class of objects identified by the class identifier using the creation method without knowledge that the class factory object instance is instantiated in a different process, each created object instance being implemented by code in the linkable library loaded in the surrogate process;
| 1
|
响应请求,调用代理进程内注册的 class 工厂对象实例的创建方法,而请求代码不知道创建方法正在代理进程内执行,其中,接收调用服务器应用程序的请求的第一个进程在第一个程序的控制下,属于一个安全身份的第一个程序用于确定第一个程序的访问权,其中,接收创建对象实例的请求的请求的代码是第二个程序的一部分,属于一个安全身份的第二个程序用于确定第二个程序的访问权,其中,在代理进程中调用注册的 class 工厂对象实例的创建方法,只有在第一个和第二个程序属于同一个安全身份时才执行。
|
in response to the request, invoking the creation method of the registered class factory object instance within the surrogate process without the requesting code having knowledge that the creation method is being executed within the surrogate process, wherein the first process from which the request to invoke the server application is received is under the control of a first program, the first program belonging to a security identity for determining the access rights of the first program, wherein the requesting code from which the request to create an object instance is received is part of a second program, the second program belonging to a security identity for determining the access rights of the second program, and wherein invoking the creation method of the registered class factory object instance within the surrogate process is performed only when the first and second program belong to the same security identity.
| 1
|
权利要求20的方法,其中计算机系统连接到具有第二个服务控制管理器进程的远程计算机系统,其中调用代理进程的步骤进一步包括:
|
The method of claim 20 wherein the computer system is connected to a remote computer system having a second service control manager process, and wherein the step of invoking the surrogate process further comprises:
| 1
|
创建类标识符识别的对象类的对象的对象的实例;以及
|
creating an object instance of the class of objects identified by the class identifier; and
| 1
|
返回第一个进程的指标到被创建的对象实例的被请求接口,第一个进程使用的返回指标透明地调用被创建的对象实例在代理进程中实例化被请求的接口的方法。
|
returning to the first process an indicator to a requested interface of the created object instance, the returned indicator being used by the first process to transparently invoke methods of the requested interface of the created object instance instantiated in the surrogate process.
| 1
|
权利要求24的方法,其中计算机系统连接到远程计算机系统,其中代理进程在远程计算机系统上执行,并进一步包括:
|
The method of claim 24 wherein the computer system is connected to a remote computer system and wherein the surrogate process is executed on the remote computer system and, further comprising:
| 1
|
接收一个请求,以创建类标识符识别的对象类的第二个对象实例;以及
|
receiving a request to create a second object instance of the class of objects identified by the class identifier; and
| 1
|
响应接收到的请求,透明地调用代理进程中注册的类工厂对象实例的创建方法。
|
in response to the received request, transparently invoking the creation method of the registered class factory object instance within the surrogate process.
| 1
|
计算机系统中用于调用服务器代码的方法,该方法包括:
|
A method in a computer system for invoking server code, the method comprising:
| 1
|
接收来自客户端进程的请求以调用服务器代码;
|
receiving a request from a client process to invoke the server code;
| 1
|
响应接收到的请求,确定服务器代码是否已经在执行;
|
in response to the received request, determining whether the server code is already executing;
| 1
|
当确定服务器应用程序尚未执行时,确定服务器代码是否存在独立的可执行程序;
|
when it is determined that the server application is not already executing, determining whether a standalone executable program for the server code exists;
| 1
|
当确定不存在独立的可执行程序时,确定存储在可链接库中的服务器代码是否存在可执行代码,以及是否需要在客户端进程以外的进程中执行服务器代码;
|
when it is determined that no standalone executable program exists, determining whether there exists executable code for the server code that is stored in a linkable library and whether it is desired to execute the server code in a process other than the client process;
| 1
|
当确定服务器代码的可执行代码存在于可链接库中,并且希望在客户端进程以外的进程中执行服务器应用程序,调用代理进程,引用可链接库和类标识符列表,每个类标识符标识具有共同行为和对应于类工厂对象的对象的类对象,每个类工厂对象通过存储在可引用的可链接库中的代码实现,并且具有创建方法用于创建类标识符识别的对象类对象的对象,其中代理进程是一个独立可执行的过程,用于加载服务器代码,存储在动态可链接库中,并且可以实例化一个对象;以及
|
when it is determined that executable code for the server code exists in a linkable library and it is desired to execute the server application in the process other than the client process, invoking a surrogate process with a reference to the linkable library and a list of class identifiers, each class identifier identifying a class of objects with common behavior and corresponding to a class factory object, each class factory object implemented by code that is stored in the referenced linkable library and having a creation method for creating an object of the class of objects identified by the class identifier, wherein the surrogate process is an independently executable process for loading server code that is stored in a dynamically linkable library and that can instantiate an object; and
| 1
|
在调用的代理程序的控制下,
|
under control of the invoked surrogate process,
| 1
|
加载引用的可链接库;以及
|
loading the referenced linkable library; and
| 1
|
对类对象标识符列表中的每个类标识符,
|
for each class identifier in the list of class object identifiers,
| 1
|
在代理过程中创建相应的类工厂对象的实例;以及
|
creating an instance of the corresponding class factory object within the surrogate process; and
| 1
|
注册创建的类工厂对象实例,以便其他进程可以使用创建方法创建类标识符识别的对象类对象实例。
|
registering the created class factory object instance so that other processes can create object instances of the class of objects identified by the class identifier using the creation method.
| 1
|
计算机系统中用于调用多个服务器应用程序的方法,每个服务器应用程序由存储在可链接库中的可执行服务器代码实现,该方法包括:
|
A method in a computer system for invoking a plurality of server applications, each server application implemented by executable server code that is stored in a linkable library, the method comprising:
| 1
|
响应调用第一个服务器应用程序的请求,调用一个代理进程,引用可链接库,该库存储实现第一个服务器应用程序的服务器代码;以及
|
in response to a request to invoke a first server application, invoking a surrogate process with a reference to the linkable library that stores the server code that implements the first server application; and
| 1
|
在代理进程的控制下,加载可链接库,该库存储实现第一个服务器应用程序的服务器代码;
|
under control of the surrogate process, loading the referenced linkable library that stores the server code that implements the first server application;
| 1
|
响应调用第二个服务器应用程序的请求,确定存储实现第二个服务器应用程序的服务器代码的可链接库是否包含受信任的代码是代码;
|
in response to a request to invoke a second server application, determining whether the linkable library that stores the server code that implements the second server application contains trusted is code;
| 1
|
当确定存储实现第二个服务器应用程序的服务器代码的可链接库包含受信任代码,请求已经执行的代理进程加载包含实现第二个服务器应用程序的可信代码的可链接库时;以及
|
when it is determined that the linkable library that stores the server code that implements the second server application contains trusted code, requesting the already executing surrogate process to load the linkable library that contains trusted code that implements the second server application; and
| 1
|
加载包含可链接的库,该库包含将第二个服务器应用程序实现到已经执行的代理进程的可信代码。
|
loading the linkable library that contains the trusted code that implements the second server application into the already executing surrogate process.
| 1
|
当确定存储实现第二个服务器应用程序的服务器代码的可链接库不包含可信代码,调用第二个代理进程;以及
|
when it is determined that the linkable library that stores the server code that implements the second server application does not contain trusted code, invoking a second surrogate process; and
| 1
|
在第二个代理进程的控制下,加载可链接库,该库存储实现第二个服务器应用程序的服务器代码。
|
under control of the second surrogate process, loading the referenced linkable library that stores the server code that implements the second server application.
| 1
|
权利要求36的方法,其中调用第一个服务器应用程序的请求是在第一个程序的控制下执行的,属于安全身份的第一个程序用于确定第一个程序的访问权,其中调用第二个服务器应用程序的请求是在第二个程序的控制下执行的,第二个程序属于安全身份,用于确定第二个程序的访问权,其中确定存储实现第二个服务器应用程序的服务器代码的可链接库是否包含可信代码进一步包括:
|
The method of claim 36 wherein the request to invoke the first server application is performed under the control of a first program, the first program belonging to a security identity for determining the access rights of the first program, wherein the request to invoke the second server application is performed under the control of a second program, the second program belonging to a security identity for determining the access rights of the second program, and wherein the determining of whether the linkable library that stores the server code that implements the second server application contains trusted code further comprises:
| 1
|
确定第一个程序是否属于与第二个程序相同的安全身份;以及
|
determining whether the first program belongs to the same security identity as the second program; and
| 1
|
当确定第一个和第二个程序属于相同的安全标识时,得出的结果就是存储实现第二个服务器应用程序的服务器代码的可链接库包含可信代码。
|
when it is determined that the first and second programs belong to the same security identity, reaching a result that the linkable library that stores the server code that implements the second server application contains trusted code.
| 1
|
权利要求34的方法,其中调用第一个服务器应用程序的请求是在第一个程序的控制下执行的,属于安全身份的第一个程序用于确定第一个程序的访问权,其中调用第二个服务器应用程序的请求是在第二个程序的控制下执行的,第二个程序属于安全身份,用于确定第二个程序的访问权,其中确定存储实现第二个服务器应用程序的服务器代码的可链接库是否包含可信代码包括:
|
The method of claim 34 wherein the request to invoke the first server application is performed under the control of a first program, the first program belonging to a security identity for determining the access rights of the first program, wherein the request to invoke the second server application is performed under the control of a second program, the second program belonging to a security identity for determining the access rights of the second program, and wherein the determining of whether the linkable library that stores the server code that implements the second server application contains trusted code comprises:
| 1
|
确定第一个程序是否属于与第二个程序相同的安全身份;
|
determining whether the first program belongs to the same security identity as the second program;
| 1
|
权利要求40的方法,其中计算机系统连接到具有第二个服务控制管理器进程的远程计算机系统,其中调用代理进程的步骤进一步包括以下几个子步骤:
|
The method of claim 40 wherein the computer system is connected to a remote computer system having a second service control manager process, and wherein the step of invoking the surrogate process further comprises the substeps of:
| 1
|
将调用服务器应用程序的请求转发到第二个服务控制管理器进程;以及
|
forwarding the request to invoke the server application to the second service control manager process; and
| 1
|
权利要求 34 的方法,其中请求已经执行的代理进程加载包含实现第二个服务器应用程序的可信代码的可链接库,该库包括:
|
The method of claim 34 wherein requesting the already executing surrogate process to load the linkable library that contains the trusted code that implements the second server application further comprises:
| 1
|
向已经执行的代理进程提供类标识符列表,每个类标识符标识具有共同行为的对象类,对应于类工厂对象,每个类工厂对象通过位于可链接库中的代码实现,其中包含实现第二个服务器应用程序的可信代码,每个类工厂都包含创建方法,用于创建类标识符识别的对象类的对象;以及
|
providing a list of class identifiers to the already executing surrogate process, each class identifier identifying a class of objects with common behavior and corresponding to a class factory object, each class factory object implemented by code residing in the linkable library that contains the trusted code that implements the second server application, each class factory containing a creation method for creating an object of the class of objects identified by the class identifier; and
| 1
|
其中,加载包含可信任代码的可链接库,该代码将第二个服务器应用程序实现到代理进程中,进一步包括:
|
wherein the loading of the linkable library that contains the trusted code that implements the second server application into the surrogate process further comprises:
| 1
|
为提供类对象标识符列表中的每个类标识符,
|
for each class identifier in the provided list of class object identifiers,
| 1
|
接收请求代码的请求,以创建被请求的类标识符识别的对象类的对象实例;以及
|
receiving a request from requesting code to create an object instance of the class of objects identified by a requested class identifier; and
| 1
|
响应接收到的创建对象实例的请求,调用代理进程中注册的类工厂对象实例的创建方法,而请求代码不知道创建方法正在代理进程中执行。
|
in response to the received request to create the object instance, invoking the creation method of the registered class factory object instance within the surrogate process without the requesting code having knowledge that the creation method is being executed within the surrogate process.
| 1
|
计算机系统中用于解构marshaling对象的方法,包含类标识符的marshalled对象,标识具有共同行为和unmarshaling代码的对象,由服务器代码实现的unmarshaling代码,该方法包括:
|
A method in a computer system for unmarshaling a marshalled object, the marshalled object containing a class identifier identifying a class of objects with common behavior and unmarshaling code, the unmarshaling code being implemented by server code that corresponds to the class identifier, the method comprising:
| 1
|
确定是否需要自定义解marshaling来解marshaling对象,其中custom unmarshaling指的是实现特定于服务器代码的unmarshaling进程的unmarshaling代码;
|
determining whether custom unmarshaling is required to unmarshal the marshalled object, wherein custom unmarshaling refers to unmarshaling code that implements an unmarshaling process that is specific to the server code;
| 1
|
当确定需要自定义解marshaling时,确定marshallled对象的类标识符;
|
when it is determined that custom unmarshaling is required, determining the class identifier of the marshalled object;
| 1
|
确定是否存在一个可链接的库,其中包含与确定的类标识符相对应的可执行服务器代码;
|
determining whether there exists a linkable library that contains executable server code that corresponds to the determined class identifier;
| 1
|
当确定可链接库存在时,调用带有可链接库的引用的代理进程,其中代理进程是一个独立可执行进程,用于加载存储在动态可链接库中的服务器代码,并且可以实例化一个对象;以及
|
when it is determined that the linkable library exists, invoking a surrogate process with a reference to the linkable library, wherein the surrogate process is an independently executable process for loading server code that is stored in a dynamically linkable library and that can instantiate an object; and
| 1
|
在调用的代理进程的控制下,加载可链接库并在加载的可链接库中执行自定义的解marshaling代码,以特定于服务器代码的方式解marshal 对象。
|
under control of the invoked surrogate process, loading the linkable library and executing the custom unmarshaling code in the loaded linkable library to unmarshal the marshalled object in a server code-specific manner.
| 1
|
权利要求46的方法, marshallled对象的类标识符, 类工厂对象具有创建方法, 用于创建类标识符标识的对象的类对象的类对象, 并进一步包括:
|
The method of claim 46, the class identifier of the marshalled object identifying a class factory object, the class factory object having a creation method for creating an object of the class of objects identified by the class identifier and further comprising:
| 1
|
在代理程序的控制下,
|
under control of the surrogate process,
| 1
|
创建一个类工厂对象的实例;
|
creating an instance of the class factory object;
| 1
|
使用创建的类工厂对象的创建方法,创建由确定的类标识符识别的对象类的对象实例;
|
using the creation method of the created class factory object to create an object instance of the class of objects identified by the determined class identifier;
| 1
|
将数据从marshallled对象复制到创建的对象实例;和
|
copying data from the marshalled object into the created object instance; and
| 1
|
返回一个指标到被创建的对象实例请求的接口。
|
returning an indicator to a requested interface of the created object instance.
| 1
|
计算机系统中的一种方法,用于调用服务器应用程序,其服务器代码根据第一个架构模型实现,从客户端代码实现根据第二个架构模型实现,客户端代码在客户端进程中执行,该方法包括计算机实现的步骤:
|
A method in a computer system for invoking a server application having server code implemented according to a first architectural model from client code implemented according to a second architectural model, the client code executing in a client process, the method comprising the computer-implemented steps of:
| 1
|
接收来自客户端的请求,以调用服务器应用程序;
|
receiving from the client process a request to invoke the server application;
| 1
|
响应接收到的请求,确定服务器代码的第一个架构模型是否与客户端代码的第二个架构模型兼容,这样服务器代码就可以在客户端进程中执行;
|
in response to the received request, determining whether the first architectural model of the server code is compatible with the second architectural model of the client code, such that the server code can be executed in the client process;
| 1
|
当确定服务器代码的第一个架构模型不兼容,不能在客户端进程中执行,调用代理进程,引用动态可链接库,其中包含根据第一个架构模型实现的服务器代码,代理进程提供计算机系统的仿真,该计算机系统具有实现第一个架构模型的指令集;
|
when it is determined that the first architectural model of the server code is not compatible and cannot be executed in the client process, invoking a surrogate process with a reference to a dynamically linkable library that contains the server code implemented according to the first architectural model, the surrogate process providing an emulation of a computer system having an instruction set that implements the first architectural model;
| 1
|
在代理过程中,执行根据第一个架构模型实现的服务器代码;以及
|
within the surrogate process, executing the server code implemented according to the first architectural model; and
| 1
|
返回客户端进程对执行服务器代码的引用,客户端进程使用返回的引用透明地访问服务器应用程序,就好像服务器代码在客户端进程中执行一样。
|
returning to the client process a reference to the executing server code, the client process using the returned reference to transparently access the server application as if the server code were executing in the client process.
| 1
|
用于调用存储在动态链接库中的服务器代码的计算机系统,计算机系统包括:
|
A computer system for invoking server code that is stored in a dynamically linkable library, the computer system comprising:
| 1
|
代理进程,是一个独立可执行进程,用于加载存储在动态链接库中的服务器代码,并且可以实例化一个对象,并且,响应被调用,
|
a surrogate process that is an independently executable process for loading server code that is stored in a dynamically linkable library and that can instantiate an object, and that, in response to being invoked,
| 1
|
加载存储服务器代码的动态可链接库;
|
loads the dynamically linkable library that stores the server code;
| 1
|
执行服务器代码;以及
|
executes the server code; and
| 1
|
返回一个对执行服务器代码的绑定句柄的引用,该句柄可以被第二个进程透明地用于进一步调用服务器代码,而不知道服务器代码正在代理进程中执行;以及
|
returns a reference to a binding handle for the executing server code that can be transparently used by a second process to further invoke the server code without knowledge that the server code is being executed in the surrogate process; and
| 1
|
调用机制,响应调用服务器代码的请求,调用代理进程,引用动态链接库。
|
an invocation mechanism that, in response to a request to invoke the server code, invokes the surrogate process with a reference to the dynamically linkable library.
| 1
|
用于调用存储在动态链接库中的服务器代码的计算机系统,计算机系统包括:
|
A computer system for invoking server code that is stored in a dynamically linkable library, the computer system comprising:
| 1
|
类出厂对象由类标识符识别,并由存储在可链接库中的服务器代码实现,类标识符识别具有共同行为的对象类,并包含创建类对象的方法;
|
a class factory object identified by class identifier and implemented by server code stored in the linkable library, the class identifier identifying a class of objects with common behavior and containing a creation method for creating an object of the class;
| 1
|
代理进程,是一个独立可执行进程,用于加载存储在动态链接库中的服务器代码,并且可以实例化一个对象,并且响应被调用,
|
a surrogate process that is an independently executable process for loading server code that is stored in a dynamically linkable library and that can instantiate an object, and that in response to being invoked,
| 1
|
加载存储服务器代码的可链接库;
|
loads the linkable library that stores the server code;
| 1
|
在代理过程中创建一个类工厂对象的实例;
|
creates an instance of the class factory object within the surrogate process;
| 1
|
为已创建的类工厂对象实例注册一个绑定句柄,这样其他进程就可以创建类的对象实例,而不知道类工厂对象和创建方法正在代理进程中执行;以及
|
registers a binding handle for the created class factory object instance so that other processes can create object instances of the class without knowledge that the class factory object and creation method is executing in the surrogate process; and
| 1
|
调用机制,响应调用服务器代码的请求,调用代理进程,引用可链接库和类标识符。
|
an invocation mechanism that, in response to a request to invoke the server code, invokes the surrogate process with a reference to the linkable library and the class identifier.
| 1
|
一种用于调用多个服务器应用程序的计算机系统,每个服务器应用程序由可链接库中的可执行代码实现,计算机系统包括:
|
A computer system for invoking a plurality of server applications, each server application implemented by executable code contained in a linkable library, the computer system comprising:
| 1
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.