C#: Convertir T en T []

Question

Je voudrais convertir T en T [] s'il s'agit d'un tableau.

static T GenericFunction<T>(T t) 
{ 
     if (t == null) return default(T); 

     if (t.GetType().IsArray) 
     { 
      //if object is an array it should be handled 
      //by an array method 
      return (T) GenericArrayFunction((T[])t); 
     } 
     ... 
} 

static T[] GenericArrayFunction<T>(T[] t) 
{ 
     if (t == null) return default(T); 

     for (int i = 0 ; i < t.Length ; i++) 
     { 
      //for each element in array carry 
      //out Generic Function 
      if (t[i].GetType().IsArray()) 
      { 
       newList[i] = GenericArrayFunction((T[])t[i]); 
      } 
      else 
      { 
       newList[i] = GenericFunction(t[i]); 
      } 
     } 
     ... 
} 

Erreur Si je tente (T []) t

Impossible de convertir le type 'T' 'T []'

Erreur Si je viens essayer à transmettre t

Les arguments de type pour la méthode 'GenericAr rayFunction (T []) 'ne peut pas être déduit de l'utilisation. Essayez de spécifier explicitement les arguments de type.

Answer 1

Tout simplement parce que T est un type de tableau ne veut pas dire qu'il est aussi un tableau deT. En fait, la seule façon qui pourrait arriver serait que T soit quelque chose comme object, Array ou l'une des interfaces implémentées par les tableaux.

Qu'essayez-vous vraiment de faire? Je soupçonne que vous voulez trouver le type d'élément de la matrice, puis appelez GenericArrayFunction avec le T approprié - mais ce ne sera pas le mêmeT, et vous aurez besoin de l'appeler avec la réflexion, ce qui sera un peu douloureux. (. Pas trop mal, mais désagréable)

Je suspect-vous pas bien comprendre C#/génériques NET -. S'il vous plaît nous donner plus de contexte sur l'image plus grande afin que nous puissions vous aider à mieux.

EDIT: L'approche de réflexion serait quelque chose comme ceci:

private static readonly ArrayMethod = typeof(NameOfContainingType) 
    .GetMethod("GenericArrayFunction", BindingFlags.Static | BindingFlags.NonPublic); 

... 

static T GenericFunction<T>(T t) 
{ 
     if (t == null) return default(T); 

     if (t is Array) 
     { 
      Type elementType = t.GetType().GetElementType(); 
      MethodInfo method = ArrayMethod.MakeGenericMethod(new[] elementType); 
      return (T) method.Invoke(null, new object[] { t }); 
     } 
     ... 
} 

Notez que cela échouera encore pour les tableaux rectangulaires, qui deviennent encore plus difficiles à faire face.

Answer 2

Ce n'est pas possible. T ne peut jamais être T[]. T est toujours un certain type, pas seulement un espace réservé. Si T est array (int[]), alors T[] sera int[][].

Modifier: Il y a quelques exceptions (comme object est object[]), mais dans le cas général (et c'est ce que les génériques sont) T ne peut pas être T []