Classi parziali (C++/CX)

Articolo
08/03/2024

Una classe parziale è un costrutto che supporta scenari in cui tu effettui la modifica di una parte di una definizione di classe e il software che genera codice automaticamente, ad esempio la finestra di progettazione XAML, modifica il codice nella stessa classe. Utilizzando una classe parziale, puoi impedire alla finestra di progettazione di sovrascrivere il tuo codice. In un progetto di Visual Studio, il modificatore partial viene applicato automaticamente al file generato.

Sintassi

Per definire una classe parziale, utilizza la parola chiave partial immediatamente prima della classe di chiave della definizione di classe normale. Una parola chiave come partial ref class è una parola chiave contestuale contenente spazi vuoti. Le definizioni parziali sono supportate nei seguenti costrutti.

class oppure struct
ref class oppure ref struct
value class oppure value struct
enum oppure enum class
ref interface, interface class, interface struct o __interface
union

In questo esempio viene illustrato un oggetto ref classparziale.

partial ref class MyClass {/* ... */};

Contenuto

Se la parola chiave partial è stata omessa, una definizione di classe parziale può contenere qualsiasi elemento che può essere incluso in una definizione di classe completa. Ciò significa che, con un'unica eccezione, una definizione di classe parziale può includere qualsiasi costrutto valido come le classi di base, i membri dati, le funzioni membro, le enumerazioni, le dichiarazioni Friend e gli attributi. Sono inoltre consentite le definizioni inline dei membri dati statici.

L'unica eccezione è l'accessibilità della classe. Ad esempio, l'istruzione public partial class MyInvalidClass {/* ... */}; non è corretta. Gli identificatori di accesso utilizzati in una definizione di classe parziale per MyInvalidClass non influiscono sull'accessibilità predefinita in una successiva definizione di classe parziale o completa per MyInvalidClass.

Nel frammento di codice riportato di seguito viene illustrata l'impostazione dell'accessibilità. Nella prima classe parziale, Method1 è pubblico perché la relativa accessibilità è pubblica. Nella seconda classe parziale, Method2 è privato perché l'accessibilità della classe predefinita è privata.

partial ref class N 
{
public:
    int Method1(); // Method1 is public.

};
ref class N 
{   
    void Method2(); // Method2 is private.
};

Dichiarazione

Una definizione parziale di una classe, MyClass ad esempio, è solo una dichiarazione di MyClass. Vale a dire, introduce solo il nome MyClass. MyClass non può essere usato in modo che richieda una definizione di classe, ad esempio conoscendo le dimensioni di MyClass o usando una base o un membro di MyClass. MyClass viene considerato definito solo quando il compilatore rileva una definizione non parziale di MyClass.

Nell'esempio seguente viene illustrato il comportamento dichiarativo di una classe parziale. Dopo la dichiarazione n. 1, MyClass può essere usato come se fosse scritto come dichiarazione di inoltro, ref class MyClass;. La dichiarazione n. 2 equivale alla dichiarazione n. 1. La dichiarazione n. 3 è valida perché è una dichiarazione forward a una classe. La dichiarazione n.4 non è valida perché

MyClass non è completamente definito.

La dichiarazione 5 non usa la partial parola chiave e la dichiarazione definisce MyClasscompletamente . Pertanto, la dichiarazione #6 è valida.

// Declaration #1
partial ref class MyClass {};

// Declaration #2
partial ref class MyClass;

// Declaration #3
MyClass^ pMc; // OK, forward declaration.

// Declaration #4
MyClass mc; // Error, MyClass is not defined.

// Declaration #5
ref class MyClass { };

// Declaration #6
MyClass mc; // OK, now MyClass is defined.

Numero e ordine

Per ogni definizione completa di una classe possono esservi zero o più definizioni di classe parziali.

Ogni definizione di classe parziale deve precedere a livello lessicale la definizione completa della stessa classe, ma non ne deve precedere le dichiarazioni con prototipo. Se non è presente alcuna definizione completa della classe, le dichiarazioni di classe parziali possono solo essere dichiarazioni con prototipo.

Tutte le chiavi-classe come class e struct devono trovare corrispondenza. Ad esempio, non è corretto scrivere il codice partial class X {}; struct X {};.

Nell'esempio seguente vengono illustrati il numero e l'ordine. L'ultima dichiarazione parziale ha esito negativo perché la classe è già definita.

ref class MyClass;  // OK
partial ref class MyClass{};  //OK
partial ref class MyClass{}; // OK
partial ref class MyClass{}; // OK
ref class MyClass{}; // OK
partial ref class MyClass{}; // C3971, partial definition cannot appear after full definition.

Definizione completa

Nel punto della definizione completa della classe X, si ha lo stesso comportamento come se nella definizione di X fossero dichiarati tutte le classi di base, i membri e così via, nell'ordine in cui sono stati rilevati e definiti nelle classi parziali. Il contenuto delle classi parziali viene considerato come se fosse scritto nel punto della definizione completa della classe e la ricerca del nome e altre regole del linguaggio vengono applicate nel punto della definizione completa della classe come se il contenuto delle classi parziali fosse stato scritto sul posto.

I due esempi di codice seguenti hanno significato e risultati identici. A differenza del secondo esempio, nel primo esempio viene utilizzata una classe parziale.

ref class Base1 { public: property int m_num; int GetNumBase();};
interface class Base2 { int GetNum(); };
interface class Base3{ int GetNum2();};

partial ref class N : public Base1 
{
public:
    /*...*/

};

partial ref class N : public Base2
{
public:
    virtual int GetNum();
    // OK, as long as OtherClass is
    //declared before the full definition of N
    void Method2( OtherClass^ oc );       
};

ref class OtherClass;

ref class N : public Base3
{    
public:
    virtual int GetNum2();
};

ref class OtherClass;
ref class N : public Base1, public Base2, public Base3 
{
public:    
    virtual int GetNum();
    virtual int GetNum2();
private:    
    void Method2(OtherClass^ oc);

};

Modelli

Una classe parziale non può essere un modello.

Restrizioni

Una classe parziale non può estendersi oltre un'unità di conversione.

La parola chiave partial è supportata solo in combinazione con la parola chiave ref class o value class .

Esempi

Nell'esempio seguente la definizione della classe Address si estende a due file di codice. Il file Address.details.h viene modificato dalla finestra di progettazione e tu devi modificare Address.h. La parola chiave partial viene utilizzata solo nella definizione della classe nel primo file.

// Address.Details.h
partial ref class Address
{
private:
  Platform::String^ street_;
  Platform::String^ city_;
  Platform::String^ state_;
  Platform::String^ zip_;
  Platform::String^ country_;
  void ValidateAddress(bool normalize = true);
};

// Address.h
#include "Address.details.h"
ref class Address
{
public:
  Address(Platform::String^ street, Platform::String^ city, Platform::String^ state,
    Platform::String^ zip, Platform::String^ country);
  property Platform::String^ Street { Platform::String^ get(); }
  property Platform::String^ City { Platform::String^ get(); }
  property Platform::String^ State { Platform::String^ get(); }
  property Platform::String^ Zip { Platform::String^ get(); }
  property Platform::String^ Country { Platform::String^ get(); }
};

Vedi anche

Sistema di tipi
Riferimenti al linguaggio C++/CX
Riferimenti a spazi dei nomi

Condividi tramite