Parcial Classes e métodos (guia de programação de C#)

Artigo
08/04/2011

É possível dividir a definição de um classe ou struct, um interface ou um método ao longo de dois ou mais arquivos de origem. Cada arquivo contém uma seção para definição de tipo ou método, e todas as partes são combinadas quando a aplicação é compilada.

Classes parciais

Existem várias situações em que dividir uma classe é desejável:

Ao trabalhar em grandes projetos, dividir uma classe em arquivos separados permite múltiplos programadores a trabalhar sobre ela, ao mesmo tempo.
Ao trabalhar com a fonte gerado automaticamente, código pode ser adicionado à classe sem ter que recriar o arquivo de origem. Visual Studio usa esta abordagem quando ele cria o Windows Forms, código adptadores de Web Service, e assim sucessivamente. Você pode criar o código que usa essas classes sem ter que modificar o arquivo criado pelo Visual Studio.
Para dividir uma definição de classe, use o parcial modificador de palavra-chave, como mostrado aqui:

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

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

O partial palavra-chave indica que as outras partes da classe, struct ou interface podem ser definidos no namespace. Todas as partes devem usar o partial palavra-chave. Todas as partes devem estar disponíveis em tempo de compilação para formar o tipo final. Todas as partes devem ter a mesma acessibilidade, como public, privatee assim por diante.

Se qualquer parte é declarado como abstrato, o tipo de inteiro é considerado abstrato. Se qualquer parte for declarada lacrado, o tipo inteiro será considerada lacrado. Se qualquer parte declara um tipo base, o tipo inteiro herda a classe.

Especificar uma classe base todas as partes devem concordar, mas as partes omitir uma classe base ainda herdam o tipo base. Partes podem especificar diferentes interfaces de base e o tipo final implementa todas as interfaces listadas por todas as declarações parciais. Qualquer classe, struct ou membros de interface declarados em uma definição parcial estão disponíveis para todas as partes. O tipo final é a combinação de todas as partes em tempo de compilação.

Observação
O partial modificador não está disponível em declarações delegate ou enumeração.

O exemplo a seguir mostra que tipos aninhados podem ser parciais, mesmo se o tipo que são aninhados não é parcial propriamente dito.

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

Em tempo de compilação, os atributos das definições de tipo parcial são mesclados. Por exemplo, considere as seguintes declarações:

[SerializableAttribute]
partial class Moon { }

[ObsoleteAttribute]
partial class Moon { }

Eles são equivalentes para as seguintes declarações:

[SerializableAttribute]
[ObsoleteAttribute]
class Moon { }

A seguir é mesclada de todas as definições de tipo parcial:

Comentários XML
interfaces
atributos de parâmetro de tipo genérico
atributos de classe
membros

Por exemplo, considere as seguintes declarações:

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

Eles são equivalentes para as seguintes declarações:

class Earth : Planet, IRotate, IRevolve { }

Restrições

Existem várias regras a seguir quando você estiver trabalhando com definições de classe parcial:

Todas as definições de tipo parcial deve ser partes do mesmo tipo que devem ser modificadas com partial. Por exemplo, as seguintes declarações de classe geram um erro:
```
public partial class A { }
//public class tcA { }  // Error, must also be marked partial
```
O partial modificador só pode aparecer imediatamente antes das palavras-chave class, struct, ou interface.

Tipos parciais aninhados são permitidos em definições de tipo parcial, conforme ilustrado no exemplo a seguir:

partial class ClassWithNestedClass
{
    partial class NestedClass { }
}

partial class ClassWithNestedClass
{
    partial class NestedClass { }
}

Todas as definições de tipo parcial deve ser partes do mesmo tipo devem ser definidas no mesmo assembly e o mesmo módulo (arquivo. exe ou. dll). Definições parciais não podem abranger vários módulos.
O nome da classe e os parâmetros de tipo genérico devem coincidir com todas as definições de tipo parcial. Tipos genéricos podem ser parciais. Cada declaração parcial deve usar os mesmos nomes de parâmetro na mesma ordem.
As seguintes palavras-chave em uma definição de tipo parcial são opcionais, mas se estiver presente em uma definição de tipo parcial, não é possível entrar em conflito com as palavras-chave especificadas em outra definição parcial para o mesmo tipo:
- Público
- Particular
- Protegido
- interno
- abstrata
- autenticada
- classe base
- nova o modificador (partes aninhadas)
- restrições genéricas
  
  Para obter mais informações, consulte Constraints on Type Parameters (C# Programming Guide).

Exemplo 1

Descrição

No exemplo a seguir, os campos e o construtor da classe, CoOrds, que são declaradas em uma definição de classe parcial e o membro PrintCoOrds, que é declarado em outra definição de classe parcial.

Código

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

Exemplo 2

Descrição

O exemplo a seguir mostra que você também pode desenvolver interfaces e structs parcial.

Código

partial interface ITest
{
    void Interface_Test();
}

partial interface ITest
{
    void Interface_Test2();
}

partial struct S1
{
    void Struct_Test() { }
}

partial struct S1
{
    void Struct_Test2() { }
}

Métodos Parciais

Uma classe ou um struct parcial pode conter um método também parcial. Uma parte da classe contém a assinatura do método. Uma implementação opcional pode ser definida na mesma parte ou outra parte. Se a implementação não for fornecida, em seguida, o método e todas as chamadas ao método são removidas em tempo de compilação.

Métodos parciais permitem que o implementador de uma parte de uma classe definir um método semelhante a um evento. O implementador da parte da classe pode decidir se deseja implementar o método ou não. Se o método não é implementado, o compilador remove o método de assinatura e todas as chamadas ao método. As chamadas de método, incluindo quaisquer resultados que ocorreriam na avaliação dos argumentos em chamadas, não têm efeito em tempo de execução. Portanto, qualquer código na classe parcial livremente pode usar um método parcial, mesmo se a implementação não for fornecida. Erros de tempo de compilação ou runtime resultará se o método for chamado, mas não implementado.

Métodos parciais são especialmente úteis, como uma maneira de personalizar o código gerado. Eles permitem que um nome de método e a assinatura a ser reservado, para que o código gerado pode chamar o método, mas o desenvolvedor pode optar por implementar o método. Bem como classes parciais, os métodos parciais permitem código criado por um gerador de código e o código criado por um desenvolvedor humano trabalhem juntas, sem custos de tempo de execução.

Uma declaração de método parcial consiste em duas partes: a definição e a implementação. Esses podem ser em partes separadas de uma classe parcial ou na mesma parte. Se não houver nenhuma declaração de implementação, o compilador otimiza distância tanto a definição de declaração e todas as chamadas ao método.

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

// Implementation in file2.cs
partial void onNameChanged()
{
  // method body
}

Declarações de método parcial devem começar com a palavra-chave contextual parcial e o método deve retornar void.
Métodos parciais podem ter ref , mas não check-out parâmetros.
Métodos parciais são implicitamente particular, e portanto não pode ser virtual.
Métodos parciais não podem ser extern, porque a presença do corpo determina se eles estão definindo ou implementação.
Métodos parciais podem ter estático e inseguros modificadores.
Métodos parciais podem ser genéricos. As restrições são colocadas na declaração de definição de método parcial e podem, opcionalmente, ser repetidas na implementação. Nomes de parâmetro e tipo de parâmetro não tem o mesmo na declaração da implementação, como na definição.
Você pode fazer uma delegar um método parcial que foram definido e implementado, mas não um método parcial que só foi definido.