C# args de longitud variable, que es mejor y por qué: __arglist, params array o Dictionary <T,K>?

Question

Recientemente he leído el siguiente mensaje de desbordamiento: Hidden Features of C#

Una de las características señalado fue el arglist. ¿Por qué uno elegiría esta o las alternativas como un medio para usar una lista de argumentos de longitud variable para un método? Además, tenga en cuenta que probablemente no use este tipo de constructo en mi código a menos que un caso de esquina lo justifique. Esta es más una cuestión de semántica que si es incluso práctico o prudente usar incluso argumentos de longitud variable. Entonces, ¿alguien sabe cuál es mejor y por qué?

[Test] 
public void CanHandleVariableLengthArgs() 
{ 
    TakeVariableLengthArgs(__arglist(new StringBuilder(), 12)); 

    object[] arr = { new StringBuilder() }; 
    TakeVariableLengthArgs2(arr); 

    TakeVariableLengthArgs3(
     new Dictionary<string, object> 
     { { "key", new StringBuilder() } }); 
} 

public void TakeVariableLengthArgs(__arglist) 
{ 
     var args = new ArgIterator(__arglist); 

     var a = (StringBuilder)TypedReference.ToObject(args.GetNextArg()); 
     a.Append(1); 
} 

public void TakeVariableLengthArgs2(params object[] args) 
{ 
     var a = (StringBuilder)args[0]; 
     a.Append(1); 
} 

public void TakeVariableLengthArgs3(Dictionary<string, object> args) 
{ 
     var a = (StringBuilder)args["StringBuilder"]; 
     a.Append(1); 
} 

Answer 1

sin duda lo nunca utilice __arglist, ya que es indocumentado y nadie sabe lo que significa en cualquier caso.

También evitaría las listas de argumentos de longitud variable durante el mayor tiempo posible, y en su lugar volver a trabajar mi diseño para comprender qué es realmente variable y modelar esa variabilidad de una manera menos dependiente de la plataforma.

Answer 2

Preferiría no utilizar ninguna de las tres técnicas descritas aquí. En su lugar, diseñaría un objeto de valor que tenga tipos fuertes siempre que sea posible, y posiblemente incluso tipos anulables. Si viene el impulso, también puede crear un objeto de valor tipado genérico.

Hay tanto olor a código en esta forma de codificación para mí. A longitud variable colección de objeto? No pasaría desapercibido en mi revisión del código.

Editar: Y si lo hizo pasar mi opinión código del parámetro sería con toda probabilidad será una instancia IEnumerable y ninguno de los tres elementos sugerencias. IEnumerable es lo más delgado que podría encapsular mis necesidades.

Answer 3

Depende del caso. He usado params en casos en los que tengo una cantidad variable de argumentos y esto aumenta significativamente la legibilidad del código de llamada.

Por ejemplo, tengo una clase que representa un documento TIFF y permite el acceso a una colección de páginas que pueden reordenarse e intercalarse con otros documentos TIFF. Dado que una de las tareas más comunes que desean nuestros clientes es la capacidad de combinar fácilmente múltiples documentos TIFF en una sola, también ofrecemos los siguientes dos métodos de utilidad:

public static void Combine(Stream output, params Stream[] sources) { /* ... */ } 
public static void Combine(Stream output, params string[] sourceFiles) { /* ... */ } 

que en el lenguaje hacen que el código de cliente se sienta muy agradable:

using (FileStream output = new FileStream(outputPath, FileMode.Create)) { 
    TiffDocument.Combine(output, tpsCoverSheetPath, mainDocumentPath, tpsTrailerPath); 
} 

Answer 4

En general, probablemente sea mejor que evite las características no documentadas del idioma, por varias razones.

• Ellos son más propensos a cambiar entonces las, características documentados establecidos
• Pueden tener efectos secundarios y las consecuencias que no son evidentes en su uso
• Otros desarrolladores no están familiarizados con ellos y tendrán más dificultades para mantener su código
• herramientas de refactorización (como VS sí mismo o Resharper) son poco probable que sea capaz de reconocerlos
• le quitan la claridad de la intención de su código
• Hay alternativas lenguaje apoyado a la mayoría de ellos

En el caso específico de la __arglist, se puede lograr la misma capacidad con el lenguaje soportado params palabra clave, que le permite crear listas de argumentos de variable de tipo seguro para métodos en C#. Como práctica, sin embargo, sería cuidadoso al usarlo, ya que puede ofuscar tu código si se usa de manera apropiada: buenos casos de uso (como los de cadena.Formato() que acepta argumentos variables) son menos frecuentes de lo que crees.

Answer 5

C# 4 tendrá un mejor mecanismo para esto; named and optional arguments:

static void Main(string[] args) 
{ 
    // The method can be called in the normal way, by using positional arguments. 
    Console.WriteLine(CalculateBMI(123, 64)); 

    // Named arguments can be supplied for the parameters in either order. 
    Console.WriteLine(CalculateBMI(weight: 123, height: 64)); 
    Console.WriteLine(CalculateBMI(height: 64, weight: 123)); 

    // Positional arguments cannot follow named arguments. 
    // The following statement causes a compiler error. 
    //Console.WriteLine(CalculateBMI(weight: 123, 64)); 

    // Named arguments can follow positional arguments. 
    Console.WriteLine(CalculateBMI(123, height: 64)); 
} 

static int CalculateBMI(int weight, int height) 
{ 
    return (weight * 703)/(height * height); 
}