Instrucciones de uso de métodos

Artículo
04/11/2008

En las reglas siguientes se describen las instrucciones de uso de métodos:

Elija un nombre para el evento siguiendo las Instrucciones de nomenclatura de eventos.
No utilice la notación húngara.
De forma predeterminada, los métodos no son virtuales. Mantenga esta característica predeterminada en las situaciones en las que no es necesario utilizar métodos virtuales. Para obtener más información sobre la herencia de implementación, vea Instrucciones de uso de clases base.

Instrucciones de sobrecarga de métodos

La sobrecarga de métodos se produce cuando una clase contiene dos métodos con el mismo nombre, pero firmas diferentes. En esta sección se proporcionan algunas instrucciones de utilización de métodos sobrecargados.

Utilice la sobrecarga de métodos para proporcionar métodos diferentes que semánticamente hagan lo mismo.
Utilice la sobrecarga de métodos, en vez de permitir argumentos predeterminados. Los argumentos predeterminados no controlan bien las versiones y, por tanto, no se permiten en Common Language Specification (CLS). En el siguiente ejemplo de código se muestra un método String.IndexOf sobrecargado.
```
Function String.IndexOf(name As String) As Integer
Function String.IndexOf(name As String, startIndex As Integer) As Integer
[C#]
int String.IndexOf (String name);
int String.IndexOf (String name, int startIndex);
```
Utilice los valores predeterminados correctamente. En una familia de métodos sobrecargados, el método complejo debe utilizar nombres de parámetros que indiquen un cambio del estado predeterminado que se supone en el método sencillo. Por ejemplo, en el código siguiente el primer método supone que la búsqueda no hará distinción entre mayúsculas y minúsculas. En el segundo método se utiliza el nombre ignoreCase en vez de caseSensitive para indicar cómo se cambia el comportamiento predeterminado.
```
' Method #1: ignoreCase = false.
Function Type.GetMethod(name As String) As MethodInfo
' Method #2: Indicates how the default behavior of method #1 
' is being changed.
Function Type.GetMethod(name As String, ignoreCase As Boolean) As MethodInfo
[C#]
// Method #1: ignoreCase = false.
MethodInfo Type.GetMethod(String name); 
// Method #2: Indicates how the default behavior of method #1 is being // changed.
 MethodInfo Type.GetMethod (String name, Boolean ignoreCase);
```

Utilice un modelo de nomenclatura y de orden coherentes en los parámetros del método. Lo habitual es proporcionar un conjunto de métodos sobrecargados con un número creciente de parámetros para que el programador pueda especificar el nivel de información deseado. Cuantos más parámetros especifique, más detalles puede especificar el programador. En el siguiente ejemplo de código, el método Execute contiene un orden de parámetros coherente y una variación del modelo de nomenclatura. Cada variación del método Execute utiliza la misma semántica para el conjunto compartido de parámetros.

Public Class SampleClass
   Private defaultForA As String = "default value for a"
   Private defaultForB As Integer = "42"
   Private defaultForC As Double = "68.90"

   Overloads Public Sub Execute()
      Execute(defaultForA, defaultForB, defaultForC)
   End Sub

   Overloads Public Sub Execute(a As String)
      Execute(a, defaultForB, defaultForC)
   End Sub

   Overloads Public Sub Execute(a As String, b As Integer)
      Execute(a, b, defaultForC)
   End Sub

   Overloads Public Sub Execute(a As String, b As Integer, c As Double)
      Console.WriteLine(a)
      Console.WriteLine(b)
      Console.WriteLine(c)
      Console.WriteLine()
   End Sub 
End Class
[C#]
public class SampleClass
{
   readonly string defaultForA = "default value for a";
   readonly int defaultForB = "42";
   readonly double defaultForC = "68.90";

   public void Execute()
   {
      Execute(defaultForA, defaultForB, defaultForC);
   }

   public void Execute (string a)
   {
      Execute(a, defaultForB, defaultForC);
   }

   public void Execute (string a, int b)
   {
      Execute (a, b, defaultForC);     
   }

   public void Execute (string a, int b, double c)
   {
      Console.WriteLine(a);
      Console.WriteLine(b);
      Console.WriteLine(c);
      Console.WriteLine();
   } 
}

Tenga en cuenta que el único método del grupo que debe ser virtual es el que más parámetros tiene y sólo cuando se precisa extensibilidad.

Si debe proporcionar la capacidad de reemplazar un método, establezca sólo la sobrecarga más completa como virtual y defina las otras operaciones en función de esta sobrecarga. En el ejemplo siguiente se muestra este modelo.

Public Class SampleClass
   Private myString As String

   Public Sub New(str As String)
      Me.myString = str
   End Sub

   Overloads Public Function IndexOf(s As String) As Integer
      Return IndexOf(s, 0)
   End Function

   Overloads Public Function IndexOf(s As String, startIndex As 
            Integer) As Integer
      Return IndexOf(s, startIndex, myString.Length - startIndex)
   End Function

   Overloads Public Overridable Function IndexOf(s As String, 
            startIndex As Integer, count As Integer) As Integer
      Return myString.IndexOf(s, startIndex, count)
   End Function 
End Class
[C#]
public class SampleClass
{
   private string myString;

   public MyClass(string str)
   {
      this.myString = str;
   }

   public int IndexOf(string s) 
   {
      return IndexOf (s, 0);
   }

   public int IndexOf(string s, int startIndex) 
   {
      return IndexOf(s, startIndex, myString.Length - startIndex );
   }

   public virtual int IndexOf(string s, int startIndex, int count) 
   {
      return myString.IndexOf(s, startIndex, count);
   }
}

Métodos con un número variable de argumentos

Puede que desee exponer un método que incluya un número variable de argumentos. Un ejemplo clásico es el método printf del lenguaje de programación C. En las bibliotecas de clases administradas, utilice la palabra clave params (ParamArray en Visual Basic) para esta construcción. Por ejemplo, utilice el siguiente código en vez de varios métodos sobrecargados.

Sub Format(formatString As String, ParamArray args() As Object)
[C#]
void Format(string formatString, params object [] args)

No es conveniente utilizar únicamente la convención de llamada VarArgs o puntos suspensivos (...) ya que no es compatible con Common Language Specification.

En un código sensible al rendimiento, puede proporcionar rutas de acceso de código especiales para un reducido número de elementos. Sólo se debe hacer esto para la ruta de acceso a un código completo de un caso especial (no únicamente crear una matriz y llamar al método general). En estos casos, se recomienda utilizar el siguiente modelo para que haya un equilibrio entre el rendimiento y el costo del código de un caso especial.

Sub Format(formatString As String, arg1 As Object)
Sub Format(formatString As String, arg1 As Object, arg2 As Object)

Sub Format(formatString As String, ParamArray args() As Object)
[C#]
void Format(string formatString, object arg1)
void Format(string formatString, object arg1, object arg2)
   
void Format(string formatString, params object [] args)

Vea también

Instrucciones de diseño para programadores de bibliotecas de clases | Instrucciones de nomenclatura de métodos | Instrucciones de uso de miembros de clases | Instrucciones de uso de clases base

Share via

Instrucciones de uso de métodos

Instrucciones de sobrecarga de métodos

Métodos con un número variable de argumentos

Vea también

Recursos adicionales