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

Artigo
02/25/2013

É possível dividir a definição de um classe ou um 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 outras partes da classe, struct, ou interface pode ser definido 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 inteiro é considerado abstrato.Se qualquer parte for declarada lacrado, o tipo inteiro será considerada lacrados.Se qualquer parte declara um tipo base, o tipo inteiro herda dessa classe.

Todas as partes que especificar uma classe base devem concordar, mas 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 de parciais.Qualquer classe, struct ou membros de interface declarados em uma definição parcial estão disponíveis para todas as outras 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 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.

Aninhadas tipos parciais 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 se estender por 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 na outra definição parcial para o mesmo tipo:
- Público
- Particular
- Protegido
- interno
- abstrata
- autenticada
- classe base
- nova modificador (partes aninhadas)
- restrições genéricas
  
  Para obter mais informações, consulte Restrições em parâmetros de tipo (guia de programação do C#).

Exemplo 1

Descrição

No exemplo a seguir, os campos e o construtor da classe, CoOrds, são declarados em uma definição de classe parcial e o membro, PrintCoOrds, é 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 serã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 outra 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 para o método, incluindo qualquer resultado que ocorreria da avaliação de argumentos nas 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 que a implementação não for fornecida.Nenhum erro 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 forma 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 decidir se deseja 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 em conjunto, 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étodos parciais devem começar com a palavra-chave contextual parcial e o método deve retornar void.
Os 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.
Os métodos parciais podem ter estático e não seguros modificadores.
Métodos parciais podem ser genéricos.As restrições são colocadas na declaração de método parcial a definição e, opcionalmente, podem ser repetidas na implementação.Nomes de parâmetro e tipo de parâmetro não tem o mesmo na declaração de implementação, como naquela definição.
Você pode fazer uma delegar um método parcial que foi definido e implementado, mas não um método parcial que só foi definido.

Especificação da linguagem C#

Para obter mais informações, consulte Especificação de linguagem do C# A especificação da linguagem é a fonte definitiva para a sintaxe e o uso da linguagem C#.