Classi e metodi parziali (Guida per programmatori C#)Partial Classes and Methods (C# Programming Guide)

È possibile suddividere la definizione di una classe di uno struct, di un'interfaccia o di un metodo tra due o più file di origine.It is possible to split the definition of a class, a struct, an interface or a method over two or more source files. Ogni file di origine contiene una sezione della definizione di tipo o metodo e tutte le parti vengono combinate al momento della compilazione dell'applicazione.Each source file contains a section of the type or method definition, and all parts are combined when the application is compiled.

Classi parzialiPartial Classes

La suddivisione della definizione di una classe è consigliabile in diverse situazioni:There are several situations when splitting a class definition is desirable:

  • Quando si lavora su progetti di grandi dimensioni, la distribuzione di una classe in file distinti ne consente l'uso simultaneo da parte di più programmatori.When working on large projects, spreading a class over separate files enables multiple programmers to work on it at the same time.

  • Quando si usa un'origine generata automaticamente, è possibile aggiungere codice alla classe senza dover ricreare il file di origine.When working with automatically generated source, code can be added to the class without having to recreate the source file. Visual Studio usa questo approccio per la creazione di Windows Form, codice wrapper di servizi Web e così via.Visual Studio uses this approach when it creates Windows Forms, Web service wrapper code, and so on. È possibile creare codice che usa queste classi senza dover modificare il file creato da Visual Studio.You can create code that uses these classes without having to modify the file created by Visual Studio.

  • Per suddividere la definizione di una classe, usare il modificatore della parola chiave partial, come illustrato di seguito:To split a class definition, use the partial keyword modifier, as shown here:

    public partial class Employee
    {
        public void DoWork()
        {
        }
    }
    
    public partial class Employee
    {
        public void GoToLunch()
        {
        }
    }
    

La parola chiave partial indica che è possibile definire altre parti della classe, dello struct o dell'interfaccia nello spazio dei nomi.The partial keyword indicates that other parts of the class, struct, or interface can be defined in the namespace. Tutte le parti devono usare la parola chiave partialAll the parts must use the partial keyword. ed essere disponibili in fase di compilazione in modo da formare il tipo finale.All the parts must be available at compile time to form the final type. Tutte le parti devono anche avere lo stesso livello di accessibilità, ad esempio public, private e così via.All the parts must have the same accessibility, such as public, private, and so on.

Se una parte viene dichiarata come astratta, l'intero tipo verrà considerato astratto.If any part is declared abstract, then the whole type is considered abstract. Se una parte viene dichiarata come sealed, l'intero tipo verrà considerato sealed.If any part is declared sealed, then the whole type is considered sealed. Se una parte dichiara un tipo base, l'intero tipo eredita la classe.If any part declares a base type, then the whole type inherits that class.

Tutte le parti che specificano una classe base devono concordare, tuttavia le parti che omettono una classe base ereditano comunque il tipo base.All the parts that specify a base class must agree, but parts that omit a base class still inherit the base type. Le parti possono specificare interfacce di base differenti e il tipo finale implementa tutte le interfacce elencate da tutte le dichiarazioni parziali.Parts can specify different base interfaces, and the final type implements all the interfaces listed by all the partial declarations. Tutti i membri di classe, struttura o interfaccia dichiarati in una definizione parziale sono disponibili per tutte le altre parti.Any class, struct, or interface members declared in a partial definition are available to all the other parts. Il tipo finale rappresenta la combinazione di tutte le parti in fase di compilazione.The final type is the combination of all the parts at compile time.

Nota

Il modificatore partial non è disponibile per le dichiarazioni di delegato o di enumerazione.The partial modifier is not available on delegate or enumeration declarations.

L'esempio seguente illustra che i tipi annidati possono essere parziali, anche se non lo è il tipo all'interno del quale sono annidati.The following example shows that nested types can be partial, even if the type they are nested within is not partial itself.

class Container
{
    partial class Nested
    {
        void Test() { }
    }
    partial class Nested
    {
        void Test2() { }
    }
}

In fase di compilazione gli attributi delle definizioni di tipi parziali vengono uniti.At compile time, attributes of partial-type definitions are merged. Si considerino ad esempio le dichiarazioni seguenti:For example, consider the following declarations:

[SerializableAttribute]
partial class Moon { }

[ObsoleteAttribute]
partial class Moon { }

Sono equivalenti alle dichiarazioni seguenti:They are equivalent to the following declarations:

[SerializableAttribute]
[ObsoleteAttribute]
class Moon { }

Gli elementi seguenti vengono uniti da tutte le definizioni di tipi parziali:The following are merged from all the partial-type definitions:

  • XML (commenti)XML comments

  • interfacceinterfaces

  • attributi di parametri di tipo genericogeneric-type parameter attributes

  • attributi classclass attributes

  • Membri dimembers

Si considerino ad esempio le dichiarazioni seguenti:For example, consider the following declarations:

partial class Earth : Planet, IRotate { }
partial class Earth : IRevolve { }

Sono equivalenti alle dichiarazioni seguenti:They are equivalent to the following declarations:

class Earth : Planet, IRotate, IRevolve { }

RestrizioniRestrictions

Quando si usano le definizioni parziali di classi è necessario rispettare diverse regole:There are several rules to follow when you are working with partial class definitions:

  • Tutte le definizioni di tipi parziali destinate a essere parti dello stesso tipo devono essere modificate con partial.All partial-type definitions meant to be parts of the same type must be modified with partial. Ad esempio, le dichiarazioni di classe seguenti generano un errore:For example, the following class declarations generate an error:

    public partial class A { }
    //public class A { }  // Error, must also be marked partial
    
  • Il modificatore partial può essere specificato solo prima delle parole chiave class, struct o interface.The partial modifier can only appear immediately before the keywords class, struct, or interface.

  • I tipi parziali annidati sono consentiti nelle definizioni di tipi parziali, come illustrato nell'esempio seguente:Nested partial types are allowed in partial-type definitions as illustrated in the following example:

    partial class ClassWithNestedClass
    {
        partial class NestedClass { }
    }
    
    partial class ClassWithNestedClass
    {
        partial class NestedClass { }
    }
    
  • Tutte le definizioni di tipi parziali destinate a essere parti dello stesso tipo devono essere definite nello stesso assembly e nello stesso modulo (file con estensione exe o dll).All partial-type definitions meant to be parts of the same type must be defined in the same assembly and the same module (.exe or .dll file). Le definizioni parziali non possono estendersi su più moduli.Partial definitions cannot span multiple modules.

  • Il nome della classe e i parametri di tipo generico devono corrispondere in tutte le definizioni di tipi parziali.The class name and generic-type parameters must match on all partial-type definitions. I tipi generici possono essere parziali.Generic types can be partial. In ogni dichiarazione parziale è necessario usare gli stessi nomi di parametri nello stesso ordine.Each partial declaration must use the same parameter names in the same order.

  • Le parole chiave riportate di seguito sono facoltative in una definizione di tipi parziali. Tuttavia, se presenti in una definizione, tali parole chiave non possono essere in conflitto con quelle specificate in un'altra definizione parziale per lo stesso tipo:The following keywords on a partial-type definition are optional, but if present on one partial-type definition, cannot conflict with the keywords specified on another partial definition for the same type:

Per altre informazioni, vedere Vincoli sui parametri di tipo.For more information, see Constraints on Type Parameters.

Esempio 1Example 1

DescrizioneDescription

Nell'esempio seguente i campi e il costruttore della classe Coords vengono dichiarati in una definizione parziale di classe, mentre il membro PrintCoords viene dichiarato in un'altra definizione parziale di classe.In the following example, the fields and the constructor of the class, Coords, are declared in one partial class definition, and the member, PrintCoords, is declared in another partial class definition.

CodiceCode

public partial class Coords
{
    private int x;
    private int y;

    public Coords(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

public partial class Coords
{
    public void PrintCoords()
    {
        Console.WriteLine("Coords: {0},{1}", x, y);
    }
}

class TestCoords
{
    static void Main()
    {
        Coords myCoords = new Coords(10, 15);
        myCoords.PrintCoords();

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
// Output: Coords: 10,15

Esempio 2Example 2

DescrizioneDescription

L'esempio seguente dimostra che è anche possibile sviluppare struct e interfacce parziali.The following example shows that you can also develop partial structs and interfaces.

CodiceCode

partial interface ITest
{
    void Interface_Test();
}

partial interface ITest
{
    void Interface_Test2();
}

partial struct S1
{
    void Struct_Test() { }
}

partial struct S1
{
    void Struct_Test2() { }
}

Metodi parzialiPartial Methods

Una classe o uno struct parziale può contenere un metodo parziale.A partial class or struct may contain a partial method. Una parte della classe contiene la firma del metodo.One part of the class contains the signature of the method. Un'implementazione facoltativa può essere definita nella stessa parte o in un'altra parte.An optional implementation may be defined in the same part or another part. Se l'implementazione non viene specificata, il metodo e tutte le chiamate al metodo vengono rimosse in fase di compilazione.If the implementation is not supplied, then the method and all calls to the method are removed at compile time.

I metodi parziali consentono all'implementatore di una parte di una classe di definire un metodo, simile a un evento.Partial methods enable the implementer of one part of a class to define a method, similar to an event. L'implementatore dell'altra parte della classe può decidere se implementare il metodo o meno.The implementer of the other part of the class can decide whether to implement the method or not. Se il metodo non viene implementato, il compilatore rimuove la firma del metodo e tutte le chiamate al metodo.If the method is not implemented, then the compiler removes the method signature and all calls to the method. Le chiamate al metodo, inclusi eventuali risultati che derivassero dalla valutazione di argomenti nelle chiamate, non hanno alcun effetto in fase di esecuzione.The calls to the method, including any results that would occur from evaluation of arguments in the calls, have no effect at run time. Pertanto, il codice nella classe parziale può usare liberamente un metodo parziale, anche se non viene specificata l'implementazione.Therefore, any code in the partial class can freely use a partial method, even if the implementation is not supplied. Non verranno generati errori in fase di compilazione o errori di runtime se il metodo viene chiamato ma non implementato.No compile-time or run-time errors will result if the method is called but not implemented.

I metodi parziali sono particolarmente utili per personalizzare il codice generato.Partial methods are especially useful as a way to customize generated code. Consentono di riservare un nome e una firma del metodo, in modo che il codice generato possa chiamare il metodo ma spetta allo sviluppatore decidere se implementare il metodo.They allow for a method name and signature to be reserved, so that generated code can call the method but the developer can decide whether to implement the method. Analogamente alle classi parziali, i metodi parziali consentono di usare il codice creato da un generatore di codice con il codice creato da un sviluppatore senza alcun costo in fase di esecuzione.Much like partial classes, partial methods enable code created by a code generator and code created by a human developer to work together without run-time costs.

Una dichiarazione di metodo parziale è costituita da due parti: la definizione e l'implementazione,A partial method declaration consists of two parts: the definition, and the implementation. che possono trovarsi in parti separate di una classe parziale o nella stessa parte.These may be in separate parts of a partial class, or in the same part. Se non è presente la dichiarazione di implementazione, il compilatore ottimizza la dichiarazione di definizione e tutte le chiamate al metodo.If there is no implementation declaration, then the compiler optimizes away both the defining declaration and all calls to the method.

// Definition in file1.cs
partial void onNameChanged();

// Implementation in file2.cs
partial void onNameChanged()
{
  // method body
}
  • Le dichiarazioni di metodi parziali devono iniziare con la parola chiave contestuale partial e il metodo deve restituire void.Partial method declarations must begin with the contextual keyword partial and the method must return void.

  • I metodi parziali possono contenere il parametro in o ref ma non il parametro out.Partial methods can have in or ref but not out parameters.

  • I metodi parziali sono implicitamente private e pertanto non possono essere virtual.Partial methods are implicitly private, and therefore they cannot be virtual.

  • I metodi parziali non possono essere extern perché la presenza del corpo determina se è in corso una definizione o un'implementazione.Partial methods cannot be extern, because the presence of the body determines whether they are defining or implementing.

  • I metodi parziali possono contenere modificatori static e unsafe.Partial methods can have static and unsafe modifiers.

  • I metodi parziali possono essere generici.Partial methods can be generic. I vincoli vengono inseriti nella dichiarazione di definizione del metodo parziale e possono essere ripetuti facoltativamente nella dichiarazione di implementazione.Constraints are put on the defining partial method declaration, and may optionally be repeated on the implementing one. I nomi dei parametri e dei parametri di tipo non devono essere uguali nella dichiarazione di implementazione e in quella di definizione.Parameter and type parameter names do not have to be the same in the implementing declaration as in the defining one.

  • È possibile creare un delegato di un metodo parziale che è stato definito e implementato, ma non di un metodo parziale che è stato solo definito.You can make a delegate to a partial method that has been defined and implemented, but not to a partial method that has only been defined.

Specifica del linguaggio C#C# Language Specification

Per altre informazioni, vedere Tipi parziali in Specifica del linguaggio C#.For more information, see Partial types in the C# Language Specification. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.The language specification is the definitive source for C# syntax and usage.

Vedere ancheSee also