AppDomain.CreateInstanceAndUnwrap Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Erstellt eine neue Instanz eines angegebenen Typs.
Überlädt
CreateInstanceAndUnwrap(String, String) |
Erstellt eine neue Instanz des angegebenen Typs. Parameter geben die Assembly, in der der Typ definiert ist, und den Namen des Typs an. |
CreateInstanceAndUnwrap(String, String, Object[]) |
Erstellt eine neue Instanz des angegebenen Typs. Parameter geben die Assembly an, in der der Typ definiert ist, und den Namen des Typs und ein Array von Aktivierungsattributen. |
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) |
Erstellt eine neue Instanz des angegebenen, in der angegebenen Assembly definierten Typs, die angibt, ob die Groß-/Kleinschreibung des Typnamens ignoriert wird, außerdem die Bindungsattribute und den Binder, mit denen der zu erstellende Typ ausgewählt wird, die Argumente des Konstruktors, die Kultur und die Aktivierungsattribute. |
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) |
Veraltet.
Erstellt eine neue Instanz des angegebenen Typs. Parameter geben den Namen des Typs an und wie er gesucht und erstellt werden kann. |
CreateInstanceAndUnwrap(String, String)
- Quelle:
- AppDomain.cs
- Quelle:
- AppDomain.cs
- Quelle:
- AppDomain.cs
Erstellt eine neue Instanz des angegebenen Typs. Parameter geben die Assembly, in der der Typ definiert ist, und den Namen des Typs an.
public:
System::Object ^ CreateInstanceAndUnwrap(System::String ^ assemblyName, System::String ^ typeName);
public object? CreateInstanceAndUnwrap (string assemblyName, string typeName);
public object CreateInstanceAndUnwrap (string assemblyName, string typeName);
member this.CreateInstanceAndUnwrap : string * string -> obj
Public Function CreateInstanceAndUnwrap (assemblyName As String, typeName As String) As Object
Parameter
- typeName
- String
Der vollqualifizierte Name des angeforderten Typs einschließlich des Namespace, jedoch ohne die Assembly, wie er von der FullName -Eigenschaft zurückgegeben wird.
Gibt zurück
Eine Instanz des durch typeName
angegebenen Objekts.
Ausnahmen
assemblyName
oder typeName
ist null
.
Es wurde kein übereinstimmender öffentlicher Konstruktor gefunden.
typename
wurde in assemblyName
nicht gefunden.
assemblyName
wurde nicht gefunden.
Der Aufrufer hat keine Berechtigung zum Aufrufen dieses Konstruktors.
Der Vorgang wird für eine entladene Anwendungsdomäne ausgeführt.
assemblyName
ist keine gültige Assembly für die derzeit geladene Runtime.
Eine Assembly oder ein Modul wurde zweimal mit zwei unterschiedlichen Beweisen geladen.
Beispiele
Das folgende Codebeispiel zeigt die einfachste Methode zum Ausführen von Code in einer anderen Anwendungsdomäne. Im Beispiel wird eine Klasse namens Worker
definiert, die von MarshalByRefObjecterbt. Die Worker
-Klasse definiert eine Methode, die den Namen der Anwendungsdomäne anzeigt, in der sie ausgeführt wird. Im Beispiel werden Instanzen von Worker
in der Standardanwendungsdomäne und in einer neuen Anwendungsdomäne erstellt.
Hinweis
Die Assembly, die enthält Worker
, muss in beide Anwendungsdomänen geladen werden, aber sie kann andere Assemblys laden, die nur in der neuen Anwendungsdomäne vorhanden sind.
using namespace System;
using namespace System::Reflection;
public ref class Worker : MarshalByRefObject
{
public:
void PrintDomain()
{
Console::WriteLine("Object is executing in AppDomain \"{0}\"",
AppDomain::CurrentDomain->FriendlyName);
}
};
void main()
{
// Create an ordinary instance in the current AppDomain
Worker^ localWorker = gcnew Worker();
localWorker->PrintDomain();
// Create a new application domain, create an instance
// of Worker in the application domain, and execute code
// there.
AppDomain^ ad = AppDomain::CreateDomain("New domain");
Worker^ remoteWorker = (Worker^) ad->CreateInstanceAndUnwrap(
Worker::typeid->Assembly->FullName,
"Worker");
remoteWorker->PrintDomain();
}
/* This code produces output similar to the following:
Object is executing in AppDomain "source.exe"
Object is executing in AppDomain "New domain"
*/
using System;
using System.Reflection;
public class CreateInstanceWorker : MarshalByRefObject
{
public void PrintDomain()
{
Console.WriteLine("Object is executing in AppDomain \"{0}\"",
AppDomain.CurrentDomain.FriendlyName);
}
}
class CreateInstanceAndUnwrapSourceSnippet
{
public static void Main()
{
// Create an ordinary instance in the current AppDomain
CreateInstanceWorker localWorker = new CreateInstanceWorker();
localWorker.PrintDomain();
// Create a new application domain, create an instance
// of Worker in the application domain, and execute code
// there.
AppDomain ad = AppDomain.CreateDomain("New domain");
CreateInstanceWorker remoteWorker = (CreateInstanceWorker) ad.CreateInstanceAndUnwrap(
typeof(CreateInstanceWorker).Assembly.FullName,
"Worker");
remoteWorker.PrintDomain();
}
}
/* This code produces output similar to the following:
Object is executing in AppDomain "source.exe"
Object is executing in AppDomain "New domain"
*/
open System
open System.Reflection
type Worker() =
inherit MarshalByRefObject()
member _.PrintDomain() =
printfn $"Object is executing in AppDomain \"{AppDomain.CurrentDomain.FriendlyName}\""
// Create an ordinary instance in the current AppDomain
let localWorker = Worker()
localWorker.PrintDomain()
// Create a new application domain, create an instance
// of Worker in the application domain, and execute code
// there.
let ad = AppDomain.CreateDomain "New domain"
let remoteWorker =
ad.CreateInstanceAndUnwrap(typeof<Worker>.Assembly.FullName, "Worker") :?> Worker
remoteWorker.PrintDomain()
// This code produces output similar to the following:
// Object is executing in AppDomain "source.exe"
// Object is executing in AppDomain "New domain"
Imports System.Reflection
Public Class Worker
Inherits MarshalByRefObject
Public Sub PrintDomain()
Console.WriteLine("Object is executing in AppDomain ""{0}""", _
AppDomain.CurrentDomain.FriendlyName)
End Sub
End Class
Class Example
Public Shared Sub Main()
' Create an ordinary instance in the current AppDomain
Dim localWorker As New Worker()
localWorker.PrintDomain()
' Create a new application domain, create an instance
' of Worker in the application domain, and execute code
' there.
Dim ad As AppDomain = AppDomain.CreateDomain("New domain")
Dim remoteWorker As Worker = CType( _
ad.CreateInstanceAndUnwrap( _
GetType(Worker).Assembly.FullName, _
"Worker"), _
Worker)
remoteWorker.PrintDomain()
End Sub
End Class
' This code produces output similar to the following:
'
'Object is executing in AppDomain "source.exe"
'Object is executing in AppDomain "New domain"
Hinweise
Dies ist eine praktische Methode, die und ObjectHandle.UnwrapkombiniertCreateInstance. Diese Methode ruft den parameterlosen Konstruktor für typeName
auf.
Das Format von finden Sie AssemblyName unter assemblyName
. Sehen Sie sich die Type.FullName -Eigenschaft für das Format von an typeName
.
Hinweis
Wenn Sie einen früh gebundenen Aufruf einer Methode M
eines Objekts vom Typ T1
durchführen, das von CreateInstanceAndUnwrapzurückgegeben wurde, und diese Methode einen früh gebundenen Aufruf einer Methode eines Objekts vom Typ T2
in einer anderen Assembly C
als der aktuellen Assembly oder der Assembly, T1
die enthält, wird die Assembly C
in die aktuelle Anwendungsdomäne geladen. Dieses Laden tritt auch dann auf, wenn der früh gebundene Aufruf T1.M()
von im Textkörper eines oder in einem DynamicMethodanderen dynamisch generierten Code erfolgt ist. Wenn die aktuelle Domäne die Standarddomäne ist, kann die Assembly C
erst entladen werden, wenn der Prozess beendet wird. Wenn die aktuelle Domäne später versucht, die Assembly C
zu laden, schlägt die Auslastung möglicherweise fehl.
Weitere Informationen
Gilt für:
CreateInstanceAndUnwrap(String, String, Object[])
- Quelle:
- AppDomain.cs
- Quelle:
- AppDomain.cs
- Quelle:
- AppDomain.cs
Erstellt eine neue Instanz des angegebenen Typs. Parameter geben die Assembly an, in der der Typ definiert ist, und den Namen des Typs und ein Array von Aktivierungsattributen.
public:
System::Object ^ CreateInstanceAndUnwrap(System::String ^ assemblyName, System::String ^ typeName, cli::array <System::Object ^> ^ activationAttributes);
public object? CreateInstanceAndUnwrap (string assemblyName, string typeName, object?[]? activationAttributes);
public object CreateInstanceAndUnwrap (string assemblyName, string typeName, object[] activationAttributes);
member this.CreateInstanceAndUnwrap : string * string * obj[] -> obj
Public Function CreateInstanceAndUnwrap (assemblyName As String, typeName As String, activationAttributes As Object()) As Object
Parameter
- typeName
- String
Der vollqualifizierte Name des angeforderten Typs einschließlich des Namespace, jedoch ohne die Assembly, wie er von der FullName -Eigenschaft zurückgegeben wird.
- activationAttributes
- Object[]
Ein Array mit einem oder mehreren Attributen, die an der Aktivierung beteiligt sein können. Üblicherweise ein Array, das ein einzelnes UrlAttribute-Objekt enthält, das die zum Aktivieren eines Remoteobjekts erforderliche URL angibt.
Der Parameter ist vom Client aktivierten Objekten zugeordnet. Die Clientaktivierung ist eine veraltete Technologie, die zum Zweck der Abwärtskompatibilität mit vorhandenen Anwendungen beibehalten, jedoch nicht für die Neuentwicklung empfohlen wird. Für verteilte Anwendungen sollte stattdessen Windows Communication Foundation verwendet werden.
Gibt zurück
Eine Instanz des durch typeName
angegebenen Objekts.
Ausnahmen
assemblyName
oder typeName
ist null
.
Es wurde kein übereinstimmender öffentlicher Konstruktor gefunden.
typename
wurde in assemblyName
nicht gefunden.
assemblyName
wurde nicht gefunden.
Der Aufrufer hat keine Berechtigung zum Aufrufen dieses Konstruktors.
Der Aufrufer kann keine Aktivierungsattribute für ein Objekt bereitstellen, das nicht von MarshalByRefObject erbt.
Der Vorgang wird für eine entladene Anwendungsdomäne ausgeführt.
assemblyName
ist keine gültige Assembly für die derzeit geladene Runtime.
Eine Assembly oder ein Modul wurde zweimal mit zwei unterschiedlichen Beweisen geladen.
Beispiele
using namespace System;
using namespace System::IO;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Runtime::Remoting;
ref class ADDyno
{
public:
static Type^ CreateADynamicAssembly( interior_ptr<AppDomain^> myNewDomain, String^ executableNameNoExe )
{
String^ executableName = String::Concat( executableNameNoExe, ".exe" );
AssemblyName^ myAsmName = gcnew AssemblyName;
myAsmName->Name = executableNameNoExe;
myAsmName->CodeBase = Environment::CurrentDirectory;
AssemblyBuilder^ myAsmBuilder = ( *myNewDomain)->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::RunAndSave );
Console::WriteLine( "-- Dynamic Assembly instantiated." );
ModuleBuilder^ myModBuilder = myAsmBuilder->DefineDynamicModule( executableNameNoExe, executableName );
TypeBuilder^ myTypeBuilder = myModBuilder->DefineType( executableNameNoExe, TypeAttributes::Public, MarshalByRefObject::typeid );
array<Type^>^temp0 = nullptr;
MethodBuilder^ myFCMethod = myTypeBuilder->DefineMethod( "CountLocalFiles", static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), nullptr, temp0 );
MethodInfo^ currentDirGetMI = Environment::typeid->GetProperty( "CurrentDirectory" )->GetGetMethod();
array<Type^>^temp1 = {String::typeid};
MethodInfo^ writeLine0objMI = Console::typeid->GetMethod( "WriteLine", temp1 );
array<Type^>^temp2 = {String::typeid,Object::typeid,Object::typeid};
MethodInfo^ writeLine2objMI = Console::typeid->GetMethod( "WriteLine", temp2 );
array<Type^>^temp3 = {String::typeid};
MethodInfo^ getFilesMI = Directory::typeid->GetMethod( "GetFiles", temp3 );
myFCMethod->InitLocals = true;
ILGenerator^ myFCIL = myFCMethod->GetILGenerator();
Console::WriteLine( "-- Generating MSIL method body..." );
LocalBuilder^ v0 = myFCIL->DeclareLocal( String::typeid );
LocalBuilder^ v1 = myFCIL->DeclareLocal( int::typeid );
LocalBuilder^ v2 = myFCIL->DeclareLocal( String::typeid );
LocalBuilder^ v3 = myFCIL->DeclareLocal( array<String^>::typeid );
Label evalForEachLabel = myFCIL->DefineLabel();
Label topOfForEachLabel = myFCIL->DefineLabel();
// Build the method body.
myFCIL->EmitCall( OpCodes::Call, currentDirGetMI, nullptr );
myFCIL->Emit( OpCodes::Stloc_S, v0 );
myFCIL->Emit( OpCodes::Ldc_I4_0 );
myFCIL->Emit( OpCodes::Stloc_S, v1 );
myFCIL->Emit( OpCodes::Ldstr, "---" );
myFCIL->EmitCall( OpCodes::Call, writeLine0objMI, nullptr );
myFCIL->Emit( OpCodes::Ldloc_S, v0 );
myFCIL->EmitCall( OpCodes::Call, getFilesMI, nullptr );
myFCIL->Emit( OpCodes::Stloc_S, v3 );
myFCIL->Emit( OpCodes::Br_S, evalForEachLabel );
// foreach loop starts here.
myFCIL->MarkLabel( topOfForEachLabel );
// Load array of strings and index, store value at index for output.
myFCIL->Emit( OpCodes::Ldloc_S, v3 );
myFCIL->Emit( OpCodes::Ldloc_S, v1 );
myFCIL->Emit( OpCodes::Ldelem_Ref );
myFCIL->Emit( OpCodes::Stloc_S, v2 );
myFCIL->Emit( OpCodes::Ldloc_S, v2 );
myFCIL->EmitCall( OpCodes::Call, writeLine0objMI, nullptr );
// Increment counter by one.
myFCIL->Emit( OpCodes::Ldloc_S, v1 );
myFCIL->Emit( OpCodes::Ldc_I4_1 );
myFCIL->Emit( OpCodes::Add );
myFCIL->Emit( OpCodes::Stloc_S, v1 );
// Determine if end of file list array has been reached.
myFCIL->MarkLabel( evalForEachLabel );
myFCIL->Emit( OpCodes::Ldloc_S, v1 );
myFCIL->Emit( OpCodes::Ldloc_S, v3 );
myFCIL->Emit( OpCodes::Ldlen );
myFCIL->Emit( OpCodes::Conv_I4 );
myFCIL->Emit( OpCodes::Blt_S, topOfForEachLabel );
//foreach loop end here.
myFCIL->Emit( OpCodes::Ldstr, "---" );
myFCIL->EmitCall( OpCodes::Call, writeLine0objMI, nullptr );
myFCIL->Emit( OpCodes::Ldstr, "There are {0} files in {1}." );
myFCIL->Emit( OpCodes::Ldloc_S, v1 );
myFCIL->Emit( OpCodes::Box, int::typeid );
myFCIL->Emit( OpCodes::Ldloc_S, v0 );
myFCIL->EmitCall( OpCodes::Call, writeLine2objMI, nullptr );
myFCIL->Emit( OpCodes::Ret );
Type^ myType = myTypeBuilder->CreateType();
myAsmBuilder->SetEntryPoint( myFCMethod );
myAsmBuilder->Save( executableName );
Console::WriteLine( "-- Method generated, type completed, and assembly saved to disk." );
return myType;
}
};
int main()
{
String^ domainDir;
String^ executableName = nullptr;
Console::Write( "Enter a name for the file counting assembly: " );
String^ executableNameNoExe = Console::ReadLine();
executableName = String::Concat( executableNameNoExe, ".exe" );
Console::WriteLine( "---" );
domainDir = Environment::CurrentDirectory;
AppDomain^ curDomain = Thread::GetDomain();
// Create a new AppDomain, with the current directory as the base.
Console::WriteLine( "Current Directory: {0}", Environment::CurrentDirectory );
AppDomainSetup^ mySetupInfo = gcnew AppDomainSetup;
mySetupInfo->ApplicationBase = domainDir;
mySetupInfo->ApplicationName = executableNameNoExe;
mySetupInfo->LoaderOptimization = LoaderOptimization::SingleDomain;
AppDomain^ myDomain = AppDomain::CreateDomain( executableNameNoExe, nullptr, mySetupInfo );
Console::WriteLine( "Creating a new AppDomain '{0}'...", executableNameNoExe );
Console::WriteLine( "-- Base Directory = '{0}'", myDomain->BaseDirectory );
Console::WriteLine( "-- Shadow Copy? = '{0}'", myDomain->ShadowCopyFiles );
Console::WriteLine( "---" );
Type^ myFCType = ADDyno::CreateADynamicAssembly( &curDomain, executableNameNoExe );
Console::WriteLine( "Loading '{0}' from '{1}'...", executableName, myDomain->BaseDirectory );
BindingFlags bFlags = static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::CreateInstance | BindingFlags::Instance);
Object^ myObjInstance = myDomain->CreateInstanceAndUnwrap( executableNameNoExe, executableNameNoExe, false, bFlags, nullptr, nullptr, nullptr, nullptr, nullptr );
Console::WriteLine( "Executing method 'CountLocalFiles' in {0}...", myObjInstance );
array<Object^>^temp4 = nullptr;
myFCType->InvokeMember( "CountLocalFiles", BindingFlags::InvokeMethod, nullptr, myObjInstance, temp4 );
}
using System;
using System.IO;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.Remoting;
class ADDyno
{
public static Type CreateADynamicAssembly(ref AppDomain myNewDomain,
string executableNameNoExe)
{
string executableName = executableNameNoExe + ".exe";
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = executableNameNoExe;
myAsmName.CodeBase = Environment.CurrentDirectory;
AssemblyBuilder myAsmBuilder = myNewDomain.DefineDynamicAssembly(myAsmName,
AssemblyBuilderAccess.RunAndSave);
Console.WriteLine("-- Dynamic Assembly instantiated.");
ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(executableNameNoExe,
executableName);
TypeBuilder myTypeBuilder = myModBuilder.DefineType(executableNameNoExe,
TypeAttributes.Public,
typeof(MarshalByRefObject));
MethodBuilder myFCMethod = myTypeBuilder.DefineMethod("CountLocalFiles",
MethodAttributes.Public |
MethodAttributes.Static,
null,
new Type[] { });
MethodInfo currentDirGetMI = typeof(Environment).GetProperty("CurrentDirectory").GetGetMethod();
MethodInfo writeLine0objMI = typeof(Console).GetMethod("WriteLine",
new Type[] { typeof(string) });
MethodInfo writeLine2objMI = typeof(Console).GetMethod("WriteLine",
new Type[] { typeof(string), typeof(object), typeof(object) });
MethodInfo getFilesMI = typeof(Directory).GetMethod("GetFiles",
new Type[] { typeof(string) });
myFCMethod.InitLocals = true;
ILGenerator myFCIL = myFCMethod.GetILGenerator();
Console.WriteLine("-- Generating MSIL method body...");
LocalBuilder v0 = myFCIL.DeclareLocal(typeof(string));
LocalBuilder v1 = myFCIL.DeclareLocal(typeof(int));
LocalBuilder v2 = myFCIL.DeclareLocal(typeof(string));
LocalBuilder v3 = myFCIL.DeclareLocal(typeof(string[]));
Label evalForEachLabel = myFCIL.DefineLabel();
Label topOfForEachLabel = myFCIL.DefineLabel();
// Build the method body.
myFCIL.EmitCall(OpCodes.Call, currentDirGetMI, null);
myFCIL.Emit(OpCodes.Stloc_S, v0);
myFCIL.Emit(OpCodes.Ldc_I4_0);
myFCIL.Emit(OpCodes.Stloc_S, v1);
myFCIL.Emit(OpCodes.Ldstr, "---");
myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null);
myFCIL.Emit(OpCodes.Ldloc_S, v0);
myFCIL.EmitCall(OpCodes.Call, getFilesMI, null);
myFCIL.Emit(OpCodes.Stloc_S, v3);
myFCIL.Emit(OpCodes.Br_S, evalForEachLabel);
// foreach loop starts here.
myFCIL.MarkLabel(topOfForEachLabel);
// Load array of strings and index, store value at index for output.
myFCIL.Emit(OpCodes.Ldloc_S, v3);
myFCIL.Emit(OpCodes.Ldloc_S, v1);
myFCIL.Emit(OpCodes.Ldelem_Ref);
myFCIL.Emit(OpCodes.Stloc_S, v2);
myFCIL.Emit(OpCodes.Ldloc_S, v2);
myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null);
// Increment counter by one.
myFCIL.Emit(OpCodes.Ldloc_S, v1);
myFCIL.Emit(OpCodes.Ldc_I4_1);
myFCIL.Emit(OpCodes.Add);
myFCIL.Emit(OpCodes.Stloc_S, v1);
// Determine if end of file list array has been reached.
myFCIL.MarkLabel(evalForEachLabel);
myFCIL.Emit(OpCodes.Ldloc_S, v1);
myFCIL.Emit(OpCodes.Ldloc_S, v3);
myFCIL.Emit(OpCodes.Ldlen);
myFCIL.Emit(OpCodes.Conv_I4);
myFCIL.Emit(OpCodes.Blt_S, topOfForEachLabel);
//foreach loop end here.
myFCIL.Emit(OpCodes.Ldstr, "---");
myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null);
myFCIL.Emit(OpCodes.Ldstr, "There are {0} files in {1}.");
myFCIL.Emit(OpCodes.Ldloc_S, v1);
myFCIL.Emit(OpCodes.Box, typeof(int));
myFCIL.Emit(OpCodes.Ldloc_S, v0);
myFCIL.EmitCall(OpCodes.Call, writeLine2objMI, null);
myFCIL.Emit(OpCodes.Ret);
Type myType = myTypeBuilder.CreateType();
myAsmBuilder.SetEntryPoint(myFCMethod);
myAsmBuilder.Save(executableName);
Console.WriteLine("-- Method generated, type completed, and assembly saved to disk.");
return myType;
}
public static void Main()
{
string domainDir, executableName = null;
Console.Write("Enter a name for the file counting assembly: ");
string executableNameNoExe = Console.ReadLine();
executableName = executableNameNoExe + ".exe";
Console.WriteLine("---");
domainDir = Environment.CurrentDirectory;
AppDomain curDomain = Thread.GetDomain();
// Create a new AppDomain, with the current directory as the base.
Console.WriteLine("Current Directory: {0}", Environment.CurrentDirectory);
AppDomainSetup mySetupInfo = new AppDomainSetup();
mySetupInfo.ApplicationBase = domainDir;
mySetupInfo.ApplicationName = executableNameNoExe;
mySetupInfo.LoaderOptimization = LoaderOptimization.SingleDomain;
AppDomain myDomain = AppDomain.CreateDomain(executableNameNoExe,
null, mySetupInfo);
Console.WriteLine("Creating a new AppDomain '{0}'...",
executableNameNoExe);
Console.WriteLine("-- Base Directory = '{0}'", myDomain.BaseDirectory);
Console.WriteLine("-- Shadow Copy? = '{0}'", myDomain.ShadowCopyFiles);
Console.WriteLine("---");
Type myFCType = CreateADynamicAssembly(ref curDomain,
executableNameNoExe);
Console.WriteLine("Loading '{0}' from '{1}'...", executableName,
myDomain.BaseDirectory.ToString());
BindingFlags bFlags = (BindingFlags.Public | BindingFlags.CreateInstance |
BindingFlags.Instance);
Object myObjInstance = myDomain.CreateInstanceAndUnwrap(executableNameNoExe,
executableNameNoExe, false, bFlags,
null, null, null, null, null);
Console.WriteLine("Executing method 'CountLocalFiles' in {0}...",
myObjInstance.ToString());
myFCType.InvokeMember("CountLocalFiles", BindingFlags.InvokeMethod, null,
myObjInstance, new object[] { });
}
}
open System
open System.IO
open System.Threading
open System.Reflection
open System.Reflection.Emit
let createADynamicAssembly (myNewDomain: byref<AppDomain>) executableNameNoExe =
let executableName = executableNameNoExe + ".exe"
let myAsmName = AssemblyName()
myAsmName.Name <- executableNameNoExe
myAsmName.CodeBase <- Environment.CurrentDirectory
let myAsmBuilder =
myNewDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
printfn "-- Dynamic Assembly instantiated."
let myModBuilder =
myAsmBuilder.DefineDynamicModule(executableNameNoExe, executableName)
let myTypeBuilder =
myModBuilder.DefineType(executableNameNoExe,
TypeAttributes.Public,
typeof<MarshalByRefObject>)
let myFCMethod =
myTypeBuilder.DefineMethod("CountLocalFiles",
MethodAttributes.Public |||
MethodAttributes.Static,
null,
[||])
let currentDirGetMI = typeof<Environment>.GetProperty("CurrentDirectory").GetGetMethod()
let writeLine0objMI = typeof<Console>.GetMethod("WriteLine", [| typeof<string> |])
let writeLine2objMI = typeof<Console>.GetMethod("WriteLine", [| typeof<string>; typeof<obj>; typeof<obj> |])
let getFilesMI = typeof<Directory>.GetMethod("GetFiles", [| typeof<string> |])
myFCMethod.InitLocals <- true
let myFCIL = myFCMethod.GetILGenerator()
printfn "-- Generating MSIL method body..."
let v0 = myFCIL.DeclareLocal typeof<string>
let v1 = myFCIL.DeclareLocal typeof<int>
let v2 = myFCIL.DeclareLocal typeof<string>
let v3 = myFCIL.DeclareLocal typeof<string[]>
let evalForEachLabel = myFCIL.DefineLabel()
let topOfForEachLabel = myFCIL.DefineLabel()
// Build the method body.
myFCIL.EmitCall(OpCodes.Call, currentDirGetMI, null)
myFCIL.Emit(OpCodes.Stloc_S, v0)
myFCIL.Emit(OpCodes.Ldc_I4_0)
myFCIL.Emit(OpCodes.Stloc_S, v1)
myFCIL.Emit(OpCodes.Ldstr, "---")
myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null)
myFCIL.Emit(OpCodes.Ldloc_S, v0)
myFCIL.EmitCall(OpCodes.Call, getFilesMI, null)
myFCIL.Emit(OpCodes.Stloc_S, v3)
myFCIL.Emit(OpCodes.Br_S, evalForEachLabel)
// foreach loop starts here.
myFCIL.MarkLabel topOfForEachLabel
// Load array of strings and index, store value at index for output.
myFCIL.Emit(OpCodes.Ldloc_S, v3)
myFCIL.Emit(OpCodes.Ldloc_S, v1)
myFCIL.Emit OpCodes.Ldelem_Ref
myFCIL.Emit(OpCodes.Stloc_S, v2)
myFCIL.Emit(OpCodes.Ldloc_S, v2)
myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null)
// Increment counter by one.
myFCIL.Emit(OpCodes.Ldloc_S, v1)
myFCIL.Emit(OpCodes.Ldc_I4_1)
myFCIL.Emit OpCodes.Add
myFCIL.Emit(OpCodes.Stloc_S, v1)
// Determine if end of file list array has been reached.
myFCIL.MarkLabel evalForEachLabel
myFCIL.Emit(OpCodes.Ldloc_S, v1)
myFCIL.Emit(OpCodes.Ldloc_S, v3)
myFCIL.Emit OpCodes.Ldlen
myFCIL.Emit OpCodes.Conv_I4
myFCIL.Emit(OpCodes.Blt_S, topOfForEachLabel)
//foreach loop end here.
myFCIL.Emit(OpCodes.Ldstr, "---")
myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, null)
myFCIL.Emit(OpCodes.Ldstr, "There are {0} files in {1}.")
myFCIL.Emit(OpCodes.Ldloc_S, v1)
myFCIL.Emit(OpCodes.Box, typeof<int>)
myFCIL.Emit(OpCodes.Ldloc_S, v0)
myFCIL.EmitCall(OpCodes.Call, writeLine2objMI, null)
myFCIL.Emit OpCodes.Ret
let myType = myTypeBuilder.CreateType()
myAsmBuilder.SetEntryPoint myFCMethod
myAsmBuilder.Save executableName
printfn "-- Method generated, type completed, and assembly saved to disk."
myType
printf "Enter a name for the file counting assembly: "
let executableNameNoExe = stdin.ReadLine()
let executableName = executableNameNoExe + ".exe"
printfn "---"
let domainDir = Environment.CurrentDirectory
let mutable curDomain = Thread.GetDomain()
// Create a new AppDomain, with the current directory as the base.
printfn $"Current Directory: {Environment.CurrentDirectory}"
let mySetupInfo = AppDomainSetup()
mySetupInfo.ApplicationBase <- domainDir
mySetupInfo.ApplicationName <- executableNameNoExe
mySetupInfo.LoaderOptimization <- LoaderOptimization.SingleDomain
let myDomain =
AppDomain.CreateDomain(executableNameNoExe, null, mySetupInfo)
printfn $"Creating a new AppDomain '{executableNameNoExe}'..."
printfn $"-- Base Directory = '{myDomain.BaseDirectory}'"
printfn $"-- Shadow Copy? = '{myDomain.ShadowCopyFiles}'"
printfn "---"
let myFCType =
createADynamicAssembly &curDomain executableNameNoExe
printfn $"Loading '{executableName}' from '{myDomain.BaseDirectory}'..."
let bFlags =
BindingFlags.Public ||| BindingFlags.CreateInstance ||| BindingFlags.Instance
let myObjInstance =
myDomain.CreateInstanceAndUnwrap(executableNameNoExe,
executableNameNoExe, false, bFlags,
null, null, null, null, null)
printfn $"Executing method 'CountLocalFiles' in {myObjInstance}..."
myFCType.InvokeMember("CountLocalFiles", BindingFlags.InvokeMethod, null, myObjInstance, [||])
Imports System.IO
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Runtime.Remoting
Class ADDyno
Public Shared Function CreateADynamicAssembly(ByRef myNewDomain As AppDomain, executableNameNoExe As String) As Type
Dim executableName As String = executableNameNoExe + ".exe"
Dim myAsmName As New AssemblyName()
myAsmName.Name = executableNameNoExe
myAsmName.CodeBase = Environment.CurrentDirectory
Dim myAsmBuilder As AssemblyBuilder = myNewDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave)
Console.WriteLine("-- Dynamic Assembly instantiated.")
Dim myModBuilder As ModuleBuilder = myAsmBuilder.DefineDynamicModule(executableNameNoExe, executableName)
Dim myTypeBuilder As TypeBuilder = myModBuilder.DefineType(executableNameNoExe, TypeAttributes.Public, GetType(MarshalByRefObject))
Dim myFCMethod As MethodBuilder = myTypeBuilder.DefineMethod("CountLocalFiles", MethodAttributes.Public Or MethodAttributes.Static, Nothing, New Type() {})
Dim currentDirGetMI As MethodInfo = GetType(Environment).GetProperty("CurrentDirectory").GetGetMethod()
Dim writeLine0objMI As MethodInfo = GetType(Console).GetMethod("WriteLine", New Type() {GetType(String)})
Dim writeLine2objMI As MethodInfo = GetType(Console).GetMethod("WriteLine", New Type() {GetType(String), GetType(Object), GetType(Object)})
Dim getFilesMI As MethodInfo = GetType(Directory).GetMethod("GetFiles", New Type() {GetType(String)})
myFCMethod.InitLocals = True
Dim myFCIL As ILGenerator = myFCMethod.GetILGenerator()
Console.WriteLine("-- Generating MSIL method body...")
Dim v0 As LocalBuilder = myFCIL.DeclareLocal(GetType(String))
Dim v1 As LocalBuilder = myFCIL.DeclareLocal(GetType(Integer))
Dim v2 As LocalBuilder = myFCIL.DeclareLocal(GetType(String))
Dim v3 As LocalBuilder = myFCIL.DeclareLocal(GetType(String()))
Dim evalForEachLabel As Label = myFCIL.DefineLabel()
Dim topOfForEachLabel As Label = myFCIL.DefineLabel()
' Build the method body.
myFCIL.EmitCall(OpCodes.Call, currentDirGetMI, Nothing)
myFCIL.Emit(OpCodes.Stloc_S, v0)
myFCIL.Emit(OpCodes.Ldc_I4_0)
myFCIL.Emit(OpCodes.Stloc_S, v1)
myFCIL.Emit(OpCodes.Ldstr, "---")
myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, Nothing)
myFCIL.Emit(OpCodes.Ldloc_S, v0)
myFCIL.EmitCall(OpCodes.Call, getFilesMI, Nothing)
myFCIL.Emit(OpCodes.Stloc_S, v3)
myFCIL.Emit(OpCodes.Br_S, evalForEachLabel)
' foreach loop starts here.
myFCIL.MarkLabel(topOfForEachLabel)
' Load array of strings and index, store value at index for output.
myFCIL.Emit(OpCodes.Ldloc_S, v3)
myFCIL.Emit(OpCodes.Ldloc_S, v1)
myFCIL.Emit(OpCodes.Ldelem_Ref)
myFCIL.Emit(OpCodes.Stloc_S, v2)
myFCIL.Emit(OpCodes.Ldloc_S, v2)
myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, Nothing)
' Increment counter by one.
myFCIL.Emit(OpCodes.Ldloc_S, v1)
myFCIL.Emit(OpCodes.Ldc_I4_1)
myFCIL.Emit(OpCodes.Add)
myFCIL.Emit(OpCodes.Stloc_S, v1)
' Determine if end of file list array has been reached.
myFCIL.MarkLabel(evalForEachLabel)
myFCIL.Emit(OpCodes.Ldloc_S, v1)
myFCIL.Emit(OpCodes.Ldloc_S, v3)
myFCIL.Emit(OpCodes.Ldlen)
myFCIL.Emit(OpCodes.Conv_I4)
myFCIL.Emit(OpCodes.Blt_S, topOfForEachLabel)
'foreach loop end here.
myFCIL.Emit(OpCodes.Ldstr, "---")
myFCIL.EmitCall(OpCodes.Call, writeLine0objMI, Nothing)
myFCIL.Emit(OpCodes.Ldstr, "There are {0} files in {1}.")
myFCIL.Emit(OpCodes.Ldloc_S, v1)
myFCIL.Emit(OpCodes.Box, GetType(Integer))
myFCIL.Emit(OpCodes.Ldloc_S, v0)
myFCIL.EmitCall(OpCodes.Call, writeLine2objMI, Nothing)
myFCIL.Emit(OpCodes.Ret)
Dim myType As Type = myTypeBuilder.CreateType()
myAsmBuilder.SetEntryPoint(myFCMethod)
myAsmBuilder.Save(executableName)
Console.WriteLine("-- Method generated, type completed, and assembly saved to disk.")
Return myType
End Function 'CreateADynamicAssembly
Public Shared Sub Main()
Dim executableName As String = Nothing
Dim domainDir As String
Console.Write("Enter a name for the file counting assembly: ")
Dim executableNameNoExe As String = Console.ReadLine()
executableName = executableNameNoExe + ".exe"
Console.WriteLine("---")
domainDir = Environment.CurrentDirectory
Dim curDomain As AppDomain = Thread.GetDomain()
' Create a new AppDomain, with the current directory as the base.
Console.WriteLine("Current Directory: {0}", Environment.CurrentDirectory)
Dim mySetupInfo As New AppDomainSetup()
mySetupInfo.ApplicationBase = domainDir
mySetupInfo.ApplicationName = executableNameNoExe
mySetupInfo.LoaderOptimization = LoaderOptimization.SingleDomain
Dim myDomain As AppDomain = AppDomain.CreateDomain(executableNameNoExe, Nothing, mySetupInfo)
Console.WriteLine("Creating a new AppDomain '{0}'...", executableNameNoExe)
Console.WriteLine("-- Base Directory = '{0}'", myDomain.BaseDirectory)
Console.WriteLine("-- Shadow Copy? = '{0}'", myDomain.ShadowCopyFiles)
Console.WriteLine("---")
Dim myFCType As Type = CreateADynamicAssembly(curDomain, executableNameNoExe)
Console.WriteLine("Loading '{0}' from '{1}'...", executableName, myDomain.BaseDirectory.ToString())
Dim bFlags As BindingFlags = BindingFlags.Public Or BindingFlags.CreateInstance Or BindingFlags.Instance
Dim myObjInstance As [Object] = myDomain.CreateInstanceAndUnwrap(executableNameNoExe, executableNameNoExe, False, bFlags, Nothing, Nothing, Nothing, Nothing, Nothing)
Console.WriteLine("Executing method 'CountLocalFiles' in {0}...", myObjInstance.ToString())
myFCType.InvokeMember("CountLocalFiles", BindingFlags.InvokeMethod, Nothing, myObjInstance, New Object() {})
End Sub
End Class
Hinweise
Dies ist eine praktische Methode, die und ObjectHandle.UnwrapkombiniertCreateInstance. Diese Methode ruft den parameterlosen Konstruktor für typeName
auf.
Das Format von finden Sie AssemblyName unter assemblyName
. Sehen Sie sich die Type.FullName -Eigenschaft für das Format von an typeName
.
Hinweis
Wenn Sie einen früh gebundenen Aufruf einer Methode M
eines Objekts vom Typ T1
durchführen, das von CreateInstanceAndUnwrapzurückgegeben wurde, und diese Methode einen früh gebundenen Aufruf einer Methode eines Objekts vom Typ T2
in einer anderen Assembly C
als der aktuellen Assembly oder der Assembly, T1
die enthält, wird die Assembly C
in die aktuelle Anwendungsdomäne geladen. Dieses Laden tritt auch dann auf, wenn der früh gebundene Aufruf T1.M()
von im Textkörper eines oder in einem DynamicMethodanderen dynamisch generierten Code erfolgt ist. Wenn die aktuelle Domäne die Standarddomäne ist, kann die Assembly C
erst entladen werden, wenn der Prozess beendet wird. Wenn die aktuelle Domäne später versucht, die Assembly C
zu laden, schlägt die Auslastung möglicherweise fehl.
Weitere Informationen
Gilt für:
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])
- Quelle:
- AppDomain.cs
- Quelle:
- AppDomain.cs
- Quelle:
- AppDomain.cs
Erstellt eine neue Instanz des angegebenen, in der angegebenen Assembly definierten Typs, die angibt, ob die Groß-/Kleinschreibung des Typnamens ignoriert wird, außerdem die Bindungsattribute und den Binder, mit denen der zu erstellende Typ ausgewählt wird, die Argumente des Konstruktors, die Kultur und die Aktivierungsattribute.
public:
System::Object ^ CreateInstanceAndUnwrap(System::String ^ assemblyName, System::String ^ typeName, bool ignoreCase, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, cli::array <System::Object ^> ^ args, System::Globalization::CultureInfo ^ culture, cli::array <System::Object ^> ^ activationAttributes);
public object? CreateInstanceAndUnwrap (string assemblyName, string typeName, bool ignoreCase, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder? binder, object?[]? args, System.Globalization.CultureInfo? culture, object?[]? activationAttributes);
public object CreateInstanceAndUnwrap (string assemblyName, string typeName, bool ignoreCase, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, object[] args, System.Globalization.CultureInfo culture, object[] activationAttributes);
member this.CreateInstanceAndUnwrap : string * string * bool * System.Reflection.BindingFlags * System.Reflection.Binder * obj[] * System.Globalization.CultureInfo * obj[] -> obj
Public Function CreateInstanceAndUnwrap (assemblyName As String, typeName As String, ignoreCase As Boolean, bindingAttr As BindingFlags, binder As Binder, args As Object(), culture As CultureInfo, activationAttributes As Object()) As Object
Parameter
- typeName
- String
Der vollqualifizierte Name des angeforderten Typs einschließlich des Namespace, jedoch ohne die Assembly, wie er von der FullName -Eigenschaft zurückgegeben wird.
- ignoreCase
- Boolean
Ein boolescher Wert, der angibt, ob bei der Suche die Groß-/Kleinschreibung beachtet werden soll.
- bindingAttr
- BindingFlags
Eine Kombination von 0 oder mehr Bitflags, die die Suche nach dem typeName
-Konstruktor beeinflussen. Wenn bindingAttr
0 ist, wird eine Suche nach öffentlichen Konstruktoren mit Beachtung der Groß-/Kleinschreibung durchgeführt.
- binder
- Binder
Ein Objekt, das die Bindung, die Umwandlung von Argumenttypen, das Aufrufen von Membern und das Abrufen von MemberInfo-Objekten über Reflektion ermöglicht. Wenn binder
den Wert null aufweist, wird der Standardbinder verwendet.
- args
- Object[]
Die an den Konstruktor zu übergebenden Argumente. Dieses Array von Argumenten muss hinsichtlich Anzahl, Reihenfolge und Typ mit den Parametern des aufzurufenden Konstruktors übereinstimmen. Wenn der parameterlose Konstruktor bevorzugt wird, muss args
ein leeres Array oder NULL sein.
- culture
- CultureInfo
Ein kulturspezifisches Objekt, mit dem die Umwandlung von Typen geregelt wird. Wenn culture
den Wert null
hat, wird die CultureInfo
des aktuellen Threads verwendet.
- activationAttributes
- Object[]
Ein Array mit einem oder mehreren Attributen, die an der Aktivierung beteiligt sein können. In der Regel ein Array, das ein einzelnes UrlAttribute -Objekt enthält. Dies gibt die zum Aktivieren eines Remoteobjekts erforderliche URL an.
Der Parameter ist vom Client aktivierten Objekten zugeordnet. Die Clientaktivierung ist eine veraltete Technologie, die zum Zweck der Abwärtskompatibilität mit vorhandenen Anwendungen beibehalten, jedoch nicht für die Neuentwicklung empfohlen wird. Für verteilte Anwendungen sollte stattdessen Windows Communication Foundation verwendet werden.
Gibt zurück
Eine Instanz des durch typeName
angegebenen Objekts.
Ausnahmen
assemblyName
oder typeName
ist null
.
Es wurde kein übereinstimmender Konstruktor gefunden.
typename
wurde in assemblyName
nicht gefunden.
assemblyName
wurde nicht gefunden.
Der Aufrufer hat keine Berechtigung zum Aufrufen dieses Konstruktors.
Der Aufrufer kann keine Aktivierungsattribute für ein Objekt bereitstellen, das nicht von MarshalByRefObject erbt.
Der Vorgang wird für eine entladene Anwendungsdomäne ausgeführt.
assemblyName
ist keine gültige Assembly für die derzeit geladene Runtime.
Eine Assembly oder ein Modul wurde zweimal mit zwei unterschiedlichen Beweisen geladen.
Beispiele
Im folgenden Beispiel wird die Verwendung des ignoreCase
Parameters veranschaulicht.
using namespace System;
using namespace System::Reflection;
static void InstantiateINT32( bool ignoreCase )
{
try
{
AppDomain^ currentDomain = AppDomain::CurrentDomain;
Object^ instance = currentDomain->CreateInstanceAndUnwrap(
"mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"SYSTEM.INT32",
ignoreCase,
BindingFlags::Default,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr );
Console::WriteLine( instance->GetType() );
}
catch ( TypeLoadException^ e )
{
Console::WriteLine( e->Message );
}
}
int main()
{
InstantiateINT32( false ); // Failed!
InstantiateINT32( true ); // OK!
}
using System;
using System.Reflection;
class IgnoreCaseSnippet {
static void Main() {
InstantiateINT32(false); // Failed!
InstantiateINT32(true); // OK!
}
static void InstantiateINT32(bool ignoreCase) {
try {
AppDomain currentDomain = AppDomain.CurrentDomain;
object instance = currentDomain.CreateInstanceAndUnwrap(
"mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"SYSTEM.INT32",
ignoreCase,
BindingFlags.Default,
null,
null,
null,
null,
null
);
Console.WriteLine(instance.GetType());
} catch (TypeLoadException e) {
Console.WriteLine(e.Message);
}
}
}
open System
open System.Reflection
let instantiateINT32 ignoreCase =
try
let currentDomain = AppDomain.CurrentDomain
let instance = currentDomain.CreateInstanceAndUnwrap(
"mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"SYSTEM.INT32",
ignoreCase,
BindingFlags.Default,
null,
null,
null,
null,
null)
printfn $"{instance.GetType()}"
with :? TypeLoadException as e ->
printfn $"{e.Message}"
instantiateINT32 false // Failed!
instantiateINT32 true // OK!
Imports System.Reflection
Module Test
Sub Main()
InstantiateINT32(False) ' Failed!
InstantiateINT32(True) ' OK!
End Sub
Sub InstantiateINT32(ignoreCase As Boolean)
Try
Dim currentDomain As AppDomain = AppDomain.CurrentDomain
Dim instance As Object = currentDomain.CreateInstanceAndUnwrap( _
"mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", _
"SYSTEM.INT32", _
ignoreCase, _
BindingFlags.Default, _
Nothing, _
Nothing, _
Nothing, _
Nothing, _
Nothing _
)
Console.WriteLine(instance.GetType())
Catch e As TypeLoadException
Console.WriteLine(e.Message)
End Try
End Sub
End Module 'Test
Hinweise
Dies ist eine praktische Methode, die und ObjectHandle.UnwrapkombiniertCreateInstance.
Das Format von finden Sie AssemblyName unter assemblyName
. Sehen Sie sich die Type.FullName -Eigenschaft für das Format von an typeName
.
Hinweis
Wenn Sie einen früh gebundenen Aufruf einer Methode M
eines Objekts vom Typ T1
durchführen, das von CreateInstanceAndUnwrapzurückgegeben wurde, und diese Methode einen früh gebundenen Aufruf einer Methode eines Objekts vom Typ T2
in einer anderen Assembly C
als der aktuellen Assembly oder der Assembly, T1
die enthält, wird die Assembly C
in die aktuelle Anwendungsdomäne geladen. Dieses Laden tritt auch dann auf, wenn der früh gebundene Aufruf T1.M()
von im Textkörper eines oder in einem DynamicMethodanderen dynamisch generierten Code erfolgt ist. Wenn die aktuelle Domäne die Standarddomäne ist, kann die Assembly C
erst entladen werden, wenn der Prozess beendet wird. Wenn die aktuelle Domäne später versucht, die Assembly C
zu laden, schlägt die Auslastung möglicherweise fehl.
Weitere Informationen
Gilt für:
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)
Achtung
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 CreateInstanceAndUnwrap which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.
Erstellt eine neue Instanz des angegebenen Typs. Parameter geben den Namen des Typs an und wie er gesucht und erstellt werden kann.
public:
System::Object ^ CreateInstanceAndUnwrap(System::String ^ assemblyName, System::String ^ typeName, bool ignoreCase, System::Reflection::BindingFlags bindingAttr, System::Reflection::Binder ^ binder, cli::array <System::Object ^> ^ args, System::Globalization::CultureInfo ^ culture, cli::array <System::Object ^> ^ activationAttributes, System::Security::Policy::Evidence ^ securityAttributes);
public object CreateInstanceAndUnwrap (string assemblyName, string typeName, bool ignoreCase, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, object[] args, System.Globalization.CultureInfo culture, object[] activationAttributes, System.Security.Policy.Evidence securityAttributes);
[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 CreateInstanceAndUnwrap which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public object CreateInstanceAndUnwrap (string assemblyName, string typeName, bool ignoreCase, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, object[] args, System.Globalization.CultureInfo culture, object[] activationAttributes, System.Security.Policy.Evidence securityAttributes);
member this.CreateInstanceAndUnwrap : string * string * bool * System.Reflection.BindingFlags * System.Reflection.Binder * obj[] * System.Globalization.CultureInfo * obj[] * System.Security.Policy.Evidence -> obj
[<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 CreateInstanceAndUnwrap which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")>]
member this.CreateInstanceAndUnwrap : string * string * bool * System.Reflection.BindingFlags * System.Reflection.Binder * obj[] * System.Globalization.CultureInfo * obj[] * System.Security.Policy.Evidence -> obj
Public Function CreateInstanceAndUnwrap (assemblyName As String, typeName As String, ignoreCase As Boolean, bindingAttr As BindingFlags, binder As Binder, args As Object(), culture As CultureInfo, activationAttributes As Object(), securityAttributes As Evidence) As Object
Parameter
- typeName
- String
Der vollqualifizierte Name des angeforderten Typs einschließlich des Namespace, jedoch ohne die Assembly, wie er von der FullName -Eigenschaft zurückgegeben wird.
- ignoreCase
- Boolean
Ein boolescher Wert, der angibt, ob bei der Suche die Groß-/Kleinschreibung beachtet werden soll.
- bindingAttr
- BindingFlags
Eine Kombination von 0 oder mehr Bitflags, die die Suche nach dem typeName
-Konstruktor beeinflussen. Wenn bindingAttr
0 ist, wird eine Suche nach öffentlichen Konstruktoren mit Beachtung der Groß-/Kleinschreibung durchgeführt.
- binder
- Binder
Ein Objekt, das die Bindung, die Umwandlung von Argumenttypen, das Aufrufen von Membern und das Abrufen von MemberInfo-Objekten über Reflektion ermöglicht. Wenn binder
den Wert null aufweist, wird der Standardbinder verwendet.
- args
- Object[]
Die an den Konstruktor zu übergebenden Argumente. Dieses Array von Argumenten muss hinsichtlich Anzahl, Reihenfolge und Typ mit den Parametern des aufzurufenden Konstruktors übereinstimmen. Wenn der parameterlose Konstruktor bevorzugt wird, muss args
ein leeres Array oder NULL sein.
- culture
- CultureInfo
Ein kulturspezifisches Objekt, mit dem die Umwandlung von Typen geregelt wird. Wenn culture
den Wert null
hat, wird die CultureInfo
des aktuellen Threads verwendet.
- activationAttributes
- Object[]
Ein Array mit einem oder mehreren Attributen, die an der Aktivierung beteiligt sein können. Üblicherweise ein Array, das ein einzelnes UrlAttribute-Objekt enthält, das die zum Aktivieren eines Remoteobjekts erforderliche URL angibt.
Der Parameter ist vom Client aktivierten Objekten zugeordnet. Die Clientaktivierung ist eine veraltete Technologie, die zum Zweck der Abwärtskompatibilität mit vorhandenen Anwendungen beibehalten, jedoch nicht für die Neuentwicklung empfohlen wird. Für verteilte Anwendungen sollte stattdessen Windows Communication Foundation verwendet werden.
- securityAttributes
- Evidence
Informationen, die zum Autorisieren der Erstellung von typeName
verwendet werden.
Gibt zurück
Eine Instanz des durch typeName
angegebenen Objekts.
- Attribute
Ausnahmen
assemblyName
oder typeName
ist null
.
Es wurde kein übereinstimmender Konstruktor gefunden.
typename
wurde in assemblyName
nicht gefunden.
assemblyName
wurde nicht gefunden.
Der Aufrufer hat keine Berechtigung zum Aufrufen dieses Konstruktors.
Der Aufrufer kann keine Aktivierungsattribute für ein Objekt bereitstellen, das nicht von MarshalByRefObject erbt.
Der Vorgang wird für eine entladene Anwendungsdomäne ausgeführt.
assemblyName
ist keine gültige Assembly für die derzeit geladene Runtime.
Eine Assembly oder ein Modul wurde zweimal mit zwei unterschiedlichen Beweisen geladen.
Beispiele
Im folgenden Beispiel wird die Verwendung des ignoreCase
Parameters veranschaulicht.
using namespace System;
using namespace System::Reflection;
static void InstantiateINT32( bool ignoreCase )
{
try
{
AppDomain^ currentDomain = AppDomain::CurrentDomain;
Object^ instance = currentDomain->CreateInstanceAndUnwrap(
"mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"SYSTEM.INT32",
ignoreCase,
BindingFlags::Default,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr );
Console::WriteLine( instance->GetType() );
}
catch ( TypeLoadException^ e )
{
Console::WriteLine( e->Message );
}
}
int main()
{
InstantiateINT32( false ); // Failed!
InstantiateINT32( true ); // OK!
}
using System;
using System.Reflection;
class IgnoreCaseSnippet {
static void Main() {
InstantiateINT32(false); // Failed!
InstantiateINT32(true); // OK!
}
static void InstantiateINT32(bool ignoreCase) {
try {
AppDomain currentDomain = AppDomain.CurrentDomain;
object instance = currentDomain.CreateInstanceAndUnwrap(
"mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"SYSTEM.INT32",
ignoreCase,
BindingFlags.Default,
null,
null,
null,
null,
null
);
Console.WriteLine(instance.GetType());
} catch (TypeLoadException e) {
Console.WriteLine(e.Message);
}
}
}
open System
open System.Reflection
let instantiateINT32 ignoreCase =
try
let currentDomain = AppDomain.CurrentDomain
let instance = currentDomain.CreateInstanceAndUnwrap(
"mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"SYSTEM.INT32",
ignoreCase,
BindingFlags.Default,
null,
null,
null,
null,
null)
printfn $"{instance.GetType()}"
with :? TypeLoadException as e ->
printfn $"{e.Message}"
instantiateINT32 false // Failed!
instantiateINT32 true // OK!
Imports System.Reflection
Module Test
Sub Main()
InstantiateINT32(False) ' Failed!
InstantiateINT32(True) ' OK!
End Sub
Sub InstantiateINT32(ignoreCase As Boolean)
Try
Dim currentDomain As AppDomain = AppDomain.CurrentDomain
Dim instance As Object = currentDomain.CreateInstanceAndUnwrap( _
"mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", _
"SYSTEM.INT32", _
ignoreCase, _
BindingFlags.Default, _
Nothing, _
Nothing, _
Nothing, _
Nothing, _
Nothing _
)
Console.WriteLine(instance.GetType())
Catch e As TypeLoadException
Console.WriteLine(e.Message)
End Try
End Sub
End Module 'Test
Hinweise
Dies ist eine praktische Methode, die und ObjectHandle.UnwrapkombiniertCreateInstance.
Das Format von finden Sie AssemblyName unter assemblyName
. Sehen Sie sich die Type.FullName -Eigenschaft für das Format von an typeName
.
Hinweis
Wenn Sie einen früh gebundenen Aufruf einer Methode M
eines Objekts vom Typ T1
durchführen, das von CreateInstanceAndUnwrapzurückgegeben wurde, und diese Methode einen früh gebundenen Aufruf einer Methode eines Objekts vom Typ T2
in einer anderen Assembly C
als der aktuellen Assembly oder der Assembly, T1
die enthält, wird die Assembly C
in die aktuelle Anwendungsdomäne geladen. Dieses Laden tritt auch dann auf, wenn der früh gebundene Aufruf T1.M()
von im Textkörper eines oder in einem DynamicMethodanderen dynamisch generierten Code erfolgt ist. Wenn die aktuelle Domäne die Standarddomäne ist, kann die Assembly C
erst entladen werden, wenn der Prozess beendet wird. Wenn die aktuelle Domäne später versucht, die Assembly C
zu laden, schlägt die Auslastung möglicherweise fehl.
Weitere Informationen
Gilt für:
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für