如何通过非泛型类函数传递泛型类型

Question

I have a function that copies generic data from an API to a generic array ( apiData.copyTo() ). I solved that by doing the following:

public class Foo<T> {
    T[] data;

    public void SetData(Action<T[]> action) {
        action.Invoke(data);
    }
}

// ushort as example:
Foo<ushort> someFoo;
someFoo.SetData(buffer => apiData.copyTo(buffer));

However, after some changes in the data layout I'd like to create a private class for the generic data and make the Foo class non-generic this results in the following problem I'm facing:

public class Foo {

    private class Bar<T> {
        T[] data;

        public void SetData(Action<T[]> action) {
            action.Invoke(data);
        }
    }

    private Bar<ushort> bar; // Example generic, could be everything

    // The problem lies here:
    // T is not known to Foo, how to fix this?
    public void SetData(Action<T[]> action) {
        bar.SetData(action);

        // Some other stuff...
    }       
}

As you can see the problem is that the generic type T is not known to the Foo class. How can I still pass the Action to the private class Bar<T> within Foo ?

Please note that this is a minimal example to make my problem clear.

Answer 1

I think this will do what you're asking:

public class Foo
{
    public interface IBar
    {
        void SetData<T>(Action<T[]> action);
        Type GetBarType();
    }
    private class Bar<T>: IBar
    {
        //I changed this to a list since an empty array probably won't do you much good.
        List<T> data = new List<T>();

        public Type GetBarType()
        {
            return typeof(T);
        }

        public void SetData<TAction>(Action<TAction[]> action)
        {
            if(typeof(T) == typeof(TAction))
                action.Invoke(data as TAction[]);
        }
    }

    private IBar bar; 

    public void SetData<T>(Action<T[]> action)
    {
        if(bar?.GetBarType() == typeof(T))
            bar.SetData(action);
        else
        {
            bar = new Bar<T>();
            bar.SetData(action);
        }
        // Some other stuff...
    }
}

public class DoStuff
{
    public DoStuff()
    {
        var foo = new Foo();
        foo.SetData<int>((data) => {  /*do somthing wth this container*/ });
        foo.SetData<byte>((data) => {  /*do somthing wth this container*/ });
        foo.SetData<ushort>((data) => {  /*do somthing wth this container*/ });
        foo.SetData<ulong>((data) => {  /*do somthing wth this container*/ });
        foo.SetData<string>((data) => {  /*do somthing wth this container*/ });
    }
}