Comment fusionner deux tableaux de type indéfini en C# en utilisant .NET 1.1

Question

J'essaye de créer une méthode utilitaire qui acceptera deux tableaux comme paramètres, les fusionner ensemble et retournera le tableau résultant. Rejeter les doublons.

Idéalement, les paramètres accepteraient n'importe quel type de tableau, comme int [] ou string []. J'utilise C# .NET 1.1, et n'ai donc pas accès à Generics ou Array.Resize().

Existe-t-il un meilleur moyen de fusionner deux tableaux sans connaître leur type, mais en retournant un tableau du même type?

À ce stade, le code suivant renvoie un tableau d'objet []. Je voudrais que le type de tableau retourné corresponde aux paramètres.

public static object[] MergeArrays(object[] dest, object[] src) 
{ 
    if (dest.GetType() != src.GetType()) 
     return null; // The arrays are of different types 

    if (dest.Equals(src)) 
     return dest; // Don't merge with self 

    // We now know there are two compatible and unique arrays 
    int delta = src.Length; 

    // Cycle through the passed materials and see if they already exist 
    for (int i = 0; i < src.Length; i++) 
     // Check to see if this material already exists 
     for (int j = 0; j < dest.Length; j++) 
      if (src[i] == dest[j]) 
      { 
       // The material already exists, so we'll skip it 
       src[i] = null; 
       delta--; 
       break; 
      } 

    // If there are still objects to merge, increase the array size 
    if (delta > 0) 
    { 
     object[] = new object[dest.Length + delta]; 
     int index; 

     // Copy the original array 
     for (index = 0; index < dest.Length; index++) 
      tmp[index] = dest[index]; 

     // Add the new elements 
     for (int i = 0; i < src.Length; i++) 
     { 
      if (src[i] == null) 
       continue; 
      tmp[index++] = src[i]; 
     } 
     dest = tmp; 
    } 
    return dest; 
} 

Answer 1

Je crois que tout cela est légal .NET 1.1:

public static object[] Merge(object[] first, object[] second) { 
    if (first == null) { 
     throw new ArgumentNullException("first"); 
    } 
    if (second == null) { 
     throw new ArgumentNullException("second"); 
    } 
    Type firstType = first.GetType(); 
    Type secondType = second.GetType(); 
    if (firstType != secondType) { 
     throw new InvalidOperationException("type mismatch"); 
    } 
    Hashtable table = new Hashtable(); 
    ArrayList items = new ArrayList(); 
    NewMethod(first, table, items); 
    NewMethod(second, table, items); 
    return (object[])items.ToArray(firstType.GetElementType()); 
} 

static void NewMethod(object[] array, Hashtable table, ArrayList items) { 
    for (int i = 0; i < array.Length; i++) { 
     object item = array[i]; 
     if (!table.Contains(item)) { 
      table.Add(item, 1); 
      items.Add(item); 
     } 
    } 
} 

Je suis trop paresseux pour trouver un bon nom pour NewMethod donc je laisse simplement le nom par défaut Visual Studio après un y décompresser procédure à la méthode.

Utilisation:

object[] a = new string[10]; 
object[] b = new string[10]; 

for(int i = 0; i < 10; i++) { 
    a[i] = i.ToString(); 
    b[i] = (i + 5).ToString(); 
} 

object[] c = Merge(a, b); 
Console.WriteLine(c.Length); 
Console.WriteLine(c.GetType()); 
for (int i = 0; i < c.Length; i++) { 
    Console.WriteLine(c[i]); 
} 

Sortie:

15 
System.String[] 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 

Notez que si vous voulez pousser un tableau à deux T[] où T : ValueType en Merge vous devez boîte les premiers éléments et tapez le tableau comme object[]; c'est parce qu'il n'y a pas de conversion de T[] à object[] lorsque T : ValueType. En outre, parce que GetType n'est pas virtuel, le meilleur que vous pouvez sortir dans ce cas est un object[], pas un T[].