Classes e métodos (guia de programação translation from VPE for Csharp) parcial

Artigo
08/25/2010

É possível dividir a definição de um classe or a struct, an interface ou um método em duas ou mais arquivos de fonte.Cada arquivo de código-fonte contém uma seção da definição de tipo ou método e todas as partes são combinadas quando o aplicativo é compilado.

Classes parcial

Quando a separação de uma definição de classe é desejável, existem várias situações:

Ao trabalhar em projetos grandes, a difusão de uma classe em arquivos separados permite que os programadores vários trabalhar ao mesmo time.
Ao trabalhar com código-fonte gerado automaticamente, o código pode ser adicionado à classe sem ter que recriar o arquivo de origem.O Visual Studio usa essa abordagem quando cria Windows Forms, código de wrapper de serviço Web e assim por diante.Você pode criar 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 parcialmodificador palavra-chave, sistema autônomo mostrado aqui:

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

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

The partial palavra-chave indica que Outros partes da classee, struct ou interface podem ser definidas no espaço para nome. Todas as partes devem usar o partial palavra-chave. Todas as partes devem estar disponível em time de compilar para formar o tipo final.Todas sistema autônomo partes devem ter a mesma acessibilidade, sistema autônomo public, private, e assim por diante.

Se qualquer parte está declarado como abstrato, o tipo de inteiro é considerado abstrato.Se qualquer parte for declarada lacrado, e, em seguida, o tipo de inteiro é considerado sealed.Se qualquer parte declarar um tipo de base, o tipo inteiro herda dessa classe.

Devem concordar com todas as partes que especificar uma classe base, mas partes omitir uma classe base ainda herdam o tipo de base.Partes podem especificar diferentes interfaces base e o tipo final implementa todas as interfaces listadas por todas as declarações parcial.Qualquer classe, struct ou interface membros declarados em uma definição parcial estão disponível para todos os Outros partes.O tipo final é a combinação de todas as partes em time de compilar.

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

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

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

Em tempo de compilar, 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 às 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 às 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 A { }  // Error, must also be marked partial
```
The partial modificador só pode aparecer imediatamente antes das palavras-chave class, struct, ou interface.

Tipos aninhados 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 conjunto de módulos (assembly) e o mesmo módulo (arquivo .exe ou .dll).Definições parcial não podem abranger vários módulos.
O nome de classe e os parâmetros de tipo genérico devem corresponder em todas as definições de tipo parcial.Tipos genéricos podem ser parcial.Cada declaração parcial deve usam 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 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
- novo modificador (partes aninhadas)
- restrições genéricas
  
  Para obter mais informações, consulte Restrições em parâmetros de tipo (Guia de programação 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 parcial structs e interfaces.

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 parcial ou estrutura pode conter um método 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 time de compilar.

Métodos parcial 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 está implementado e, em seguida, o compilador remove o método de assinatura e todas as chamadas ao método.Portanto, qualquer código na classe parcial livremente pode usar um método parcial, mesmo que a implementação não for fornecida.Não há time de compilar ou em time de execução resultarão erros se o método é chamado, mas não implementado.

Métodos parcial são especialmente úteis sistema autônomo uma maneira de personalizar o código gerado.Eles permitem que um nome de método e assinatura a ser reservado, para que gerou o código pode chamar o método, mas o desenvolvedor pode decidir se deseja implementar o método.Bem como classes parcial, métodos parcial permitem código criado por um gerador de código e código criado por um desenvolvedor humano trabalhem em conjunto sem custos de time de execução.

Uma declaração de método parcial consiste em duas partes: a definição e a implementação.Isso podem estar no partes separadas de uma classe parcial ou na mesma parte.Se não há nenhuma declaração de implementação e, em seguida, o compilador otimiza imediatamente tanto a definição 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 devem retornar void.
Métodos parcial podem ter ref but not check-out parâmetros.
Métodos parcial são, implicitamente, particulare, portanto, eles não podem ser virtual.
Métodos parcial não podem ser extern, porque a presença do corpo determina se eles estão definindo ou implementação.
Métodos parcial podem ter estático and não seguro modificador.
Métodos parcial podem ser genéricos.Restrições são colocadas na declaração de método parcial definição e, opcionalmente, podem ser repetidas em uma implementação.sistema autônomo nomes de parâmetro e tipo de parâmetro não tem o mesmo na declaração da implementação, sistema autônomo em uma definição.
Não é possível tornar um delegado para um método parcial.