AppDomain.CreateInstanceAndUnwrap Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Crea una nuova istanza di un tipo specificato.
Overload
CreateInstanceAndUnwrap(String, String) |
Crea una nuova istanza del tipo specificato. I parametri specificano l'assembly in cui è definito il tipo e il nome del tipo. |
CreateInstanceAndUnwrap(String, String, Object[]) |
Crea una nuova istanza del tipo specificato. I parametri specificano l'assembly in cui è definito il tipo, il nome del tipo e una matrice di attributi di attivazione. |
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[]) |
Crea una nuova istanza del tipo specificato definito nell'assembly specificato, indicando se ignorare le maiuscole/minuscole del nome del tipo, gli attributi e lo strumento di associazione usati per selezionare il tipo da creare, gli argomenti del costruttore, le impostazioni cultura e gli attributi di attivazione. |
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence) |
Obsoleti.
Crea una nuova istanza del tipo specificato. I parametri specificano il nome del tipo e le relative modalità di individuazione e creazione. |
CreateInstanceAndUnwrap(String, String)
- Origine:
- AppDomain.cs
- Origine:
- AppDomain.cs
- Origine:
- AppDomain.cs
Crea una nuova istanza del tipo specificato. I parametri specificano l'assembly in cui è definito il tipo e il nome del tipo.
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
Parametri
- typeName
- String
Nome completo del tipo richiesto, compreso lo spazio dei nomi ed escluso l'assembly, restituito dalla proprietà FullName.
Restituisce
Istanza dell'oggetto specificato da typeName
.
Eccezioni
assemblyName
o typeName
è null
.
Non è stato trovato alcun costruttore pubblico corrispondente.
Non è possibile trovare typename
in assemblyName
.
Il parametro assemblyName
non è stato trovato.
Il chiamante non ha l'autorizzazione necessaria per chiamare il costruttore.
L'operazione viene tentata in un dominio dell'applicazione non caricato.
assemblyName
non è un assembly valido per il runtime attualmente caricato.
Un assembly o un modulo è stato caricato due volte con due evidenze diverse.
Esempio
L'esempio di codice seguente illustra il modo più semplice per eseguire il codice in un altro dominio applicazione. L'esempio definisce una classe denominata Worker
che eredita da MarshalByRefObject. La Worker
classe definisce un metodo che visualizza il nome del dominio applicazione in cui è in esecuzione. Nell'esempio vengono create istanze di Worker
nel dominio applicazione predefinito e in un nuovo dominio applicazione.
Nota
L'assembly che contiene Worker
deve essere caricato in entrambi i domini applicazione, ma può caricare altri assembly esistenti solo nel nuovo dominio applicazione.
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"
Commenti
Si tratta di un metodo pratico che combina CreateInstance e ObjectHandle.Unwrap. Questo metodo chiama il costruttore senza parametri per typeName
.
Vedere AssemblyName per il formato di assemblyName
. Vedere la Type.FullName proprietà per il formato di typeName
.
Nota
Se si effettua una chiamata con associazione anticipata a un metodo M
di un oggetto di tipo T1
restituito da CreateInstanceAndUnwrape tale metodo effettua una chiamata con associazione anticipata a un metodo di un oggetto di tipo T2
in un assembly C
diverso dall'assembly corrente o dall'assembly contenente T1
, l'assembly C
viene caricato nel dominio applicazione corrente. Questo caricamento si verifica anche se la chiamata con associazione anticipata a T1.M()
è stata effettuata nel corpo di un DynamicMethodoggetto o in un altro codice generato in modo dinamico. Se il dominio corrente è il dominio predefinito, l'assembly C
non può essere scaricato fino al termine del processo. Se il dominio corrente tenta successivamente di caricare l'assembly C
, il carico potrebbe non riuscire.
Vedi anche
Si applica a
CreateInstanceAndUnwrap(String, String, Object[])
- Origine:
- AppDomain.cs
- Origine:
- AppDomain.cs
- Origine:
- AppDomain.cs
Crea una nuova istanza del tipo specificato. I parametri specificano l'assembly in cui è definito il tipo, il nome del tipo e una matrice di attributi di attivazione.
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
Parametri
- typeName
- String
Nome completo del tipo richiesto, compreso lo spazio dei nomi ed escluso l'assembly, restituito dalla proprietà FullName.
- activationAttributes
- Object[]
Matrice di uno o più attributi che possono prendere parte all'attivazione. In genere, matrice che contiene un singolo oggetto UrlAttribute che specifica l'URL necessario per attivare un oggetto remoto.
Il parametro è correlato agli oggetti attivati dal client. L'attivazione del client è una tecnologia legacy mantenuta per garantire la compatibilità con le versioni precedenti, ma non è consigliata per nuove attività di sviluppo. Per le applicazioni distribuite si dovrebbe usare invece Windows Communication Foundation.
Restituisce
Istanza dell'oggetto specificato da typeName
.
Eccezioni
assemblyName
o typeName
è null
.
Non è stato trovato alcun costruttore pubblico corrispondente.
Non è possibile trovare typename
in assemblyName
.
Il parametro assemblyName
non è stato trovato.
Il chiamante non ha l'autorizzazione necessaria per chiamare il costruttore.
Il chiamante non può fornire attributi di attivazione per un oggetto che non eredita da MarshalByRefObject.
L'operazione viene tentata in un dominio dell'applicazione non caricato.
assemblyName
non è un assembly valido per il runtime attualmente caricato.
Un assembly o un modulo è stato caricato due volte con due evidenze diverse.
Esempio
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
Commenti
Si tratta di un metodo pratico che combina CreateInstance e ObjectHandle.Unwrap. Questo metodo chiama il costruttore senza parametri per typeName
.
Vedere AssemblyName per il formato di assemblyName
. Vedere la Type.FullName proprietà per il formato di typeName
.
Nota
Se si effettua una chiamata con associazione anticipata a un metodo M
di un oggetto di tipo T1
restituito da CreateInstanceAndUnwrape tale metodo effettua una chiamata con associazione anticipata a un metodo di un oggetto di tipo T2
in un assembly C
diverso dall'assembly corrente o dall'assembly contenente T1
, l'assembly C
viene caricato nel dominio applicazione corrente. Questo caricamento si verifica anche se la chiamata con associazione anticipata a T1.M()
è stata effettuata nel corpo di un DynamicMethodoggetto o in un altro codice generato in modo dinamico. Se il dominio corrente è il dominio predefinito, l'assembly C
non può essere scaricato fino al termine del processo. Se il dominio corrente tenta successivamente di caricare l'assembly C
, il carico potrebbe non riuscire.
Vedi anche
Si applica a
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[])
- Origine:
- AppDomain.cs
- Origine:
- AppDomain.cs
- Origine:
- AppDomain.cs
Crea una nuova istanza del tipo specificato definito nell'assembly specificato, indicando se ignorare le maiuscole/minuscole del nome del tipo, gli attributi e lo strumento di associazione usati per selezionare il tipo da creare, gli argomenti del costruttore, le impostazioni cultura e gli attributi di attivazione.
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
Parametri
- typeName
- String
Nome completo del tipo richiesto, compreso lo spazio dei nomi ed escluso l'assembly, restituito dalla proprietà FullName.
- ignoreCase
- Boolean
Valore booleano che indica se deve o meno essere eseguita una ricerca con distinzione tra maiuscole e minuscole.
- bindingAttr
- BindingFlags
Combinazione di zero o più flag di bit che influiscono sulla ricerca del costruttore typeName
. Se bindingAttr
è uguale a zero, verrà eseguita una ricerca di costruttori pubblici con distinzione tra maiuscole e minuscole.
- binder
- Binder
Oggetto che consente l'associazione, la coercizione dei tipi di argomento, la chiamata dei membri e il recupero di oggetti MemberInfo tramite reflection. Se binder
è Null, verrà usato il binder predefinito.
- args
- Object[]
Argomenti da passare al costruttore. La matrice di argomenti deve corrispondere ai parametri del costruttore da richiamare in quanto a numero, ordine e tipo. Per usare il costruttore senza parametri, args
deve essere una matrice vuota o Null.
- culture
- CultureInfo
Oggetto specifico delle impostazioni cultura usato per regolare la coercizione dei tipi. Se culture
è null
, per il thread corrente verrà usato l'oggetto CultureInfo
.
- activationAttributes
- Object[]
Matrice di uno o più attributi che possono prendere parte all'attivazione. In genere, corrisponde a una matrice che contiene un singolo oggetto UrlAttribute. specifica l'URL necessario per attivare un oggetto remoto.
Il parametro è correlato agli oggetti attivati dal client. L'attivazione del client è una tecnologia legacy mantenuta per garantire la compatibilità con le versioni precedenti, ma non è consigliata per nuove attività di sviluppo. Per le applicazioni distribuite si dovrebbe usare invece Windows Communication Foundation.
Restituisce
Istanza dell'oggetto specificato da typeName
.
Eccezioni
assemblyName
o typeName
è null
.
Non è stato trovato alcun costruttore corrispondente.
Non è possibile trovare typename
in assemblyName
.
Il parametro assemblyName
non è stato trovato.
Il chiamante non ha l'autorizzazione necessaria per chiamare il costruttore.
Il chiamante non può fornire attributi di attivazione per un oggetto che non eredita da MarshalByRefObject.
L'operazione viene tentata in un dominio dell'applicazione non caricato.
assemblyName
non è un assembly valido per il runtime attualmente caricato.
Un assembly o un modulo è stato caricato due volte con due evidenze diverse.
Esempio
Nell'esempio seguente viene illustrato l'uso del ignoreCase
parametro .
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
Commenti
Si tratta di un metodo pratico che combina CreateInstance e ObjectHandle.Unwrap.
Vedere AssemblyName per il formato di assemblyName
. Vedere la Type.FullName proprietà per il formato di typeName
.
Nota
Se si effettua una chiamata con associazione anticipata a un metodo M
di un oggetto di tipo T1
restituito da CreateInstanceAndUnwrape tale metodo effettua una chiamata con associazione anticipata a un metodo di un oggetto di tipo T2
in un assembly C
diverso dall'assembly corrente o dall'assembly contenente T1
, l'assembly C
viene caricato nel dominio applicazione corrente. Questo caricamento si verifica anche se la chiamata con associazione anticipata a T1.M()
è stata effettuata nel corpo di un DynamicMethodoggetto o in un altro codice generato in modo dinamico. Se il dominio corrente è il dominio predefinito, l'assembly C
non può essere scaricato fino al termine del processo. Se il dominio corrente tenta successivamente di caricare l'assembly C
, il carico potrebbe non riuscire.
Vedi anche
Si applica a
CreateInstanceAndUnwrap(String, String, Boolean, BindingFlags, Binder, Object[], CultureInfo, Object[], Evidence)
Attenzione
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.
Crea una nuova istanza del tipo specificato. I parametri specificano il nome del tipo e le relative modalità di individuazione e creazione.
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
Parametri
- typeName
- String
Nome completo del tipo richiesto, compreso lo spazio dei nomi ed escluso l'assembly, restituito dalla proprietà FullName.
- ignoreCase
- Boolean
Valore booleano che indica se deve o meno essere eseguita una ricerca con distinzione tra maiuscole e minuscole.
- bindingAttr
- BindingFlags
Combinazione di zero o più flag di bit che influiscono sulla ricerca del costruttore typeName
. Se bindingAttr
è uguale a zero, verrà eseguita una ricerca di costruttori pubblici con distinzione tra maiuscole e minuscole.
- binder
- Binder
Oggetto che consente l'associazione, la coercizione dei tipi di argomento, la chiamata dei membri e il recupero di oggetti MemberInfo tramite reflection. Se binder
è Null, verrà usato il binder predefinito.
- args
- Object[]
Argomenti da passare al costruttore. La matrice di argomenti deve corrispondere ai parametri del costruttore da richiamare in quanto a numero, ordine e tipo. Per usare il costruttore senza parametri, args
deve essere una matrice vuota o Null.
- culture
- CultureInfo
Oggetto specifico delle impostazioni cultura usato per regolare la coercizione dei tipi. Se culture
è null
, per il thread corrente verrà usato l'oggetto CultureInfo
.
- activationAttributes
- Object[]
Matrice di uno o più attributi che possono prendere parte all'attivazione. In genere, matrice che contiene un singolo oggetto UrlAttribute che specifica l'URL necessario per attivare un oggetto remoto.
Il parametro è correlato agli oggetti attivati dal client. L'attivazione del client è una tecnologia legacy mantenuta per garantire la compatibilità con le versioni precedenti, ma non è consigliata per nuove attività di sviluppo. Per le applicazioni distribuite si dovrebbe usare invece Windows Communication Foundation.
- securityAttributes
- Evidence
Informazioni usate per autorizzare la creazione di typeName
.
Restituisce
Istanza dell'oggetto specificato da typeName
.
- Attributi
Eccezioni
assemblyName
o typeName
è null
.
Non è stato trovato alcun costruttore corrispondente.
Non è possibile trovare typename
in assemblyName
.
Il parametro assemblyName
non è stato trovato.
Il chiamante non ha l'autorizzazione necessaria per chiamare il costruttore.
Il chiamante non può fornire attributi di attivazione per un oggetto che non eredita da MarshalByRefObject.
L'operazione viene tentata in un dominio dell'applicazione non caricato.
assemblyName
non è un assembly valido per il runtime attualmente caricato.
Un assembly o un modulo è stato caricato due volte con due evidenze diverse.
Esempio
Nell'esempio seguente viene illustrato l'uso del ignoreCase
parametro .
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
Commenti
Si tratta di un metodo pratico che combina CreateInstance e ObjectHandle.Unwrap.
Vedere AssemblyName per il formato di assemblyName
. Vedere la Type.FullName proprietà per il formato di typeName
.
Nota
Se si effettua una chiamata con associazione anticipata a un metodo M
di un oggetto di tipo T1
restituito da CreateInstanceAndUnwrape tale metodo effettua una chiamata con associazione anticipata a un metodo di un oggetto di tipo T2
in un assembly C
diverso dall'assembly corrente o dall'assembly contenente T1
, l'assembly C
viene caricato nel dominio applicazione corrente. Questo caricamento si verifica anche se la chiamata con associazione anticipata a T1.M()
è stata effettuata nel corpo di un DynamicMethodoggetto o in un altro codice generato in modo dinamico. Se il dominio corrente è il dominio predefinito, l'assembly C
non può essere scaricato fino al termine del processo. Se il dominio corrente tenta successivamente di caricare l'assembly C
, il carico potrebbe non riuscire.
Vedi anche
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per