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 manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Strutture (F#)

Una struttura è un tipo di oggetto compatto che può essere più efficiente rispetto a una classe per tipi che hanno una piccola quantità di dati e comportamento semplice.

[ attributes ] type [accessibility-modifier] type-name =    struct       type-definition-elements    end // or [ attributes ] [<StructAttribute>] type [accessibility-modifier] type-name =    type-definition-elements

Le strutture sono tipi di valore, archiviate direttamente sullo stack o, quando vengono usate come campi o elementi di matrice, inline nell'elemento padre. A differenza di record e classi, le strutture hanno una semantica pass-by-value. Ciò significa che sono utili principalmente per piccole aggregazioni di dati accessibili e copiati di frequente.

Nella sintassi precedente sono illustrate due forme. La prima non è la sintassi leggera, ma viene comunque usata frequentemente perché, quando si usano la parole chiave struct e endStructAttribute, è possibile omettere l'attributo , che viene visualizzato nella seconda forma. È possibile abbreviare StructAttribute in Struct.

Il type-definition-elements nella sintassi precedente rappresenta definizioni e dichiarazioni di membri. Le strutture possono disporre di costruttori e campi modificabili e non modificabili e possono dichiarare i membri e le implementazioni dell'interfaccia. Per altre informazioni, vedere Membri (F#).

Le strutture non possono partecipare all'ereditarietà, non possono contenere associazioni let o do e non possono contenere in modo ricorsivo campi del proprio tipo (nonostante possano contenere celle di riferimento che facciano riferimento al proprio tipo).

Poiché le strutture non consentono associazioni let, è necessario dichiarare i campi nelle strutture usando la parola chiave val. La parola chiave val definisce un campo e il relativo tipo, ma non consente l'inizializzazione. Al contrario, le dichiarazioni val sono inizializzate su zero o null. Per questo motivo, le strutture che hanno un costruttore implicito (ovvero, i parametri forniti immediatamente dopo il nome della struttura nella dichiarazione) richiedono di annotare le dichiarazioni val con l'attributo DefaultValue. Le strutture che hanno un costruttore definito supportano comunque l'inizializzazione su zero. Quindi, l'attributo DefaultValue è una dichiarazione che tale valore zero è valido per il campo. I costruttori impliciti per le strutture non eseguono alcuna azione perché le associazioni let e do non sono consentite per il tipo, ma i valori di parametro di costruttore implicito passati sono disponibili come campi privati.

I costruttori espliciti potrebbero comportare l'inizializzazione dei valori di campo. Quando si ha una struttura con un costruttore esplicito, è comunque supportata l'inizializzazione su zero. Tuttavia, non usare l'attributo DefaultValue sulle dichiarazioni val perché è in conflitto con il costruttore esplicito. Per altre informazioni sulle dichiarazioni val, vedere Campi espliciti: parola chiave val (F#).

Gli attributi e modificatori di accessibilità sono consentiti nelle strutture e seguono le stesse regole per gli altri tipi. Per altre informazioni, vedere Attributi (F#) e Controllo di accesso (F#).

Gli esempi di codice seguenti illustrano le definizioni delle strutture.

// In Point3D, three immutable values are defined. 
// x, y, and z will be initialized to 0.0. 
type Point3D =
   struct 
      val x: float
      val y: float
      val z: float
   end 

// In Point2D, two immutable values are defined. 
// Point2D has an explicit constructor. 
// You can create zero-initialized instances of Point2D, or you can 
// pass in arguments to initialize the values. 
type Point2D =
   struct 
      val X: float
      val Y: float
      new(x: float, y: float) = { X = x; Y = y }
   end

Aggiunte alla community

Mostra:
© 2015 Microsoft