Share via

Classes e métodos partial (Guia de Programação em C#)

  • Artigo

É possível dividir a definição de uma classe, um struct, uma interface ou um método em dois ou mais arquivos de origem. Cada arquivo de origem 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 parciais

Há várias situações em que a divisão de uma definição de classe é desejável:

  • Declarar uma classe em arquivos separados permite que vários programadores trabalhem nela ao mesmo tempo.
  • Você pode adicionar código à classe sem precisar recriar o arquivo de origem que inclui a origem gerada automaticamente. 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 precisar modificar o arquivo que o Visual Studio cria.
  • Os geradores de origem podem gerar funcionalidade extra em uma classe.

Para dividir uma definição de classe, use o modificador de palavra-chave partial, como mostrado aqui:

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

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

A palavra-chave partial indica que outras partes da classe, struct ou interface podem ser definidas no namespace. Todas as partes devem usar a palavra-chave partial. 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, tais como public, private e assim por diante.

Se alguma parte for declarada como abstrata, o tipo inteiro será considerado abstrato. Se alguma parte for declarada como lacrada, o tipo inteiro será considerado lacrado. Se alguma parte declarar um tipo base, o tipo inteiro herda dessa classe.

Todas as partes que especificam uma classe base devem concordar, mas partes que omitem uma classe base ainda herdam o tipo base. As partes podem especificar diferentes interfaces base e o tipo final implementa todas as interfaces listadas por todas as declarações parciais. Qualquer membro de classe, struct ou interface declarado em uma definição parcial está disponível para todas as outras partes. O tipo final é a combinação de todas as partes em tempo de compilação.

Observação

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

O exemplo a seguir mostra que os tipos aninhados podem ser parciais, mesmo que o tipo em que estão aninhados não seja parcial.

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

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

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

[SerializableAttribute]
partial class Moon { }

[ObsoleteAttribute]
partial class Moon { }

Elas são equivalentes às seguintes declarações:

[SerializableAttribute]
[ObsoleteAttribute]
class Moon { }

Os itens a seguir são mesclados de todas as definições de tipo parcial:

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

Por exemplo, considere as declarações a seguir:

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

Elas são equivalentes às seguintes declarações:

class Earth : Planet, IRotate, IRevolve { }

Restrições

Há várias regras a seguir quando você está trabalhando com definições parciais de classe:

  • Todas as definições de tipo parcial que devem 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
  • O modificador partial só pode aparecer imediatamente antes da palavra-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 que devem ser partes do mesmo tipo devem ser definidas no mesmo assembly e no mesmo módulo (arquivo .dll ou .exe). Definições parciais 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 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 estiverem presentes em uma definição de tipo parcial, não poderão entrar em conflito com as palavras-chave especificadas em outra definição parcial para o mesmo tipo:

Para obter mais informações, consulte Restrições a parâmetros de tipo.

Exemplos

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.

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

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

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 struct pode conter um método parcial. Uma parte da classe contém a assinatura do método. Uma implementação pode ser definida na mesma parte ou em outra parte.

Uma implementação não é necessária para um método parcial quando a assinatura obedece às seguintes regras:

  • A declaração não inclui modificadores de acesso. O método tem acesso private por padrão.
  • O tipo de retorno é void.
  • Nenhum dos parâmetros tem o modificador out.
  • A declaração do método não pode incluir nenhum dos seguintes modificadores:

O método e todas as chamadas para o método são removidos no momento da compilação quando não há nenhuma implementação.

Qualquer método que não esteja em conformidade com todas essas restrições (por exemplo, método public virtual partial void), deve fornecer uma implementação. Essa implementação pode ser fornecida por um gerador de origem.

Métodos parciais permitem que o implementador de uma parte de uma classe declare um método. O implementador de outra parte da classe pode definir esse método. Há dois cenários em que essa separação é útil: modelos que geram código clichê e geradores de origem.

  • Código do modelo: o modelo reserva um nome de método e uma assinatura para que o código gerado possa chamar o método. Esses métodos seguem as restrições que permitem a um desenvolvedor decidir se quer implementar o método. Se o método não for implementado, o compilador removerá a assinatura do método e todas as chamadas para o 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 pode usar livremente um método parcial, mesmo que a implementação não seja fornecida. Nenhum erro de tempo de compilação ou em tempo de execução resulta se o método for chamado, mas não implementado.
  • Geradores de origem: os geradores de origem fornecem uma implementação para métodos. O desenvolvedor humano pode adicionar a declaração de método (geralmente com atributos lidos pelo gerador de origem). O desenvolvedor pode gravar código que chama esses métodos. O gerador de origem é executado durante a compilação e fornece a implementação. Nesse cenário, as restrições para métodos parciais que podem não ser implementados geralmente não são seguidas.
// Definition in file1.cs
partial void OnNameChanged();

// Implementation in file2.cs
partial void OnNameChanged()
{
  // method body
}
  • As declarações de método parcial devem começar com a palavra-chave contextual partial.
  • As assinaturas de método parcial em ambas as partes do tipo parcial devem ser correspondentes.
  • Métodos parciais podem ter modificadores static e unsafe.
  • Métodos parciais podem ser genéricos. As restrições devem ser as mesmas na declaração de método de definição e implementação. Os nomes de parâmetro e de parâmetro de tipo não precisam ser os mesmos na declaração de implementação e de definição.
  • Você pode criar um delegado para um método parcial definido e implementado, mas não para um método parcial que não tenha uma implementação.

Especificação da Linguagem C#

Para obter mais informações, confira Tipos parciais e Métodos parciais na Especificação da Linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#. Os recursos adicionais para métodos parciais são definidos na especificação do recurso.

Confira também