Console.WriteLine () et la nécessité de tant de surcharges d'arguments?

J'étais en train de parcourir la documentation et j'ai remarqué que cette Console.WriteLine()méthode présentait plusieurs surcharges. En particulier, ma curiosité et ma confusion partielle se rapportent à ceux-ci:

public static void WriteLine(string format, params object[] arg);
public static void WriteLine(string format, object arg0);
public static void WriteLine(string format, object arg0, object arg1);
public static void WriteLine(string format, object arg0, object arg1, object arg2);
public static void WriteLine(string format, object arg0, object arg1, object arg2, object arg3);

Cela semble redondant. Quel est le besoin des quatre autres surcharges en plus de la première? La première méthode est capable de faire tout ce que les autres méthodes peuvent faire. Y a-t-il un problème de performance qu'ils essayaient de résoudre en fournissant des surcharges supplémentaires, qui gèrent jusqu'à quatre arguments (le dernier)? Est-ce que la surcharge de passer par un tableau de jusqu'à quatre arguments est suffisamment grande pour fournir la nécessité de ces surcharges?

En général, vous avez raison de dire que la première surcharge peut suffire aux autres surcharges. Ce n'est pas strictement vrai car le paramsmot - clé ne peut pas être utilisé pour des cas indirects comme la liaison de groupe de méthodes. Par exemple

delegate void E(string format, object o1);
E e = Console.WriteLine;

La paramssurcharge ne satisfera pas ce cas, elle ne fonctionnera que lorsque cette surcharge particulière est présente

public static void WriteLine(string format, object arg0);

C'est un cas assez ésotérique cependant. Les raisons les plus importantes sont les suivantes

1. Toutes les langues CLI ne sont pas nécessaires pour prendre en charge le paramsmot - clé. Les surcharges réduisent le fardeau de ces langues en supprimant la nécessité de créer manuellement un tableau pour un simple appel WriteLine`
2. Performance. L'appel de la paramssurcharge force l'appelant à allouer un tableau, même si cela est fait implicitement par le compilateur. Les allocations sont bon marché en .Net mais pas gratuites. De petites choses comme celle-ci s'additionnent rapidement, en particulier sur les méthodes communément appelées comme Console.WriteLine. Avoir les autres surcharges permet aux cas courants d'éviter cette allocation

Les surcharges sont destinées aux programmes C ++ / CLI où le mot clé params n'existe pas.

Je pense que vous oubliez tous que les paramètres ont été introduits dans C # 2.0. Par conséquent, les surcharges existent également à partir de .NET 1.1, alors que le mot clé params n'existait pas.

Je pense que la question posée a déjà les bonnes réponses explicatives de JaredPar et jaket mais un point ce que je pense peut être pertinent aussi,

Je pense que la facilité d'utilisation et la liberté pour les utilisateurs d'utiliser l'une des fonctions ci-dessus en fonction de leurs besoins, il est beaucoup plus pratique que de les imposer pour créer un tableau, alors qu'ils n'en ont vraiment pas besoin.

Je pense aussi au bon vieux temps où j'ai commencé à apprendre le C #, je n'utilisais guère les tableaux et utiliser des tableaux était une tâche compliquée pour moi, l'attribuer puis les initialiser avec les valeurs appropriées était vraiment compliqué et prend du temps aussi ...

Ce n'est pas vraiment le problème des performances en tant que tel. Cependant, l'augmentation de la convivialité est une raison valable derrière cela.

Le code ci-dessous, vous donnerait un petit aperçu.

public class TipCalculator {
    private const double tipRate = 0.18;
    public static int Main(string[] args) {
        double billTotal;
        if (args.Length == 0) {
            Console.WriteLine("usage: TIPCALC total");
            return 1;
        }
        else {
            try {
                billTotal = Double.Parse(args[0]);
            }
            catch(FormatException) {
                Console.WriteLine("usage: TIPCALC total");
                return 1;
            }
            double tip = billTotal * tipRate;
            Console.WriteLine();
            Console.WriteLine("Bill total:\t{0,8:c}", billTotal);
            Console.WriteLine("Tip total/rate:\t{0,8:c} ({1:p1})", tip, tipRate);
            Console.WriteLine(("").PadRight(24, '-'));
            Console.WriteLine("Grand total:\t{0,8:c}", billTotal + tip);
            return 0;
        }
    }
}

Veuillez consulter le lien: http://msdn.microsoft.com/en-us/library/aa324774(v=vs.71).aspx pour plus d'informations.