Panoramica degli attributi (Visual Basic)

  • Articolo

Gli attributi offrono un metodo efficace per l'associazione di metadati o informazioni dichiarative con il codice (assembly, tipi, metodi, proprietà e così via). Dopo aver associato un attributo a un'entità di programma, in fase di esecuzione è possibile eseguire una query su tale attributo usando una tecnica denominata reflection. Per altre informazioni, vedere Reflection (Visual Basic).

Di seguito sono riportate le proprietà degli attributi:

  • Gli attributi aggiungono metadati al programma. I metadati sono informazioni relative ai tipi definiti in un programma. Tutti gli assembly .NET contengono un set specificato di metadati che descrive i tipi e membri dei tipi definiti nell'assembly. È possibile aggiungere attributi personalizzati per specificare altre informazioni eventualmente necessarie. Per altre informazioni, vedere Creazione di attributi personalizzati (Visual Basic).

  • È possibile applicare uno o più attributi a interi assembly, moduli o elementi di programma di minori dimensioni, ad esempio classi e proprietà.

  • Gli attributi possono accettare argomenti nello stesso modo dei metodi e delle proprietà.

  • Il programma può esaminare i propri metadati oppure i metadati di un altro programma tramite reflection. Per altre informazioni, vedere Accesso agli attributi tramite reflection (Visual Basic).

Uso degli attributi

È possibile usare attributi nella maggior parte delle dichiarazioni, anche se la validità di un attributo specifico può essere limitata ad alcuni tipi di dichiarazione. In Visual Basic, un attributo è racchiuso tra parentesi angolari (<>). e deve apparire immediatamente prima dell'elemento a cui viene applicato, sulla stessa riga.

Nell'esempio seguente l'attributo SerializableAttribute viene usato per applicare una caratteristica specifica a una classe:

<System.Serializable()> Public Class SampleClass
    ' Objects of this type can be serialized.
End Class

Un metodo con l'attributo DllImportAttribute è dichiarato come segue:

Imports System.Runtime.InteropServices

<System.Runtime.InteropServices.DllImport("user32.dll")>
Sub SampleMethod()
End Sub

In una dichiarazione è possibile inserire più attributi:

Imports System.Runtime.InteropServices

Sub MethodA(<[In](), Out()> ByVal x As Double)
End Sub
Sub MethodB(<Out(), [In]()> ByVal x As Double)
End Sub

Alcuni attributi possono essere specificati più volte per una stessa entità. Un esempio di attributo multiuso è ConditionalAttribute:

<Conditional("DEBUG"), Conditional("TEST1")>
Sub TraceMethod()
End Sub

Nota

Per convenzione tutti i nomi di attributo terminano con la parola "Attribute", in modo che sia possibile distinguerli da altri elementi di .NET Framework. Tuttavia, quando gli attributi vengono usati nel codice, non è necessario specificare il suffisso Attribute. Ad esempio, [DllImport] è equivalente a [DllImportAttribute], mentre DllImportAttribute è il nome effettivo dell'attributo in .NET Framework.

Parametri degli attributi

Diversi attributi dispongono di parametri, che possono essere posizionali, senza nome o denominati. I parametri posizionali devono essere specificati in un determinato ordine e non possono essere omessi. I parametri denominati sono invece facoltativi e possono essere specificati in qualsiasi ordine. I parametri posizionali vengono specificati per primi. I tre attributi seguenti, ad esempio, sono equivalenti:

<DllImport("user32.dll")>
<DllImport("user32.dll", SetLastError:=False, ExactSpelling:=False)>
<DllImport("user32.dll", ExactSpelling:=False, SetLastError:=False)>

Il primo parametro, ovvero il nome della DLL, è posizionale ed è sempre specificato per primo. Gli altri parametri sono denominati. In questo caso, entrambi i parametri denominati sono impostati automaticamente su false e possono quindi essere omessi. Per informazioni sui valori predefiniti dei parametri, fare riferimento alla documentazione di ciascun attributo.

Destinazioni degli attributi

La destinazione di un attributo è l'entità a cui tale attributo viene applicato. Un attributo, ad esempio, può essere applicato a una classe, a un metodo particolare o a un intero assembly. Per impostazione predefinita, un attributo viene applicato all'elemento che lo segue. È tuttavia possibile identificare in modo esplicito, ad esempio, se un attributo viene applicato a un metodo, al relativo parametro o al relativo valore restituito.

Per identificare in modo esplicito la destinazione di un attributo, usare la sintassi seguente:

<target : attribute-list>

Nella tabella seguente sono elencati i possibili valori di target.

Valore di destinazione Si applica a
assembly Intero assembly
module Modulo dell'assembly corrente (diverso da un modulo di Visual Basic)

Nell'esempio seguente viene illustrato come applicare attributi ad assembly e moduli. Per altre informazioni, vedere Attributi comuni (Visual Basic).

Imports System.Reflection
<Assembly: AssemblyTitleAttribute("Production assembly 4"),
Module: CLSCompliant(True)>

Usi comuni degli attributi

Di seguito vengono elencati alcuni degli usi comuni degli attributi nel codice:

  • Contrassegno dei metodi mediante l'attributo WebMethod nei servizi Web per indicare che è possibile chiamare il metodo tramite il protocollo SOAP. Per altre informazioni, vedere WebMethodAttribute.

  • Descrizione della procedura di marshalling dei parametri del metodo durante l'interazione con il codice nativo. Per altre informazioni, vedere MarshalAsAttribute.

  • Descrizione delle proprietà COM per classi, metodi e interfacce.

  • Chiamata al codice non gestito che usa la classe DllImportAttribute.

  • Descrizione dell'assembly con indicazione di titolo, versione, descrizione o marchio.

  • Descrizione dei membri della classe da serializzare per la persistenza.

  • Descrizione della procedura di mapping tra membri di una classe e nodi XML per la serializzazione XML.

  • Descrizione dei requisiti di sicurezza per i metodi.

  • Definizione delle caratteristiche usate per garantire la sicurezza.

  • Controllo delle ottimizzazioni tramite il compilatore JIT (Just-In-Time), in modo da garantire un semplice debug del codice.

  • Recupero di informazioni relative al chiamante di un metodo.

Per altre informazioni, vedere:

Vedi anche