Questa pagina è stata utile?
I suggerimenti relativi al contenuto di questa pagina sono importanti. Comunicaceli.
Altri suggerimenti?
1500 caratteri rimanenti
Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe DynamicMethod

Definisce e rappresenta un metodo dinamico che può essere compilato, eseguito ed eliminato. I metodi scartati sono disponibili per la procedura di Garbage Collection.

Spazio dei nomi:  System.Reflection.Emit
Assembly:  mscorlib (in mscorlib.dll)

[ComVisibleAttribute(true)]
public sealed class DynamicMethod : MethodInfo

Il tipo DynamicMethod espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoDynamicMethod(String, Type, Type[])Inizializza un metodo dinamico contenuto anonimamente, specificando il nome del metodo, il tipo restituito e tipi di parametro.
Metodo pubblicoDynamicMethod(String, Type, Type[], Boolean)Inizializza un metodo dinamico contenuto anonimamente, specificando il nome del metodo, il tipo restituito, i tipi di parametri e il modulo e indicando se deve essere ignorato il controllo di visibilità JIT per i tipi e i membri del metodo dinamico a cui accede MSIL (Microsoft Intermediate Language).
Metodo pubblicoDynamicMethod(String, Type, Type[], Module)Crea un metodo dinamico globale per un modulo, specificando il nome del metodo, il tipo restituito, i tipi di parametri e il modulo.
Metodo pubblicoDynamicMethod(String, Type, Type[], Type)Crea un metodo dinamico, specificando il nome del metodo, il tipo restituito, i parametri di tipo e il tipo a cui il metodo dinamico è associato dal punto di vista logico.
Metodo pubblicoDynamicMethod(String, Type, Type[], Module, Boolean)Crea un metodo dinamico globale per un modulo, specificando il nome del metodo, il tipo restituito, i tipi di parametri e il modulo e indicando se deve essere ignorato il controllo di visibilità JIT per i tipi e i membri del metodo dinamico a cui accede MSIL (Microsoft Intermediate Language).
Metodo pubblicoDynamicMethod(String, Type, Type[], Type, Boolean)Crea un metodo dinamico, specificando il nome del metodo, il tipo restituito, i tipi di parametri, il tipo a cui il metodo dinamico è associato dal punto di vista logico e indicando se è necessario ignorare il controllo di visibilità JIT per i tipi e i membri a cui accede il linguaggio MSIL (Microsoft Intermediate Language) del metodo dinamico.
Metodo pubblicoDynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)Crea un metodo dinamico globale per un modulo, specificando il nome del metodo, gli attributi, la convenzione di chiamata, il tipo restituito, i tipi di parametri e il modulo e indicando se deve essere ignorato il controllo di visibilità JIT per i tipi e i membri a cui accede il linguaggio MSIL (Microsoft Intermediate Language) del metodo dinamico.
Metodo pubblicoDynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)Crea un metodo dinamico, specificando il nome del metodo, gli attributi, la convenzione di chiamata, il tipo restituito, i tipi di parametri, il tipo a cui il metodo dinamico è associato dal punto di vista logico e indicando se è necessario ignorare il controllo di visibilità JIT per i tipi e i membri a cui accede il linguaggio MSIL (Microsoft Intermediate Language) del metodo dinamico.
In alto

  NomeDescrizione
Proprietà pubblicaAttributesOttiene gli attributi specificati quando il metodo dinamico è stato creato. (Esegue l'override di MethodBase.Attributes).
Proprietà pubblicaCallingConventionOttiene la convenzione di chiamata specificata quando il metodo dinamico è stato creato. (Esegue l'override di MethodBase.CallingConvention).
Proprietà pubblicaContainsGenericParametersOttiene un valore che indica se il metodo generico contiene parametri di tipo generico non assegnati. (Ereditato da MethodBase)
Proprietà pubblicaCustomAttributesOttiene una raccolta che contiene gli attributi personalizzati del membro. (Ereditato da MemberInfo)
Proprietà pubblicaDeclaringTypeOttiene il tipo che dichiara il metodo, che è sempre null per i metodi dinamici. (Esegue l'override di MemberInfo.DeclaringType).
Proprietà pubblicaInitLocalsOttiene o imposta un valore che indica se le variabili locali all'interno del metodo sono inizializzate su zero.
Proprietà pubblicaIsAbstractOttiene un valore che indica se il metodo è astratto. (Ereditato da MethodBase)
Proprietà pubblicaIsAssemblyOttiene un valore che indica se la visibilità potenziale di questo metodo o costruttore è descritta da MethodAttributes.Assembly, ovvero se il metodo o costruttore è visibile al massimo ad altri tipi dello stesso assembly, ma non ai tipi derivati all'esterno dell'assembly. (Ereditato da MethodBase)
Proprietà pubblicaIsConstructorOttiene un valore che indica se il metodo è un costruttore. (Ereditato da MethodBase)
Proprietà pubblicaIsFamilyOttiene un valore che indica se la visibilità di questo metodo o costruttore è descritta da MethodAttributes.Family, ovvero se il metodo o costruttore è visibile solo all'interno della relativa classe e delle classi derivate. (Ereditato da MethodBase)
Proprietà pubblicaIsFamilyAndAssemblyOttiene un valore che indica se la visibilità di questo metodo o costruttore è descritta da MethodAttributes.FamANDAssem, ovvero se è possibile chiamare il metodo o il costruttore da classi derivate, ma solo se appartenenti allo stesso assembly. (Ereditato da MethodBase)
Proprietà pubblicaIsFamilyOrAssemblyOttiene un valore che indica se la visibilità potenziale di questo metodo o costruttore è descritta da MethodAttributes.FamORAssem, ovvero se è possibile chiamare il metodo o il costruttore da classi derivate indipendentemente dalla posizione e da classi appartenenti allo stesso assembly. (Ereditato da MethodBase)
Proprietà pubblicaIsFinalOttiene un valore che indica se il metodo è final. (Ereditato da MethodBase)
Proprietà pubblicaIsGenericMethodOttiene un valore che indica se il metodo è generico. (Ereditato da MethodBase)
Proprietà pubblicaIsGenericMethodDefinitionOttiene un valore che indica se il metodo è una definizione di un metodo generico. (Ereditato da MethodBase)
Proprietà pubblicaIsHideBySigOttiene un valore che indica se nella classe derivata è nascosto un solo membro dello stesso tipo che riporta esattamente la stessa firma. (Ereditato da MethodBase)
Proprietà pubblicaIsPrivateOttiene un valore che indica se questo membro è privato. (Ereditato da MethodBase)
Proprietà pubblicaIsPublicOttiene un valore che indica se si tratta di un metodo pubblico. (Ereditato da MethodBase)
Proprietà pubblicaIsSecurityCriticalOttiene un valore che indica se il metodo dinamico corrente è critico per la sicurezza o security-safe-critical e quindi è in grado di eseguire operazioni critiche. (Esegue l'override di MethodBase.IsSecurityCritical).
Proprietà pubblicaIsSecuritySafeCriticalOttiene un valore che indica se il metodo dinamico corrente è security-safe-critical al livello di attendibilità corrente, vale a dire se può eseguire operazioni critiche ed essere richiamato da codice trasparente. (Esegue l'override di MethodBase.IsSecuritySafeCritical).
Proprietà pubblicaIsSecurityTransparentOttiene un valore che indica se il metodo dinamico corrente è trasparente al livello di attendibilità corrente, e pertanto non può eseguire operazioni critiche. (Esegue l'override di MethodBase.IsSecurityTransparent).
Proprietà pubblicaIsSpecialNameOttiene un valore che indica se questo metodo ha un nome speciale. (Ereditato da MethodBase)
Proprietà pubblicaIsStaticOttiene un valore che indica se il metodo è static. (Ereditato da MethodBase)
Proprietà pubblicaIsVirtualOttiene un valore che indica se il metodo è virtual. (Ereditato da MethodBase)
Proprietà pubblicaMemberTypeOttiene un valore MemberTypes che indica che questo membro è un metodo. (Ereditato da MethodInfo)
Proprietà pubblicaMetadataTokenOttiene un valore che identifica un elemento di metadati. (Ereditato da MemberInfo)
Proprietà pubblicaMethodHandleNon supportato per i metodi dinamici. (Esegue l'override di MethodBase.MethodHandle).
Proprietà pubblicaMethodImplementationFlagsOttiene i flag MethodImplAttributes che specificano gli attributi di implementazione di un metodo. (Ereditato da MethodBase)
Proprietà pubblicaModuleOttiene il modulo a cui il metodo dinamico è associato dal punto di vista logico. (Esegue l'override di MemberInfo.Module).
Proprietà pubblicaNameOttiene il nome del metodo dinamico. (Esegue l'override di MemberInfo.Name).
Proprietà pubblicaReflectedTypeOttiene la classe utilizzata nella reflection per ottenere il metodo. (Esegue l'override di MemberInfo.ReflectedType).
Proprietà pubblicaReturnParameterOttiene il parametro restituito del metodo dinamico. (Esegue l'override di MethodInfo.ReturnParameter).
Proprietà pubblicaReturnTypeOttiene il tipo del valore restituito per il metodo dinamico. (Esegue l'override di MethodInfo.ReturnType).
Proprietà pubblicaReturnTypeCustomAttributesOttiene gli attributi personalizzati del tipo restituito per il metodo dinamico. (Esegue l'override di MethodInfo.ReturnTypeCustomAttributes).
In alto

  NomeDescrizione
Metodo pubblicoCreateDelegate(Type)Completa il metodo dinamico e crea un delegato che può essere utilizzato per eseguirlo. (Esegue l'override di MethodInfo.CreateDelegate(Type)).
Metodo pubblicoCreateDelegate(Type, Object)Completa il metodo dinamico e crea un delegato che può essere utilizzato per eseguirlo, specificando il tipo di delegato e l'oggetto a cui il delegato è associato. (Esegue l'override di MethodInfo.CreateDelegate(Type, Object)).
Metodo pubblicoDefineParameterDefinisce un parametro del metodo dinamico.
Metodo pubblicoEquals Restituisce un valore che indica se questa istanza è uguale ad un oggetto specificato. (Ereditato da MethodInfo)
Metodo pubblicoGetBaseDefinitionRestituisce l'implementazione di base per il metodo. (Esegue l'override di MethodInfo.GetBaseDefinition()).
Metodo pubblicoGetCustomAttributes(Boolean)Restituisce tutti gli attributi personalizzati definiti per il metodo. (Esegue l'override di MemberInfo.GetCustomAttributes(Boolean)).
Metodo pubblicoGetCustomAttributes(Type, Boolean)Restituisce gli attributi personalizzati del tipo specificato che sono stati applicati al metodo. (Esegue l'override di MemberInfo.GetCustomAttributes(Type, Boolean)).
Metodo pubblicoGetCustomAttributesDataRestituisce un elenco di oggetti CustomAttributeData che rappresentano i dati sugli attributi applicati al membro di destinazione. (Ereditato da MemberInfo)
Metodo pubblicoGetDynamicILInfoRestituisce un oggetto DynamicILInfo che è possibile utilizzare per generare il corpo di un metodo da token di metadati, ambiti e flussi MSIL (Microsoft Intermediate Language).
Metodo pubblicoGetGenericArgumentsRestituisce una matrice di oggetti Type che rappresentano gli argomenti di tipo di un metodo generico o i parametri di tipo della definizione di un metodo generico. (Ereditato da MethodInfo)
Metodo pubblicoGetGenericMethodDefinitionRestituisce un oggetto MethodInfo che rappresenta la definizione di un metodo generica da cui è possibile costruire il metodo corrente. (Ereditato da MethodInfo)
Metodo pubblicoGetHashCode Restituisce il codice hash per questa istanza. (Ereditato da MethodInfo)
Metodo pubblicoGetILGenerator()Restituisce un generatore in linguaggio MSIL (Microsoft Intermediate Language) per il metodo con una dimensione di flusso MSIL predefinita di 64 byte.
Metodo pubblicoGetILGenerator(Int32)Restituisce un generatore MSIL (Microsoft Intermediate Language) per il metodo con la dimensione di flusso MSIL specificata.
Metodo pubblicoGetMethodBodySe viene eseguito l'override in una classe derivata, ottiene un oggetto MethodBody che consente di accedere al flusso MSIL, alle variabili locali e alle eccezioni per il metodo corrente. (Ereditato da MethodBase)
Metodo pubblicoGetMethodImplementationFlagsRestituisce i flag di implementazione per il metodo. (Esegue l'override di MethodBase.GetMethodImplementationFlags()).
Metodo pubblicoGetParametersRestituisce i parametri del metodo dinamico. (Esegue l'override di MethodBase.GetParameters()).
Metodo pubblicoGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoInvoke(Object, Object[])Richiama il metodo o il costruttore rappresentati dall'istanza corrente utilizzando i parametri specificati. (Ereditato da MethodBase)
Metodo pubblicoInvoke(Object, BindingFlags, Binder, Object[], CultureInfo)Richiama il metodo dinamico utilizzando i parametri specificati, con i vincoli del gestore di associazione specificato e le informazioni sulle impostazioni cultura specificate. (Esegue l'override di MethodBase.Invoke(Object, BindingFlags, Binder, Object[], CultureInfo)).
Metodo pubblicoIsDefinedIndica se il tipo di attributo personalizzato specificato è definito. (Esegue l'override di MemberInfo.IsDefined(Type, Boolean)).
Metodo pubblicoMakeGenericMethodSostituisce con gli elementi di una matrice di tipi i parametri di tipo della definizione di metodo generica corrente e restituisce un oggetto MethodInfo che rappresenta il metodo costruito risultante. (Ereditato da MethodInfo)
Metodo pubblicoToStringRestituisce la firma del metodo, rappresentata sotto forma di stringa. (Esegue l'override di Object.ToString()).
In alto

  NomeDescrizione
Metodo di estensione pubblicoGetCustomAttribute(Type)Sottoposto a overload. Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato. (Definito da CustomAttributeExtensions).
Metodo di estensione pubblicoGetCustomAttribute(Type, Boolean)Sottoposto a overload. Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro. (Definito da CustomAttributeExtensions).
Metodo di estensione pubblicoGetCustomAttribute<T>()Sottoposto a overload. Recupera una attributo personalizzato di un tipo specificato che viene applicato a un membro specificato. (Definito da CustomAttributeExtensions).
Metodo di estensione pubblicoGetCustomAttribute<T>(Boolean)Sottoposto a overload. Recupera un attributo personalizzato di un tipo specificato che viene applicato a un membro specificato e verifica facoltativamente i predecessori di tale membro. (Definito da CustomAttributeExtensions).
Metodo di estensione pubblicoGetCustomAttributes()Sottoposto a overload. Recupera una raccolta di attributi personalizzati che vengono applicati a un membro specificato. (Definito da CustomAttributeExtensions).
Metodo di estensione pubblicoGetCustomAttributes(Type)Sottoposto a overload. Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato. (Definito da CustomAttributeExtensions).
Metodo di estensione pubblicoGetCustomAttributes<T>()Sottoposto a overload. Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato. (Definito da CustomAttributeExtensions).
Metodo di estensione pubblicoGetCustomAttributes<T>(Boolean)Sottoposto a overload. Recupera una raccolta di attributi personalizzati di un tipo specificato che vengono applicati a un membro specificato e verifica facoltativamente i predecessori di tale membro. (Definito da CustomAttributeExtensions).
Metodo di estensione pubblicoGetRuntimeBaseDefinitionRecupera un oggetto che rappresenta il metodo specificato nella classe di base diretta o indiretta in cui il metodo è stato inizialmente dichiarato. (Definito da RuntimeReflectionExtensions).
Metodo di estensione pubblicoIsDefinedIndica se vengono applicati attributi personalizzati del tipo specificato a un membro specificato. (Definito da CustomAttributeExtensions).
In alto

  NomeDescrizione
Implementazione esplicita dell'interfacciaMetodo privato_MemberInfo.GetIDsOfNames Esegue il mapping di un set di nomi a un corrispondente set di identificatori di dispatch. (Ereditato da MemberInfo)
Implementazione esplicita dell'interfacciaMetodo privato_MemberInfo.GetTypeOttiene un oggetto Type che rappresenta la classe MemberInfo. (Ereditato da MemberInfo)
Implementazione esplicita dell'interfacciaMetodo privato_MemberInfo.GetTypeInfoRecupera le informazioni sul tipo relative a un oggetto che può quindi essere utilizzato per ottenere informazioni sul tipo relative a un'interfaccia. (Ereditato da MemberInfo)
Implementazione esplicita dell'interfacciaMetodo privato_MemberInfo.GetTypeInfoCount Recupera il numero di interfacce di informazioni sui tipi che un oggetto fornisce (0 o 1). (Ereditato da MemberInfo)
Implementazione esplicita dell'interfacciaMetodo privato_MemberInfo.Invoke Fornisce l'accesso alle proprietà ed ai metodi esposti da un oggetto. (Ereditato da MemberInfo)
Implementazione esplicita dell'interfacciaMetodo privato_MethodBase.GetIDsOfNames Esegue il mapping di un set di nomi a un corrispondente set di identificatori di dispatch. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaMetodo privato_MethodBase.GetTypePer una descrizione di questo membro, vedere _MethodBase.GetType. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaMetodo privato_MethodBase.GetTypeInfoRecupera le informazioni sul tipo relative a un oggetto che può quindi essere utilizzato per ottenere informazioni sul tipo relative a un'interfaccia. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaMetodo privato_MethodBase.GetTypeInfoCount Recupera il numero di interfacce di informazioni sui tipi che un oggetto fornisce (0 o 1). (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaMetodo privato_MethodBase.Invoke Fornisce l'accesso alle proprietà ed ai metodi esposti da un oggetto. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsAbstractPer una descrizione di questo membro, vedere _MethodBase.IsAbstract. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsAssemblyPer una descrizione di questo membro, vedere _MethodBase.IsAssembly. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsConstructorPer una descrizione di questo membro, vedere _MethodBase.IsConstructor. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsFamilyPer una descrizione di questo membro, vedere _MethodBase.IsFamily. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsFamilyAndAssemblyPer una descrizione di questo membro, vedere _MethodBase.IsFamilyAndAssembly. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsFamilyOrAssemblyPer una descrizione di questo membro, vedere _MethodBase.IsFamilyOrAssembly. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsFinalPer una descrizione di questo membro, vedere _MethodBase.IsFinal. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsHideBySigPer una descrizione di questo membro, vedere _MethodBase.IsHideBySig. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsPrivatePer una descrizione di questo membro, vedere _MethodBase.IsPrivate. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsPublicPer una descrizione di questo membro, vedere _MethodBase.IsPublic. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsSpecialNamePer una descrizione di questo membro, vedere _MethodBase.IsSpecialName. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsStaticPer una descrizione di questo membro, vedere _MethodBase.IsStatic. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaProprietà privata_MethodBase.IsVirtualPer una descrizione di questo membro, vedere _MethodBase.IsVirtual. (Ereditato da MethodBase)
Implementazione esplicita dell'interfacciaMetodo privato_MethodInfo.GetIDsOfNames Esegue il mapping di un set di nomi a un corrispondente set di identificatori di dispatch. (Ereditato da MethodInfo)
Implementazione esplicita dell'interfacciaMetodo privato_MethodInfo.GetTypeFornisce l'accesso al metodo GetType da COM. (Ereditato da MethodInfo)
Implementazione esplicita dell'interfacciaMetodo privato_MethodInfo.GetTypeInfo Recupera le informazioni sui tipi per un oggetto, che possono essere utilizzate per ottenere informazioni sul tipo per un'interfaccia. (Ereditato da MethodInfo)
Implementazione esplicita dell'interfacciaMetodo privato_MethodInfo.GetTypeInfoCount Recupera il numero di interfacce di informazioni sui tipi che un oggetto fornisce (0 o 1). (Ereditato da MethodInfo)
Implementazione esplicita dell'interfacciaMetodo privato_MethodInfo.Invoke Fornisce l'accesso alle proprietà ed ai metodi esposti da un oggetto. (Ereditato da MethodInfo)
In alto

È possibile utilizzare la classe DynamicMethod per generare ed eseguire un metodo in fase di esecuzione, senza l'esigenza di generare un assembly dinamico e un tipo dinamico per contenere il metodo. Il codice eseguibile creato dal compilatore JIT (Just-In-Time) viene recuperato quando si recupera l'oggetto DynamicMethod. I metodi dinamici rappresentano il modo più efficace per generare ed eseguire codice di dimensioni limitate.

Un metodo dinamico può essere contenuto anonimamente o può essere associato logicamente a un modulo o a un tipo.

  • Se il metodo dinamico è contenuto anonimamente, si trova in un assembly fornito dal sistema e pertanto è isolato dall'altro codice. Per impostazione predefinita, non ha accesso a un qualsiasi dato non pubblico. Un metodo dinamico contenuto anonimamente può avere una limitata possibilità di ignorare i controlli di visibilità del compilatore JIT, se gli è stato concesso un oggetto ReflectionPermission con il flag ReflectionPermissionFlag.RestrictedMemberAccess. Il livello di attendibilità dell'assembly ai cui membri non pubblici accede il metodo dinamico deve essere uguale, o un sottoinsieme, del livello di attendibilità dello stack di chiamate che ha generato il metodo dinamico. Per ulteriori informazioni sui metodi dinamici contenuti anonimamente, vedere Procedura dettagliata: creazione di codice in scenari di attendibilità parziale.

  • Se il metodo dinamico viene associato a un modulo specificato, il metodo dinamico risulta globale per tale modulo. Può accedere a tutti i tipi nel modulo e a tutti i membri internal (Friend in Visual Basic) dei tipi. È possibile associare un metodo dinamico a qualsiasi modulo, indipendentemente dal fatto che il modulo sia stato creato, purché possa venire soddisfatta una richiesta per ReflectionPermission con il flag RestrictedMemberAccess, dallo stack di chiamate che include il codice. Se il flag ReflectionPermissionFlag.MemberAccess è incluso nell'autorizzazione, il metodo dinamico può ignorare i controlli di visibilità del compilatore JIT e accedere ai dati privati di tutti i tipi dichiarati all'interno del modulo o in qualsiasi altro modulo in qualsiasi assembly.

    NotaNota

    Quando si specifica il modulo al quale è associato un metodo dinamico, tale modulo non deve essere all'interno dell'assembly fornito dal sistema utilizzato per l'hosting anonimo.

  • Se il metodo dinamico è associato a un tipo specificato, ha accesso a tutti i membri privati del tipo, indipendentemente dal livello di accesso Inoltre possono venire ignorati i controlli di visibilità del compilatore JIT. In tal modo il metodo dinamico accede ai dati privati di altri tipi dichiarati nello stesso o in qualsiasi altro modulo. È possibile associare un metodo dinamico a qualsiasi tipo, ma il codice deve disporre di ReflectionPermission con entrambi i flag RestrictedMemberAccess e MemberAccess.

Nella tabella seguente vengono descritti tipi e membri accessibili da un metodo dinamico contenuto anonimamente, con e senza controlli di visibilità di JIT, a seconda se dispone o meno di ReflectionPermission con il flag RestrictedMemberAccess.

 

Senza RestrictedMemberAccess

Con RestrictedMemberAccess

Senza ignorare i controlli di visibilità di JIT

Membri pubblici di tipi pubblici in qualsiasi assembly.

Membri pubblici di tipi pubblici in qualsiasi assembly.

Ignorando i controlli di visibilità di JIT, con restrizioni

Membri pubblici di tipi pubblici in qualsiasi assembly.

Tutti i membri di qualsiasi tipo, solo negli assembly i cui livelli di attendibilità sono uguali o inferiori al livello di attendibilità dell'assembly che ha generato il metodo dinamico.

NotaNota

A partire da .NET Framework 2.0 Service Pack 1, la creazione di codice richiedeva ReflectionPermission con il flag ReflectionPermissionFlag.ReflectionEmit. Questa autorizzazione è inclusa per impostazione predefinita nei set di autorizzazioni denominati FullTrust e LocalIntranet, ma non nel set di autorizzazioni Internet. Di conseguenza nelle versioni precedenti di .NET Framework una libreria può essere utilizzata con autorizzazioni Internet solo se è presente un attributo SecurityCriticalAttribute ed esegue un oggetto Assert per ReflectionEmit. Tali librerie richiedono un'accurata revisione della sicurezza perché eventuali errori nel codice potrebbero comportare problemi di sicurezza. .NET Framework 2.0 SP1 consente che il codice venga generato in scenari di attendibilità parziale senza emettere alcuna richiesta di sicurezza, perché la generazione di codice non è, per sua natura, un'operazione privilegiata. Ovvero, il codice generato non ha più autorizzazioni dell'assembly che lo genera. Questo consente alle librerie che generano il codice di essere SecurityTransparent ed elimina la necessità di utilizzare un'asserzione di ReflectionEmit, semplificando l'attività di scrittura di una libreria protetta. Per utilizzare questa funzione, l'applicazione deve essere indirizzata a .NET Framework 3.5 o successiva.

Nella tabella seguenti vengono descritti i tipi e i membri accessibili a un metodo dinamico associato con un modulo o con un tipo in un modulo.

 

Associato al modulo

Associato al tipo

Senza ignorare i controlli di visibilità di JIT

Membri pubblici e interni di tipi pubblici, interni e privati nel modulo.

Membri pubblici di tipi pubblici in qualsiasi assembly.

Tutti i membri del tipo associato. Membri pubblici e interni di qualsiasi altro tipo nel modulo.

Membri pubblici di tipi pubblici in qualsiasi assembly.

Ignorando i controlli di visibilità di JIT

Tutti i membri di qualsiasi tipo in qualsiasi assembly.

Tutti i membri di qualsiasi tipo in qualsiasi assembly.

Un metodo dinamico associato a un modulo dispone dell'autorizzazione di tale modulo. Un metodo dinamico associato a un tipo dispone dell'autorizzazione del modulo che contiene tale tipo.

Non è necessario assegnare nomi ai metodi dinamici e ai relativi parametri, ma è possibile specificare nomi per il supporto del debug. Gli attributi personalizzati non sono supportati sui metodi dinamici o nei relativi parametri.

Sebbene i metodi dinamici siano metodi static (metodi Shared in Visual Basic), le regole relaxed per l'associazione di delegati introdotta in .NET Framework 2.0 consentono l'associazione di un metodo dinamico a un oggetto affinché funga da metodo di istanza quando viene chiamato mediante l'istanza del delegato. Un esempio di questa procedura è fornito per l'overload di metodi CreateDelegate(Type, Object).

NotaNota

In .NET Framework 2.0, i metodi dinamici non supportano informazioni sui simboli, ovvero nomi della variabile locali e mapping del numero di riga. Questo limite potrebbe venire rimosso dalle versioni future. È possibile utilizzare AssemblyBuilder durante lo sviluppo per semplificare il debug del linguaggio MSIL (Microsoft Intermediate Language) generato e quindi passare ai metodi dinamici durante la distribuzione finale, perché le chiamate ILGenerator sono le stesse in entrambi casi.

Verifica

Nell'elenco riportato di seguito vengono riepilogate le condizioni in base alle quali i metodi dinamici possono contenere codice non verificabile. Ad esempio, un metodo dinamico non è verificabile se la relativa proprietà InitLocals viene impostata su false.

  • Anche un metodo dinamico associato a un assembly critico per la sicurezza è critico per la sicurezza e può ignorare la verifica. Ad esempio, un assembly senza attributi di sicurezza che viene eseguito come applicazione desktop viene trattato come critico per la sicurezza dal runtime. Se si associa un metodo dinamico all'assembly, il metodo dinamico può contenere codice non verificabile.

  • Se un metodo dinamico che contiene del codice non verificabile è associato a un assembly che dispone di trasparenza di livello 1, il compilatore JIT (JIT) inietta una richiesta di sicurezza. La richiesta va a buon fine soltanto se il metodo dinamico viene eseguito da codice completamente attendibile. Vedere Codice SecurityTransparent, livello 1.

  • Se un metodo dinamico che contiene del codice non verificabile è associato a un assembly che dispone di trasparenza di livello 2 (come mscorlib.dll), invece di effettuare una richiesta di sicurezza genera un'eccezione (iniettata dal compilatore JIT). Vedere Codice SecurityTransparent, livello 2.

  • Un metodo dinamico ospitato anonimamente che contiene codice non verificabile genera sempre un'eccezione. Non può mai ignorare la verifica, anche se viene creato ed eseguito da codice completamente attendibile.

L'eccezione generata per un codice non verificabile varia a seconda della modalità tramite cui il metodo dinamico viene richiamato. Se si richiama un metodo dinamico tramite un delegato restituito dal metodo CreateDelegate, viene generato un oggetto VerificationException. Se si richiama il metodo dinamico tramite il metodo Invoke, viene generato un oggetto TargetInvocationException con un oggetto VerificationException interno.

Nell'esempio di codice riportato di seguito viene creato un metodo dinamico che accetta due parametri. In questo esempio viene creato il corpo di una funzione semplice che consente la visualizzazione del primo parametro sulla console, mentre il secondo parametro viene utilizzato come valore restituito del metodo. Nell'esempio, viene completato il metodo mediante la creazione di un delegato, viene chiamato il delegato con parametri diversi e infine viene chiamato il metodo dinamico mediante il metodo Invoke.


using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;

public class Test
{
    // Declare a delegate type that can be used to execute the completed
    // dynamic method. 
    private delegate int HelloDelegate(string msg, int ret);

    public static void Main()
    {
        // Create an array that specifies the types of the parameters
        // of the dynamic method. This dynamic method has a String
        // parameter and an Integer parameter.
        Type[] helloArgs = {typeof(string), typeof(int)};

        // Create a dynamic method with the name "Hello", a return type
        // of Integer, and two parameters whose types are specified by
        // the array helloArgs. Create the method in the module that
        // defines the String class.
        DynamicMethod hello = new DynamicMethod("Hello", 
            typeof(int), 
            helloArgs, 
            typeof(string).Module);

        // Create an array that specifies the parameter types of the
        // overload of Console.WriteLine to be used in Hello.
        Type[] writeStringArgs = {typeof(string)};
        // Get the overload of Console.WriteLine that has one
        // String parameter.
        MethodInfo writeString = typeof(Console).GetMethod("WriteLine", 
            writeStringArgs);

        // Get an ILGenerator and emit a body for the dynamic method,
        // using a stream size larger than the IL that will be
        // emitted.
        ILGenerator il = hello.GetILGenerator(256);
        // Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0);
        // Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, null);
        // The Hello method returns the value of the second argument;
        // to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ret);

        // Add parameter information to the dynamic method. (This is not
        // necessary, but can be useful for debugging.) For each parameter,
        // identified by position, supply the parameter attributes and a 
        // parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message");
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn");

        // Create a delegate that represents the dynamic method. This
        // action completes the method. Any further attempts to
        // change the method are ignored.
        HelloDelegate hi = 
            (HelloDelegate) hello.CreateDelegate(typeof(HelloDelegate));

        // Use the delegate to execute the dynamic method.
        Console.WriteLine("\r\nUse the delegate to execute the dynamic method:");
        int retval = hi("\r\nHello, World!", 42);
        Console.WriteLine("Invoking delegate hi(\"Hello, World!\", 42) returned: " + retval);

        // Execute it again, with different arguments.
        retval = hi("\r\nHi, Mom!", 5280);
        Console.WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280) returned: " + retval);

        Console.WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
        // Create an array of arguments to use with the Invoke method.
        object[] invokeArgs = {"\r\nHello, World!", 42};
        // Invoke the dynamic method using the arguments. This is much
        // slower than using the delegate, because you must create an
        // array to contain the arguments, and value-type arguments
        // must be boxed.
        object objRet = hello.Invoke(null, BindingFlags.ExactBinding, null, invokeArgs, new CultureInfo("en-us"));
        Console.WriteLine("hello.Invoke returned: " + objRet);

        Console.WriteLine("\r\n ----- Display information about the dynamic method -----");
        // Display MethodAttributes for the dynamic method, set when 
        // the dynamic method was created.
        Console.WriteLine("\r\nMethod Attributes: {0}", hello.Attributes);

        // Display the calling convention of the dynamic method, set when the 
        // dynamic method was created.
        Console.WriteLine("\r\nCalling convention: {0}", hello.CallingConvention);

        // Display the declaring type, which is always null for dynamic
        // methods.
        if (hello.DeclaringType == null)
        {
            Console.WriteLine("\r\nDeclaringType is always null for dynamic methods.");
        }
        else
        {
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType);
        }

        // Display the default value for InitLocals.
        if (hello.InitLocals)
        {
            Console.Write("\r\nThis method contains verifiable code.");
        }
        else
        {
            Console.Write("\r\nThis method contains unverifiable code.");
        }
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals);

        // Display the module specified when the dynamic method was created.
        Console.WriteLine("\r\nModule: {0}", hello.Module);

        // Display the name specified when the dynamic method was created.
        // Note that the name can be blank.
        Console.WriteLine("\r\nName: {0}", hello.Name);

        // For dynamic methods, the reflected type is always null.
        if (hello.ReflectedType == null)
        {
            Console.WriteLine("\r\nReflectedType is null.");
        }
        else
        {
            Console.WriteLine("\r\nReflectedType: {0}", hello.ReflectedType);
        }

        if (hello.ReturnParameter == null)
        {
            Console.WriteLine("\r\nMethod has no return parameter.");
        }
        else
        {
            Console.WriteLine("\r\nReturn parameter: {0}", hello.ReturnParameter);
        }

        // If the method has no return type, ReturnType is System.Void.
        Console.WriteLine("\r\nReturn type: {0}", hello.ReturnType);

        // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        // that can be used to enumerate the custom attributes of the
        // return value. At present, there is no way to set such custom
        // attributes, so the list is empty.
        if (hello.ReturnType == typeof(void))
        {
            Console.WriteLine("The method has no return type.");
        }
        else
        {
            ICustomAttributeProvider caProvider = hello.ReturnTypeCustomAttributes;
            object[] returnAttributes = caProvider.GetCustomAttributes(true);
            if (returnAttributes.Length == 0)
            {
                Console.WriteLine("\r\nThe return type has no custom attributes.");
            }
            else
            {
                Console.WriteLine("\r\nThe return type has the following custom attributes:");
                foreach( object attr in returnAttributes )
                {
                    Console.WriteLine("\t{0}", attr.ToString());
                }
            }
        }

        Console.WriteLine("\r\nToString: {0}", hello.ToString());

        // Display parameter information.
        ParameterInfo[] parameters = hello.GetParameters();
        Console.WriteLine("\r\nParameters: name, type, ParameterAttributes");
        foreach( ParameterInfo p in parameters )
        {
            Console.WriteLine("\t{0}, {1}, {2}", 
                p.Name, p.ParameterType, p.Attributes);
        }
    }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:

Hello, World!
Invoking delegate hi("Hello, World!", 42) returned: 42

Hi, Mom!
Invoking delegate hi("Hi, Mom!", 5280) returned: 5280

Use the Invoke method to execute the dynamic method:

Hello, World!
hello.Invoke returned: 42

 ----- Display information about the dynamic method -----

Method Attributes: PrivateScope, Public, Static

Calling convention: Standard

DeclaringType is always null for dynamic methods.

This method contains verifiable code. (InitLocals = True)

Module: CommonLanguageRuntimeLibrary

Name: Hello

ReflectedType is null.

Method has no return parameter.

Return type: System.Int32

The return type has no custom attributes.

ToString: Int32 Hello(System.String, Int32)

Parameters: name, type, ParameterAttributes
        message, System.String, In
        valueToReturn, System.Int32, In
 */


.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft