Преобразование массива типа T в массив типа I, где T реализует I в C#

Проблема здесь в том, что C# не поддерживает ковариация (по крайней мере, до C# 4.0, я думаю) в дженериках, поэтому неявные преобразования универсальных типов не будут работать.

Вы можете попробовать это:

List<I> list = new List<I>();
foreach (T[] arrayOfA in arrays)
{
    list.AddRange(Array.ConvertAll<T, I>(arrayOfA, t => (I)t));
}
return list.ToArray();

Для тех, кто сталкивается с этим вопросом и использует .NET 3.5, это немного более компактный способ сделать то же самое с помощью Linq.

List<I> list = new List<I>();
foreach (T[] arrayOfA in arrays)
{
    list.AddRange(arrayOfA.Cast<I>());
}
return list.ToArray();

Отредактировано для 2.0; он может стать:

static void Main() {
    IEnumerable<Foo[]> source = GetUndefinedNumberOfArraysOfObjectsOfTypeT();
    List<IFoo> list = new List<IFoo>();
    foreach (Foo[] foos in source) {
        foreach (IFoo foo in foos) {
            list.Add(foo);
        }
    }
    IFoo[] arr = list.ToArray();
}

Как насчет (в .NET 3.5):

I[] arr = src.SelectMany(x => x).Cast<I>().ToArray();

Чтобы показать это в контексте:

using System.Collections.Generic;
using System.Linq;
using System;
interface IFoo { }
class Foo : IFoo { //  A implements an interface I
    readonly int value;
    public Foo(int value) { this.value = value; }
    public override string ToString() { return value.ToString(); }
}
static class Program {
    static void Main() {
        // I have an undefined number of arrays of objects of type T
        IEnumerable<Foo[]> source=GetUndefinedNumberOfArraysOfObjectsOfTypeT();
        // I need an array of I at the end that is the sum of
        // all values from all the arrays. 
        IFoo[] arr = source.SelectMany(x => x).Cast<IFoo>().ToArray();
        foreach (IFoo foo in arr) {
            Console.WriteLine(foo);
        }
    }
    static IEnumerable<Foo[]> GetUndefinedNumberOfArraysOfObjectsOfTypeT() {
        yield return new[] { new Foo(1), new Foo(2), new Foo(3) };
        yield return new[] { new Foo(4), new Foo(5) };
    }
}

Я предполагаю, что вы пытались

list.AddRange((I[])arrayOfA);

уже?

EDIT В ответ на ваш комментарий о том, что мое предложение не сработает: я успешно запустил этот код всего минуту назад:

using System;
using System.Collections.Generic;

namespace Tester
{
    class Program
    {
        private interface I
        {
            string GetValue();
        }

        private class A : I
        {
            private string value;

            public A(string v)
            {
                value = v;
            }

            public string GetValue()
            {
                return value;
            }
        }

        static void Main(string[] args)
        {
            List<I> theIList = new List<I>();

            foreach (A[] a in GetAList())
            {
                theIList.AddRange((I[])a);
            }

            foreach (I i in theIList)
            {
                Console.WriteLine(i.GetValue());
            }
        }

        private static IEnumerable<A[]> GetAList()
        {
            yield return new [] { new A("1"), new A("2"), new A("3") };
            yield return new [] { new A("4") };
        }
    }
}

Или я просто пропустил требование?

Попробуйте добавить общее ограничение

где Т:Я

Я предполагаю, что проблема здесь в том, что дженерики не понимают, что T реализует I. Может сработать явное объявление T : I.

Также вы можете выполнить цикл for и добавлять свои объекты T по одному вместо использования AddRange.

Структура типов С# в настоящее время не поддерживает это (обработка Foo<T> как Foo<I>, если X : I), это называется ковариацией на I.

Базовая структура делает это, и c# 4.0 добавляет поддержку это

Поскольку требуются такие явные приведения, ответ Марка будет самым простым.

В вашем коде С# вы не добавляете arrayOfA в список результатов:

List<I> list = new List<I>();
foreach (T[] arrayOfA in arrays)
    list.AddRange(arrayOfA);

return list.ToArray();

Однако, если вы используете .NET 3.5, вы можете сделать это с помощью LINQ:

return (from arrayOfA in arrays
        from element in arrayOfA
        select element as I).ToArray();

Или с помощью методов LINQ:

return arrays.SelectMany(arrayOfA => arrayOfA.Cast<I>()).ToArray();

Массивы ссылочных объектов ковариантны в C# (то же верно и для Java).

Из названия я предполагаю, что ваш T является универсальным, а не реальным типом, поэтому вам нужно ограничить его ссылочным типом, чтобы получить неявное преобразование из T[] в I[].

Попробуй это:

public static I[] MergeArrays<T,I>(IEnumerable<T[]> arrays) 
    where T:class,I
{
    List<I> list = new List<I>();
    foreach(T[] array in arrays){
        list.AddRange(array);
    }
    return list.ToArray();
}