Passage de tableau à une fonction qui prend soit params object[] ou IEnumerable<T>

Je veux passer un tableau d'objets personnalisés pour une fonction comme String.Join qui a les signatures suivantes:

  • public static string Join(string separator, params Object[] values)
  • public static string Join(string separator, IEnumerable<T> values)

Si j'appelle la fonction comme ceci:

var arr = new MyClass[]{ new MyClass(), new MyClass() };
string text = string.Join("\n", arr);

J'obtiens une erreur de compilateur:

L'appel est ambigu entre les méthodes suivantes ou propriétés: 'string.Join(string, params object []) " et " chaîne de caractères.Join(chaîne, Système.Les Collections.Génériques.IEnumerable)'

Je peux résoudre l'ambiguïté en utilisant le IEnumerable<T> fonction:

var arr = new MyClass[]{ new MyClass(), new MyClass() };
string text = string.Join<MyClass>("\n", arr);

Mais puis-je appeler la params object[] fonction? Dans une critique pour les performances scénario, il serait préférable pour accéder au tableau directement, plutôt que par l'intermédiaire d'un agent recenseur.

Je suis à l'aide de C# 4.0, si cela fait une différence.

OriginalL'auteur bouvierr | 2013-04-10

  1. 20

    Si vous passez un object[] comme deuxième paramètre, le compilateur doit choisir le object[] surcharge, car il correspond exactement. Dans le cas où vous avez un différent-tableau typé (MyClass[] dans ce cas) juste lancer le tableau de object[]:

    string.Join("\n", (object[])arr);

    Vous n'êtes pas en train de modifier les types d'objets ou d'effectuer la conversion au moment de l'exécution, vous êtes seulement de donner le compilateur d'un soupçon à l'égard de laquelle la surcharge à utiliser.

    Et concernant votre commentaire sur la performance, n'oubliez pas de comparer les deux options, si la performance est critique. Ne présumez pas que l'un est plus rapide que l'autre. (Et toujours de profil de l'ensemble de votre application-il est probable que les goulots d'étranglement vont être ailleurs.)

    OriginalL'auteur cdhowie

  2. 3

    Si vous modifiez le type de votre arr variable object[] vous allez appeler l'autre surcharge:

    object[] arr = new MyClass[] { new MyClass(), new MyClass() };
string text = string.Join("\n", arr);

    Vous pouvez également convertir explicitement à object[]: string.Join("\n", (object[])arr);

    OriginalL'auteur Wouter de Kort

  3. 0

    Vous pouvez appeler l'autre surcharge comme ceci (c'est ce que param sont utilisés pour les) -

    string text = string.Join("\n", new MyClass(), new MyClass());

    OriginalL'auteur Rohit Vats

  4. 0

    Le plus simple modification de votre code, vous pourriez aller à partir de:

        var arr = new MyClass[]{ new MyClass(), new MyClass() };
    string text = string.Join("\n", arr);

    :

        var arr = new object[]{ new MyClass(), new MyClass() };
    string text = string.Join("\n", arr);

    Comme dit avant, le casting fonctionne aussi:

        var arr = new MyClass[]{ new MyClass(), new MyClass() };
    string text = string.Join("\n", (object[])arr);

    Pour en savoir plus sur ce sujet, la recherche C# résolution de surcharge.

    Résolution de surcharge est un sujet intéressant dans son propre droit, mais je n'ai pas encore trouver le goulet d'étranglement pour un problème de performance.

    Comme je l'ai mentionné dans ma question, je veux passer le tableau à la mise en œuvre appropriée de ma propre fonction (pas de Chaîne.Rejoindre, mais quelque chose de similaire avec les signatures de méthodes). La différence de performances est ici en raison des différentes implémentations de ma fonction. Certaines opérations, comme obtenir le nombre d'éléments dans la collection, sont en fait plus rapide en utilisant un tableau plutôt qu'un IEnumerable<T>.
    Le Count() la méthode d'extension utilise le .Longueur proprty dans le cas où l'interface IEnumerable est un tableau, mais ce n'est pas votre point. Vous pouvez envisager d'utiliser des noms différents pour les membres, et en ne s'appuyant pas sur la résolution de surcharge, si la différence de performance est critique. Par conséquent, vous n'aurez pas à forcer la compilation types pour obtenir la sémantique que vous êtes à la recherche pour.

    OriginalL'auteur Doug

  5. 0

    Si vous utilisez IEnumerable vous pouvez utiliser le <object> générique surcharge de la ToArray() méthode:

    var allFoos = foo.GetAllFoos().ToArray<object>(); 
string s = string.Join(", ", allFoos);

    L'air moins gros et plus lisible pour moi.

    OriginalL'auteur Kemuel Sanchez