AppDomain.ExecuteAssembly Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Exécute l'assembly contenu dans le fichier spécifié.
Surcharges
ExecuteAssembly(String, Evidence, String[], Byte[], AssemblyHashAlgorithm) |
Obsolète.
Exécute l’assembly contenu dans le fichier spécifié à l’aide de la preuve, des arguments, de la valeur et de l’algorithme de hachage spécifiés. |
ExecuteAssembly(String, Evidence, String[]) |
Obsolète.
Exécute l’assembly contenu dans le fichier spécifié à l’aide de la preuve et des arguments spécifiés. |
ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm) |
Obsolète.
Exécute l’assembly contenu dans le fichier spécifié à l’aide des arguments, de la valeur et de l’algorithme de hachage spécifiés. |
ExecuteAssembly(String, Evidence) |
Obsolète.
Exécute l'assembly contenu dans le fichier spécifié à l'aide de la preuve spécifiée. |
ExecuteAssembly(String, String[]) |
Exécute l’assembly contenu dans le fichier spécifié à l’aide des arguments spécifiés. |
ExecuteAssembly(String) |
Exécute l'assembly contenu dans le fichier spécifié. |
ExecuteAssembly(String, Evidence, String[], Byte[], AssemblyHashAlgorithm)
Attention
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.
Exécute l’assembly contenu dans le fichier spécifié à l’aide de la preuve, des arguments, de la valeur et de l’algorithme de hachage spécifiés.
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
Paramètres
- assemblyFile
- String
Nom du fichier contenant l'assembly à exécuter.
- assemblySecurity
- Evidence
Preuve fournie pour l'assembly.
- args
- String[]
Arguments pour le point d'entrée de l'assembly.
- hashValue
- Byte[]
Représente la valeur du code de hachage calculé.
- hashAlgorithm
- AssemblyHashAlgorithm
Représente l'algorithme de hachage utilisé par le manifeste d'assembly.
Retours
Valeur retournée par le point d'entrée de l'assembly.
- Attributs
Exceptions
assemblyFile
a la valeur null
.
assemblyFile
est introuvable.
assemblyFile
n’est pas un assembly valide pour le runtime actuellement chargé.
L’opération est tentée sur un domaine d’application non chargé.
Un assembly ou un module a été chargé à deux reprises avec deux preuves différentes.
assemblySecurity
n’est pas un null
. Quand la stratégie CAS héritée n’est pas activée, assemblySecurity
doit être null
.
L’assembly spécifié n’a aucun point d’entrée.
Exemples
L’exemple suivant illustre l’utilisation de l’une des surcharges de ExecuteAssembly sur deux domaines différents.
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
Remarques
L’assembly commence à s’exécuter au point d’entrée spécifié dans l’en-tête .NET Framework.
Cette méthode ne crée pas de processus ou de domaine d’application et n’exécute pas la méthode de point d’entrée sur un nouveau thread.
Cette méthode charge des assemblys à l’aide de la LoadFile méthode . Vous pouvez également exécuter des assemblys à l’aide de la ExecuteAssemblyByName méthode , qui charge les assemblys à l’aide de la Load méthode .
S’applique à
ExecuteAssembly(String, Evidence, String[])
Attention
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.
Exécute l’assembly contenu dans le fichier spécifié à l’aide de la preuve et des arguments spécifiés.
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
Paramètres
- assemblyFile
- String
Nom du fichier contenant l'assembly à exécuter.
- assemblySecurity
- Evidence
Preuve fournie pour l'assembly.
- args
- String[]
Arguments pour le point d'entrée de l'assembly.
Retours
Valeur retournée par le point d'entrée de l'assembly.
Implémente
- Attributs
Exceptions
assemblyFile
a la valeur null
.
assemblyFile
est introuvable.
assemblyFile
n’est pas un assembly valide pour le runtime actuellement chargé.
L’opération est tentée sur un domaine d’application non chargé.
Un assembly ou un module a été chargé à deux reprises avec deux preuves différentes.
assemblySecurity
n’est pas un null
. Quand la stratégie CAS héritée n’est pas activée, assemblySecurity
doit être null
.
L’assembly spécifié n’a aucun point d’entrée.
Exemples
L’exemple suivant illustre l’utilisation de l’une des surcharges de ExecuteAssembly sur deux domaines différents.
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
Remarques
L’assembly commence à s’exécuter au point d’entrée spécifié dans l’en-tête .NET Framework.
Cette méthode ne crée pas de processus ou de domaine d’application et n’exécute pas la méthode de point d’entrée sur un nouveau thread.
Cette méthode charge des assemblys à l’aide de la LoadFile méthode . Vous pouvez également exécuter des assemblys à l’aide de la ExecuteAssemblyByName méthode , qui charge les assemblys à l’aide de la Load méthode .
S’applique à
ExecuteAssembly(String, String[], Byte[], AssemblyHashAlgorithm)
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
Attention
Code Access Security is not supported or honored by the runtime.
Exécute l’assembly contenu dans le fichier spécifié à l’aide des arguments, de la valeur et de l’algorithme de hachage spécifiés.
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
Paramètres
- assemblyFile
- String
Nom du fichier contenant l'assembly à exécuter.
- args
- String[]
Arguments pour le point d'entrée de l'assembly.
- hashValue
- Byte[]
Représente la valeur du code de hachage calculé.
- hashAlgorithm
- AssemblyHashAlgorithm
Représente l'algorithme de hachage utilisé par le manifeste d'assembly.
Retours
Valeur qui est retournée par le point d'entrée de l'assembly.
- Attributs
Exceptions
assemblyFile
a la valeur null
.
assemblyFile
est introuvable.
assemblyFile
n’est pas un assembly valide pour le runtime actuellement chargé.
L’opération est tentée sur un domaine d’application non chargé.
Un assembly ou un module a été chargé à deux reprises avec deux preuves différentes.
L’assembly spécifié n’a aucun point d’entrée.
Exemples
L’exemple suivant illustre l’utilisation de l’une des surcharges de ExecuteAssembly sur deux domaines différents.
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
Remarques
Attention
La sécurité d’accès du code (CAS) a été déconseillée dans toutes les versions du .NET Framework et de .NET. Les versions récentes de .NET ne respectent pas les annotations CAS et produisent des erreurs si les API liées à CAS sont utilisées. Les développeurs doivent chercher d’autres moyens pour accomplir les tâches liées à la sécurité.
L’assembly commence à s’exécuter au point d’entrée spécifié dans l’en-tête .NET Framework.
Cette méthode ne crée pas de processus ou de domaine d’application et n’exécute pas la méthode de point d’entrée sur un nouveau thread.
Cette méthode charge des assemblys à l’aide de la LoadFile méthode . Vous pouvez également exécuter des assemblys à l’aide de la ExecuteAssemblyByName méthode , qui charge les assemblys à l’aide de la Load méthode .
S’applique à
ExecuteAssembly(String, Evidence)
Attention
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.
Exécute l'assembly contenu dans le fichier spécifié à l'aide de la preuve spécifiée.
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
Paramètres
- assemblyFile
- String
Nom du fichier contenant l'assembly à exécuter.
- assemblySecurity
- Evidence
Preuve de chargement de l'assembly.
Retours
Valeur retournée par le point d'entrée de l'assembly.
Implémente
- Attributs
Exceptions
assemblyFile
a la valeur null
.
assemblyFile
est introuvable.
assemblyFile
n’est pas un assembly valide pour le runtime actuellement chargé.
L’opération est tentée sur un domaine d’application non chargé.
Un assembly ou un module a été chargé à deux reprises avec deux preuves différentes.
L’assembly spécifié n’a aucun point d’entrée.
Exemples
L’exemple suivant illustre l’utilisation de l’une des surcharges de ExecuteAssembly sur deux domaines différents.
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
Remarques
L’assembly commence à s’exécuter au point d’entrée spécifié dans l’en-tête .NET Framework.
La ExecuteAssembly méthode ne crée pas de processus ou de domaine d’application et n’exécute pas la méthode de point d’entrée sur un nouveau thread.
Cette méthode charge des assemblys à l’aide de la LoadFile méthode . Vous pouvez également exécuter des assemblys à l’aide de la ExecuteAssemblyByName méthode , qui charge les assemblys à l’aide de la Load méthode .
S’applique à
ExecuteAssembly(String, String[])
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
Exécute l’assembly contenu dans le fichier spécifié à l’aide des arguments spécifiés.
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
Paramètres
- assemblyFile
- String
Nom du fichier contenant l'assembly à exécuter.
- args
- String[]
Arguments pour le point d'entrée de l'assembly.
Retours
Valeur qui est retournée par le point d'entrée de l'assembly.
Exceptions
assemblyFile
a la valeur null
.
assemblyFile
est introuvable.
assemblyFile
n’est pas un assembly valide pour le runtime actuellement chargé.
L’opération est tentée sur un domaine d’application non chargé.
Un assembly ou un module a été chargé à deux reprises avec deux preuves différentes.
L’assembly spécifié n’a aucun point d’entrée.
Exemples
L’exemple suivant illustre l’utilisation de l’une des surcharges de ExecuteAssembly sur deux domaines différents.
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
Remarques
L’assembly commence à s’exécuter au point d’entrée spécifié dans l’en-tête .NET Framework.
Cette méthode ne crée pas de processus ou de domaine d’application et n’exécute pas la méthode de point d’entrée sur un nouveau thread.
Cette méthode charge des assemblys à l’aide de la LoadFile méthode . Vous pouvez également exécuter des assemblys à l’aide de la ExecuteAssemblyByName méthode, qui charge les assemblys à l’aide de la Load méthode .
S’applique à
ExecuteAssembly(String)
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
- Source:
- AppDomain.cs
Exécute l'assembly contenu dans le fichier spécifié.
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
Paramètres
- assemblyFile
- String
Nom du fichier contenant l'assembly à exécuter.
Retours
Valeur retournée par le point d'entrée de l'assembly.
Implémente
Exceptions
assemblyFile
a la valeur null
.
assemblyFile
est introuvable.
assemblyFile
n’est pas un assembly valide pour le runtime actuellement chargé.
L’opération est tentée sur un domaine d’application non chargé.
Un assembly ou un module a été chargé à deux reprises avec deux preuves différentes.
L’assembly spécifié n’a aucun point d’entrée.
Exemples
L’exemple suivant illustre l’utilisation de l’une des surcharges de ExecuteAssembly sur deux domaines différents.
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
Remarques
L’assembly commence à s’exécuter au point d’entrée spécifié dans l’en-tête .NET Framework.
Cette méthode ne crée pas de processus ou de domaine d’application et n’exécute pas la méthode de point d’entrée sur un nouveau thread.
Cette méthode charge des assemblys à l’aide de la LoadFile méthode . Vous pouvez également exécuter des assemblys à l’aide de la ExecuteAssemblyByName méthode, qui charge les assemblys à l’aide de la Load méthode .
Pour créer le AppDomain à charger et à exécuter, utilisez la CreateDomain méthode .