AppDomain.ExecuteAssembly Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Ejecuta el ensamblado que contiene el archivo especificado.
Sobrecargas
ExecuteAssembly(String, Evidence, String[], Byte[], AssemblyHashAlgorithm) |
Obsoletos.
Ejecuta el ensamblado contenido en el archivo especificado, usando la evidencia, los argumentos, el valor hash y el algoritmo hash especificados. |
ExecuteAssembly(String, Evidence, String[]) |
Obsoletos.
Ejecuta el ensamblado que contiene el archivo especificado, usando la evidencia y los argumentos especificados. |
ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm) |
Obsoletos.
Ejecuta el ensamblado contenido en el archivo especificado, usando los argumentos, el valor hash y el algoritmo hash especificados. |
ExecuteAssembly(String, Evidence) |
Obsoletos.
Ejecuta el ensamblado que contiene el archivo especificado, usando la evidencia especificada. |
ExecuteAssembly(String, String[]) |
Ejecuta el ensamblado contenido en el archivo especificado, usando los argumentos especificados. |
ExecuteAssembly(String) |
Ejecuta el ensamblado que contiene el archivo especificado. |
ExecuteAssembly(String, Evidence, String[], Byte[], AssemblyHashAlgorithm)
Precaución
Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.
Ejecuta el ensamblado contenido en el archivo especificado, usando la evidencia, los argumentos, el valor hash y el algoritmo hash especificados.
public:
int ExecuteAssembly(System::String ^ assemblyFile, System::Security::Policy::Evidence ^ assemblySecurity, cli::array <System::String ^> ^ args, cli::array <System::Byte> ^ hashValue, System::Configuration::Assemblies::AssemblyHashAlgorithm hashAlgorithm);
public int ExecuteAssembly (string assemblyFile, System.Security.Policy.Evidence assemblySecurity, string[] args, byte[] hashValue, System.Configuration.Assemblies.AssemblyHashAlgorithm hashAlgorithm);
[System.Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public int ExecuteAssembly (string assemblyFile, System.Security.Policy.Evidence assemblySecurity, string[] args, byte[] hashValue, System.Configuration.Assemblies.AssemblyHashAlgorithm hashAlgorithm);
member this.ExecuteAssembly : string * System.Security.Policy.Evidence * string[] * byte[] * System.Configuration.Assemblies.AssemblyHashAlgorithm -> int
[<System.Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
member this.ExecuteAssembly : string * System.Security.Policy.Evidence * string[] * byte[] * System.Configuration.Assemblies.AssemblyHashAlgorithm -> int
Public Function ExecuteAssembly (assemblyFile As String, assemblySecurity As Evidence, args As String(), hashValue As Byte(), hashAlgorithm As AssemblyHashAlgorithm) As Integer
Parámetros
- assemblyFile
- String
Nombre del archivo que contiene el ensamblado que se va a ejecutar.
- assemblySecurity
- Evidence
Evidencia suministrada para el ensamblado.
- args
- String[]
Argumentos del punto de entrada del ensamblado.
- hashValue
- Byte[]
Representa el valor del código hash calculado.
- hashAlgorithm
- AssemblyHashAlgorithm
Representa el algoritmo hash que usa el manifiesto del ensamblado.
Devoluciones
Valor devuelto por el punto de entrada del ensamblado.
- Atributos
Excepciones
assemblyFile
es null
.
No se ha encontrado assemblyFile
.
assemblyFile
no es un ensamblado válido para el tiempo de ejecución cargado actualmente.
La operación se intenta en un dominio de aplicación descargado.
Se cargó un ensamblado o módulo dos veces con dos evidencias diferentes.
assemblySecurity
no es null
. Cuando no se habilita la directiva CAS heredada, assemblySecurity
debe ser null
.
El ensamblado especificado no tiene ningún punto de entrada.
Ejemplos
En el ejemplo siguiente se muestra el uso de una de las sobrecargas de ExecuteAssembly en dos dominios diferentes.
int main()
{
AppDomain^ currentDomain = AppDomain::CurrentDomain;
AppDomain^ otherDomain = AppDomain::CreateDomain( "otherDomain" );
currentDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on [default]"
otherDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on otherDomain"
}
class ExecuteAssemblySnippet {
public static void Main() {
AppDomain currentDomain = AppDomain.CurrentDomain;
AppDomain otherDomain = AppDomain.CreateDomain("otherDomain");
currentDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on otherDomain"
}
}
open System
let currentDomain = AppDomain.CurrentDomain
let otherDomain = AppDomain.CreateDomain "otherDomain"
currentDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on otherDomain"
Module Test
Sub Main()
Dim currentDomain As AppDomain = AppDomain.CurrentDomain
Dim otherDomain As AppDomain = AppDomain.CreateDomain("otherDomain")
currentDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on otherDomain"
End Sub
End Module 'Test
Comentarios
El ensamblado comienza a ejecutarse en el punto de entrada especificado en el encabezado de .NET Framework.
Este método no crea un nuevo proceso o dominio de aplicación y no ejecuta el método de punto de entrada en un nuevo subproceso.
Este método carga ensamblados mediante el LoadFile método . También puede ejecutar ensamblados mediante el ExecuteAssemblyByName método , que carga ensamblados mediante el Load método .
Se aplica a
ExecuteAssembly(String, Evidence, String[])
Precaución
Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.
Ejecuta el ensamblado que contiene el archivo especificado, usando la evidencia y los argumentos especificados.
public:
virtual int ExecuteAssembly(System::String ^ assemblyFile, System::Security::Policy::Evidence ^ assemblySecurity, cli::array <System::String ^> ^ args);
public int ExecuteAssembly (string assemblyFile, System.Security.Policy.Evidence assemblySecurity, string[] args);
[System.Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public int ExecuteAssembly (string assemblyFile, System.Security.Policy.Evidence assemblySecurity, string[] args);
abstract member ExecuteAssembly : string * System.Security.Policy.Evidence * string[] -> int
override this.ExecuteAssembly : string * System.Security.Policy.Evidence * string[] -> int
[<System.Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
abstract member ExecuteAssembly : string * System.Security.Policy.Evidence * string[] -> int
override this.ExecuteAssembly : string * System.Security.Policy.Evidence * string[] -> int
Public Function ExecuteAssembly (assemblyFile As String, assemblySecurity As Evidence, args As String()) As Integer
Parámetros
- assemblyFile
- String
Nombre del archivo que contiene el ensamblado que se va a ejecutar.
- assemblySecurity
- Evidence
Evidencia suministrada para el ensamblado.
- args
- String[]
Argumentos del punto de entrada del ensamblado.
Devoluciones
Valor devuelto por el punto de entrada del ensamblado.
Implementaciones
- Atributos
Excepciones
assemblyFile
es null
.
No se ha encontrado assemblyFile
.
assemblyFile
no es un ensamblado válido para el tiempo de ejecución cargado actualmente.
La operación se intenta en un dominio de aplicación descargado.
Se cargó un ensamblado o módulo dos veces con dos evidencias diferentes.
assemblySecurity
no es null
. Cuando no se habilita la directiva CAS heredada, assemblySecurity
debe ser null
.
El ensamblado especificado no tiene ningún punto de entrada.
Ejemplos
En el ejemplo siguiente se muestra el uso de una de las sobrecargas de ExecuteAssembly en dos dominios diferentes.
int main()
{
AppDomain^ currentDomain = AppDomain::CurrentDomain;
AppDomain^ otherDomain = AppDomain::CreateDomain( "otherDomain" );
currentDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on [default]"
otherDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on otherDomain"
}
class ExecuteAssemblySnippet {
public static void Main() {
AppDomain currentDomain = AppDomain.CurrentDomain;
AppDomain otherDomain = AppDomain.CreateDomain("otherDomain");
currentDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on otherDomain"
}
}
open System
let currentDomain = AppDomain.CurrentDomain
let otherDomain = AppDomain.CreateDomain "otherDomain"
currentDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on otherDomain"
Module Test
Sub Main()
Dim currentDomain As AppDomain = AppDomain.CurrentDomain
Dim otherDomain As AppDomain = AppDomain.CreateDomain("otherDomain")
currentDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on otherDomain"
End Sub
End Module 'Test
Comentarios
El ensamblado comienza a ejecutarse en el punto de entrada especificado en el encabezado de .NET Framework.
Este método no crea un nuevo proceso o dominio de aplicación y no ejecuta el método de punto de entrada en un nuevo subproceso.
Este método carga ensamblados mediante el LoadFile método . También puede ejecutar ensamblados mediante el ExecuteAssemblyByName método , que carga ensamblados mediante el Load método .
Se aplica a
ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm)
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
Precaución
Code Access Security is not supported or honored by the runtime.
Ejecuta el ensamblado contenido en el archivo especificado, usando los argumentos, el valor hash y el algoritmo hash especificados.
public:
int ExecuteAssembly(System::String ^ assemblyFile, cli::array <System::String ^> ^ args, cli::array <System::Byte> ^ hashValue, System::Configuration::Assemblies::AssemblyHashAlgorithm hashAlgorithm);
public int ExecuteAssembly (string assemblyFile, string?[]? args, byte[]? hashValue, System.Configuration.Assemblies.AssemblyHashAlgorithm hashAlgorithm);
[System.Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId="SYSLIB0003", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public int ExecuteAssembly (string assemblyFile, string?[]? args, byte[]? hashValue, System.Configuration.Assemblies.AssemblyHashAlgorithm hashAlgorithm);
public int ExecuteAssembly (string assemblyFile, string[] args, byte[] hashValue, System.Configuration.Assemblies.AssemblyHashAlgorithm hashAlgorithm);
member this.ExecuteAssembly : string * string[] * byte[] * System.Configuration.Assemblies.AssemblyHashAlgorithm -> int
[<System.Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId="SYSLIB0003", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
member this.ExecuteAssembly : string * string[] * byte[] * System.Configuration.Assemblies.AssemblyHashAlgorithm -> int
Public Function ExecuteAssembly (assemblyFile As String, args As String(), hashValue As Byte(), hashAlgorithm As AssemblyHashAlgorithm) As Integer
Parámetros
- assemblyFile
- String
Nombre del archivo que contiene el ensamblado que se va a ejecutar.
- args
- String[]
Argumentos del punto de entrada del ensamblado.
- hashValue
- Byte[]
Representa el valor del código hash calculado.
- hashAlgorithm
- AssemblyHashAlgorithm
Representa el algoritmo hash que usa el manifiesto del ensamblado.
Devoluciones
Valor devuelto por el punto de entrada del ensamblado.
- Atributos
Excepciones
assemblyFile
es null
.
No se ha encontrado assemblyFile
.
assemblyFile
no es un ensamblado válido para el tiempo de ejecución cargado actualmente.
La operación se intenta en un dominio de aplicación descargado.
Se cargó un ensamblado o módulo dos veces con dos evidencias diferentes.
El ensamblado especificado no tiene ningún punto de entrada.
Ejemplos
En el ejemplo siguiente se muestra el uso de una de las sobrecargas de ExecuteAssembly en dos dominios diferentes.
int main()
{
AppDomain^ currentDomain = AppDomain::CurrentDomain;
AppDomain^ otherDomain = AppDomain::CreateDomain( "otherDomain" );
currentDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on [default]"
otherDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on otherDomain"
}
class ExecuteAssemblySnippet {
public static void Main() {
AppDomain currentDomain = AppDomain.CurrentDomain;
AppDomain otherDomain = AppDomain.CreateDomain("otherDomain");
currentDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on otherDomain"
}
}
open System
let currentDomain = AppDomain.CurrentDomain
let otherDomain = AppDomain.CreateDomain "otherDomain"
currentDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on otherDomain"
Module Test
Sub Main()
Dim currentDomain As AppDomain = AppDomain.CurrentDomain
Dim otherDomain As AppDomain = AppDomain.CreateDomain("otherDomain")
currentDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on otherDomain"
End Sub
End Module 'Test
Comentarios
Precaución
La seguridad de acceso del código (CAS) ha quedado en desuso en todas las versiones de .NET Framework y .NET. Las versiones recientes de .NET no respetan las anotaciones de CAS y generan errores si se usan API relacionadas con CAS. Los desarrolladores deben buscar medios alternativos para realizar tareas de seguridad.
El ensamblado comienza a ejecutarse en el punto de entrada especificado en el encabezado de .NET Framework.
Este método no crea un nuevo proceso o dominio de aplicación y no ejecuta el método de punto de entrada en un nuevo subproceso.
Este método carga ensamblados mediante el LoadFile método . También puede ejecutar ensamblados mediante el ExecuteAssemblyByName método , que carga ensamblados mediante el Load método .
Se aplica a
ExecuteAssembly(String, Evidence)
Precaución
Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.
Ejecuta el ensamblado que contiene el archivo especificado, usando la evidencia especificada.
public:
virtual int ExecuteAssembly(System::String ^ assemblyFile, System::Security::Policy::Evidence ^ assemblySecurity);
public int ExecuteAssembly (string assemblyFile, System.Security.Policy.Evidence assemblySecurity);
[System.Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public int ExecuteAssembly (string assemblyFile, System.Security.Policy.Evidence assemblySecurity);
abstract member ExecuteAssembly : string * System.Security.Policy.Evidence -> int
override this.ExecuteAssembly : string * System.Security.Policy.Evidence -> int
[<System.Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
abstract member ExecuteAssembly : string * System.Security.Policy.Evidence -> int
override this.ExecuteAssembly : string * System.Security.Policy.Evidence -> int
Public Function ExecuteAssembly (assemblyFile As String, assemblySecurity As Evidence) As Integer
Parámetros
- assemblyFile
- String
Nombre del archivo que contiene el ensamblado que se va a ejecutar.
- assemblySecurity
- Evidence
Evidencia para cargar el ensamblado.
Devoluciones
Valor devuelto por el punto de entrada del ensamblado.
Implementaciones
- Atributos
Excepciones
assemblyFile
es null
.
No se ha encontrado assemblyFile
.
assemblyFile
no es un ensamblado válido para el tiempo de ejecución cargado actualmente.
La operación se intenta en un dominio de aplicación descargado.
Se cargó un ensamblado o módulo dos veces con dos evidencias diferentes.
El ensamblado especificado no tiene ningún punto de entrada.
Ejemplos
En el ejemplo siguiente se muestra el uso de una de las sobrecargas de ExecuteAssembly en dos dominios diferentes.
int main()
{
AppDomain^ currentDomain = AppDomain::CurrentDomain;
AppDomain^ otherDomain = AppDomain::CreateDomain( "otherDomain" );
currentDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on [default]"
otherDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on otherDomain"
}
class ExecuteAssemblySnippet {
public static void Main() {
AppDomain currentDomain = AppDomain.CurrentDomain;
AppDomain otherDomain = AppDomain.CreateDomain("otherDomain");
currentDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on otherDomain"
}
}
open System
let currentDomain = AppDomain.CurrentDomain
let otherDomain = AppDomain.CreateDomain "otherDomain"
currentDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on otherDomain"
Module Test
Sub Main()
Dim currentDomain As AppDomain = AppDomain.CurrentDomain
Dim otherDomain As AppDomain = AppDomain.CreateDomain("otherDomain")
currentDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on otherDomain"
End Sub
End Module 'Test
Comentarios
El ensamblado comienza a ejecutarse en el punto de entrada especificado en el encabezado de .NET Framework.
El ExecuteAssembly método no crea un nuevo proceso o dominio de aplicación y no ejecuta el método de punto de entrada en un nuevo subproceso.
Este método carga ensamblados mediante el LoadFile método . También puede ejecutar ensamblados mediante el ExecuteAssemblyByName método , que carga ensamblados mediante el Load método .
Se aplica a
ExecuteAssembly(String, String[])
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
Ejecuta el ensamblado contenido en el archivo especificado, usando los argumentos especificados.
public:
int ExecuteAssembly(System::String ^ assemblyFile, cli::array <System::String ^> ^ args);
public int ExecuteAssembly (string assemblyFile, string?[]? args);
public int ExecuteAssembly (string assemblyFile, string[] args);
member this.ExecuteAssembly : string * string[] -> int
Public Function ExecuteAssembly (assemblyFile As String, args As String()) As Integer
Parámetros
- assemblyFile
- String
Nombre del archivo que contiene el ensamblado que se va a ejecutar.
- args
- String[]
Argumentos del punto de entrada del ensamblado.
Devoluciones
Valor devuelto por el punto de entrada del ensamblado.
Excepciones
assemblyFile
es null
.
No se ha encontrado assemblyFile
.
assemblyFile
no es un ensamblado válido para el tiempo de ejecución cargado actualmente.
La operación se intenta en un dominio de aplicación descargado.
Se cargó un ensamblado o módulo dos veces con dos evidencias diferentes.
El ensamblado especificado no tiene ningún punto de entrada.
Ejemplos
En el ejemplo siguiente se muestra el uso de una de las sobrecargas de ExecuteAssembly en dos dominios diferentes.
int main()
{
AppDomain^ currentDomain = AppDomain::CurrentDomain;
AppDomain^ otherDomain = AppDomain::CreateDomain( "otherDomain" );
currentDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on [default]"
otherDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on otherDomain"
}
class ExecuteAssemblySnippet {
public static void Main() {
AppDomain currentDomain = AppDomain.CurrentDomain;
AppDomain otherDomain = AppDomain.CreateDomain("otherDomain");
currentDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on otherDomain"
}
}
open System
let currentDomain = AppDomain.CurrentDomain
let otherDomain = AppDomain.CreateDomain "otherDomain"
currentDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on otherDomain"
Module Test
Sub Main()
Dim currentDomain As AppDomain = AppDomain.CurrentDomain
Dim otherDomain As AppDomain = AppDomain.CreateDomain("otherDomain")
currentDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on otherDomain"
End Sub
End Module 'Test
Comentarios
El ensamblado comienza a ejecutarse en el punto de entrada especificado en el encabezado de .NET Framework.
Este método no crea un nuevo proceso o dominio de aplicación y no ejecuta el método de punto de entrada en un nuevo subproceso.
Este método carga ensamblados mediante el LoadFile método . También puede ejecutar ensamblados mediante el ExecuteAssemblyByName método , que carga ensamblados mediante el Load método .
Se aplica a
ExecuteAssembly(String)
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
Ejecuta el ensamblado que contiene el archivo especificado.
public:
int ExecuteAssembly(System::String ^ assemblyFile);
public:
virtual int ExecuteAssembly(System::String ^ assemblyFile);
public int ExecuteAssembly (string assemblyFile);
member this.ExecuteAssembly : string -> int
abstract member ExecuteAssembly : string -> int
override this.ExecuteAssembly : string -> int
Public Function ExecuteAssembly (assemblyFile As String) As Integer
Parámetros
- assemblyFile
- String
Nombre del archivo que contiene el ensamblado que se va a ejecutar.
Devoluciones
Valor devuelto por el punto de entrada del ensamblado.
Implementaciones
Excepciones
assemblyFile
es null
.
No se ha encontrado assemblyFile
.
assemblyFile
no es un ensamblado válido para el tiempo de ejecución cargado actualmente.
La operación se intenta en un dominio de aplicación descargado.
Se cargó un ensamblado o módulo dos veces con dos evidencias diferentes.
El ensamblado especificado no tiene ningún punto de entrada.
Ejemplos
En el ejemplo siguiente se muestra el uso de una de las sobrecargas de ExecuteAssembly en dos dominios diferentes.
int main()
{
AppDomain^ currentDomain = AppDomain::CurrentDomain;
AppDomain^ otherDomain = AppDomain::CreateDomain( "otherDomain" );
currentDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on [default]"
otherDomain->ExecuteAssembly( "MyExecutable.exe" );
// Prints S"MyExecutable running on otherDomain"
}
class ExecuteAssemblySnippet {
public static void Main() {
AppDomain currentDomain = AppDomain.CurrentDomain;
AppDomain otherDomain = AppDomain.CreateDomain("otherDomain");
currentDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe");
// Prints "MyExecutable running on otherDomain"
}
}
open System
let currentDomain = AppDomain.CurrentDomain
let otherDomain = AppDomain.CreateDomain "otherDomain"
currentDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly "MyExecutable.exe"
// Prints "MyExecutable running on otherDomain"
Module Test
Sub Main()
Dim currentDomain As AppDomain = AppDomain.CurrentDomain
Dim otherDomain As AppDomain = AppDomain.CreateDomain("otherDomain")
currentDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on [default]"
otherDomain.ExecuteAssembly("MyExecutable.exe")
' Prints "MyExecutable running on otherDomain"
End Sub
End Module 'Test
Comentarios
El ensamblado comienza a ejecutarse en el punto de entrada especificado en el encabezado de .NET Framework.
Este método no crea un nuevo proceso o dominio de aplicación y no ejecuta el método de punto de entrada en un nuevo subproceso.
Este método carga ensamblados mediante el LoadFile método . También puede ejecutar ensamblados mediante el ExecuteAssemblyByName método , que carga ensamblados mediante el Load método .
Para crear el objeto AppDomain que se va a cargar y ejecutar, use el CreateDomain método .