Fonction de prendre un tableau de type arbitraire dans C#

Question

J'ai créé une fonction qui traite un tableau d'objets, process (Object []). Cela fonctionne sur tous les types, y compris les entiers et les flottants, à condition que vous placiez chaque élément en premier. Je voudrais que la fonction prenne aussi des éléments non encadrés, ne serait-ce que pour la mettre en boîte elle-même avant le traitement. Comment je fais ça?

Je pourrais envelopper avec quelques fonctions comme le processus (int []) et le processus (float []) mais cela semble aussi un problème. J'ai essayé le processus (ValueType []) mais le compilateur sélectionne toujours le processus (Object []).

J'ai C# 2.0, mais s'il y a une bonne solution pour 3.0 je voudrais le voir.

Answer 1

Réponse courte: vous ne pouvez pas (utilement) le faire. Les génériques peuvent sembler être un moyen de contourner cela, mais dès que vous utilisez réellement l'instance génériquement typée, vous la passerez aux méthodes qui doivent accepter l'objet de la classe - donc ça sera mis en boîte à l'époque (pire, ça sera boxed plusieurs fois probablement, selon votre code). Si vous voulez gagner en performance en évitant de boxer de manière générique, vous devrez travailler sur comment vous traitez ces instances et vous assurez que tout traitement peut se faire de manière sûre malgré l'approche générique - et ce n'est pas facile (voir Generic Numerics par exemple) et dépend fortement du traitement que vous devez faire.

Answer 2

static void T(Array a) 
    { 
     if (a is int[]) 
      Console.WriteLine("Int"); 
     else 
      if (a is float[]) 
       Console.WriteLine("Float"); 
      else 
       .... 

    } 
    static void Main(){ 
     T(new int[]{30}); 
     float[] a = { 11 }; 
     T(a); 
    } 

Answer 3

La boxe est implicite. Par exemple:

using System; 

namespace MyProg 
{ 
    class Program 
    { 

    private static void ParamTest(params object[] args) 
    { 
     foreach (object o in args) 
     { 
     Console.Write(o); 
     Console.WriteLine(", "); 
     } 
     Console.WriteLine(); 
    } 

    static void Main(string[] args) 
    { 
     ParamTest(1, "abc", 2.4, new object()); 
    } 
    } 
} 

imprimera

 
1, 
abc, 
2.4, 
System.Object, 

Pas générique en vue!

Answer 4

Comment fonctionne le traitement? La signature de la méthode la plus évidente serait:

void ProcessArray<T>(T[] data) 

qui est littéralement « un tableau d'un type arbitraire » - bien que le type doit être connu par l'appelant à la compilation. Toutefois, en fonction de la façon dont vous utilisez les éléments, vous risquez de finir la boxe. Peut-être que c'est correct, compte tenu de la partie de votre question qui dit: "ne serait-ce que de la mettre en boîte elle-même avant de la traiter". Si vous êtes assez heureux avec cela, génial :)

Si vous pouviez donner plus de détails sur ce que vous faites, nous pourrons peut-être vous aider davantage.

Answer 5

Eh bien, techniquement, il est possible. Mais ce n'est pas recommandé, ni utile, pour des raisons évidentes. Notez qu'il fonctionne mal aussi, et ne vous permet pas de passer des tableaux directement. Pour l'amour de la curiosité et de l'étrangeté, voici l'astuce. Il utilise TypedReference et les mots-clés C# non documentés.

public void Process(__arglist) 
{ 
    var iterator = new ArgIterator(__arglist); 
    do 
    { 
     TypedReference typedReference = iterator.GetNextArg(); 
     Type type = __reftype(typedReference); 
     if (type == typeof(int)) 
     { 
      int value = __refvalue(typedReference,int); 
      // value is an int 
     } 
     else if (type == typeof(string)) 
     { 
      string value = __refvalue(typedReference,string); 
      // value is a string 
     } 
     else if (type == typeof(double)) 
     { 
      double value = __refvalue(typedReference,double); 
      // value is a double 
     } 
     // etc. 
    } 
    while (iterator.GetRemainingCount() > 0); 
} 

Vous pouvez appeler la méthode comme ça:

Process(__arglist(45, "lol", 42.5)); 

Il sera pas types de valeurs boîte/de Unbox. Mais, eh bien, oublie ça ...