Compartilhar via

Sobrecarga de membro

  • Artigo

Assinatura do membro inclui sua lista de nome e o parâmetro. Cada assinatura do membro deve ser exclusiva dentro do tipo. Os membros podem ter o mesmo nome sistema autônomo longo sistema autônomo suas listas de parâmetros são diferentes. Quando dois ou mais membros em um tipo são do mesmo tipo de membro (método, propriedade, construtor e assim por diante) e têm o mesmo nome e listas de parâmetros diferentes, o membro é chamado ser sobrecarregados. Por exemplo, a Array classe contém dois CopyTo métodos. O primeiro método usa uma matriz e um Int32 valor e a segunda usa método um array e uma Int64 valor.

ObservaçãoObservação:

Alterar o tipo de retorno de um método não faz o método exclusivo sistema autônomo na especificação da linguagem comum de tempo de execução. Não é possível definir métodos sobrecarregados que variam de acordo com o tipo de retorno.

Membros sobrecarregados devem fornecer variações sobre a mesma funcionalidade. Por exemplo, não seria correto para um tipo para ter dois CopyTo membros, onde o primeiro membro copiado dados para uma matriz e os dados copiados segundo para um arquivo. Um uso comum do membro sobrecarga é fornecer sobrecargas que usam parâmetros poucos ou nenhum e são fáceis de usar. Esses membros telefonar sobrecargas que são mais eficientes, mas também exigem mais experiência para usar corretamente. Sobrecargas de fáceis de usar oferecem suporte a cenários comuns passando valores padrão para os complexos métodos sobrecarregados. Por exemplo, a File classe fornece sobrecargas para o Open método. A sobrecarga simples Open leva um caminho de arquivo e modo de arquivo. Ele chama o Open sobrecarga que usa o caminho, modo de arquivo, acesso a arquivos e parâmetros de compartilhamento de arquivo e fornece normalmente usados valores padrão para o acesso a arquivos e parâmetros de compartilhamento de arquivo. Os desenvolvedores que não precisam da flexibilidade de sobrecarga complexa não é necessário saber sobre acesso a arquivos e modelos de compartilhamento para que podem em em aberto um arquivo.

Para facilitar a manutenção e o controle de versão, sobrecargas mais simples devem usar sobrecargas complexas para realizar suas ações; a funcionalidade subjacente não deve ser implementada em vários locais.

Diretrizes de sobrecarga

As diretrizes a seguir ajudam a garantir que seus membros sobrecarregados são bem projetados.

Tente usar nomes de parâmetro descritivo para indicar o valor padrão usado pelo sobrecargas mais simples.

Essa diretriz é aplicável a mais de Boolean parâmetros. O nome do parâmetro da sobrecarga mais complexo deve indicar o valor padrão fornecido pelo sobrecarga mais simples, que descreve o estado ou ação oposto. Por exemplo, a String classe fornece os seguintes métodos sobrecarregados:

Overloads Public Shared Function Compare( _
   ByVal strA As String, _
   ByVal strB As String _
) As Integer

Overloads Public Shared Function Compare( _
   ByVal strA As String, _
   ByVal strB As String, _
   ByVal ignoreCase As Boolean _
) As Integer
public static int Compare(
   string strA,
   string strB
);

public static int Compare(
   string strA,
   string strB,
   bool ignoreCase
);

A segunda sobrecarga fornece um Boolean parâmetro nomeado ignoreCase. Isso indica que a sobrecarga mais simples é sensível a diferenciar diferenciar maiúsculas de minúsculas e você precisará usar a sobrecarga mais complexa somente quando você desejar ignorar diferenciar diferenciar maiúsculas de minúsculas. Em geral, o valor padrão deve ser geralmente false.

Evite arbitrariamente diversos nomes de parâmetro em sobrecargas.Se um parâmetro em uma sobrecarga representa a mesma entrada sistema autônomo um parâmetro em sobrecarga de outro, sistema autônomo parâmetros devem ter o mesmo nome.

Por exemplo, não faça o seguinte:

Public Sub Write(message as String, stream as FileStream)
End Sub
Public Sub Write(line as String, file as FileStream, closeStream as Boolean)
End Sub

public void Write(string message, FileStream stream){}
public void Write(string line, FileStream file, bool closeStream){}

A definição correta para essas sobrecargas é o seguinte:

Public Sub Write(message as String, stream as FileStream)
End Sub
Public Sub Write(message as String, stream as FileStream, _
    closeStream as Boolean)
End Sub

public void Write(string message, FileStream stream){}
public void Write(string message, FileStream stream, bool closeStream){}

Estar consistentes na ordem de parâmetros no membros sobrecarregados.Parâmetros com o mesmo nome devem aparecer na mesma posição em todas as sobrecargas.

Por exemplo, não faça o seguinte:

Public Sub Write( message as String, stream as FileStream)
End Sub
Public Sub Write(stream as FileStream, message as String, _
    closeStream as Boolean)
End Sub

public void Write(string message, FileStream stream){}
public void Write(FileStream stream,  string message, bool closeStream){}

A definição correta para essas sobrecargas é o seguinte:

Public Sub Write(message as String, stream as FileStream)
End Sub
Public Sub Write(message as String, stream as FileStream, _
    closeStream as Boolean)
End Sub

public void Write(string message, FileStream stream){}
public void Write(string message, FileStream stream, bool closeStream){}

Essa diretriz possui duas restrições:

  • Se uma sobrecarga leva a uma lista de argumentos de variável, a lista deve ser o último parâmetro.

  • Se a sobrecarga demorar out parâmetros, por convenção que esses devem aparecer sistema autônomo sistema autônomo últimos parâmetros.

Fazer apenas a maior sobrecarga virtual (Overridable no Visual Basic) se extensibilidade é necessária.Sobrecargas menores devem simplesmente chamar por meio de para uma maior sobrecarga.

O exemplo de código a seguir demonstra essa prática.

Public Sub Write(message as String, stream as FileStream)
    Me.Write(message, stream, false)
End Sub

Public Overridable Sub Write( _
    message as String, stream as FileStream, closeStream as Boolean)
    ' Do work here.
End Sub

public void Write(string message, FileStream stream)
{
    this.Write(message, stream, false);
}
public virtual void Write(string message, FileStream stream, bool closeStream)
{
    // Do work here.
}

Não use ref ou out modificadores para sobrecarregar membros.

Por exemplo, não faça o seguinte.

Public Sub Write(message as String,  count as Integer)


...


Public Sub Write(message as String, ByRef count as Integer)

public void Write(string message, int count)


...


public void Write(string message, out int count)

Em geral, se você tiver um projeto em que isso ocorre, provavelmente há um problema de design mais profundo. Considere se um dos membros deve ser renomeado para fornecer mais informações sobre a ação exata que está sendo realizada pelo método.

Não permitem nula (Nothing no Visual Basic) sejam passadas para argumentos opcionais.Se um método aceita argumentos opcionais que são tipos de referência, permita nulo a ser passada para indicar que o valor padrão deve ser usado.Isso evita o problema de ter que verificar antes de chamar um membro nulo.

Por exemplo, os desenvolvedores não devem ter que verificar se há null no exemplo a seguir.

Public Sub CopyFile (source as FileInfo, _
    destination as DirectoryInfo, _
    newName as string)

    If newName Is Nothing
        InternalCopyFile(source, destination) 
    Else
        InternalCopyFile(source, destination, newName)
    End If
End Sub

public void CopyFile (FileInfo source, DirectoryInfo destination, string newName)
{
    if (newName == null)
    {
        InternalCopyFile(source, destination);
    }
    else
    {
        InternalCopyFile(source, destination, newName);
    }
}

Use membro sobrecarga em vez de definir os membros com argumentos padrão.Argumentos padrão não são compatíveis compatível compatível com CLS e não podem ser usados em alguns idiomas.

O exemplo de código a seguir demonstra o design do método incorreto.

Public Sub Rotate (data as Matrix, Optional degrees as Integer = 180)
' Do rotation here
End Sub

Esse código deve ser redesenhado sistema autônomo duas sobrecargas com a sobrecarga mais simples, fornecendo o valor padrão. O exemplo de código a seguir demonstra o design correto.

Overloads Public Sub Rotate (data as Matrix)
    Rotate(data, 180)
End Sub

Overloads Public Sub Rotate (data as Matrix, degrees as Integer)
' Do rotation here
End Sub

Partes direitos autorais 2005 Microsoft Corporation. Todos os direitos reservados.

Partes direitos autorais Addison-Wesley Corporation. Todos os direitos reservados.

Para obter mais informações sobre diretrizes de design, consulte a "diretrizes de design do estrutura: Catálogo de convenções, idiomas e padrões para bibliotecas do .NET reutilizável"Krzysztof Cwalina e Brad Abrams, publicado pela Addison-Wesley, 2005.

Consulte também

Outros recursos

Diretrizes de design de membro

Diretrizes de Design para desenvolvimento bibliotecas de classe