c#如何将泛型类型参数强制转换并传递给内部函数？

Question

假设我有一个“动物园”移动应用。它从在线服务器获取“动物”并将它们存储在本地数据库中。

Class Animal
Class Bird : Animal
Class Fish : Animal
Class Pelican : Bird
Class Penguin : Bird

所以我创建了一个具有以下功能的类 GetAnimalsFromServerService。

public Task<Animal[]> GetAnimalsFromServer<T>() where T : Animal, new() {
    if (typeof(T) == typeof(Bird)) {
        return GetBirdsFromServer<T>();
    } else if (typeof (T) == typeof(Fish)){
        return GetFishFromServer<T>();
    }
}


private Task<Bird[]> GetBirdsFromServer<T>() where T : Bird, new() {
    // Bird specific functionality here.
    if (typeof(T) == typeof(Pelican)) {
        return _serverConnection.GetPelicansFromServer();
    } else if (typeof (T) == typeof(Penguin)){
        return _serverConnection.GetPenguinsFromServer();
    }
}

这不会编译，因为 T 是“Animal”类型而不是“Bird”类型（并且 GetBirdsFromServer 需要“Bird”类型）。

自从“if(typeof(T) == typeof(Bird))”检查后我知道 T 是 Bird 类型，有没有办法将 T 转换为 Bird？

编辑： 根据要求，以下行无法编译

return GetBirdsFromServer<T>();

错误是：

类型“T”不能用作泛型类型或方法“GetBirdsFromServer()”中的类型参数“T”。没有从 'T' 到 'Bird' 的隐式引用转换

编辑 2： 好的，我想我明白为什么这不起作用了。基本上我最初的问题是“是否有一个我不知道的关键字可以让我做相当于：

return GetBirdsFromServer<(T as Bird)>();

但这是不可能的，因为“as”关键字本质上是在告诉计算机“哟，这个物体是一只鸟，相信我”。然后，如果它不是一只鸟，计算机可能会像“你撒谎了，那我就把对象设置为空”。

但在这种情况下，计算机并未考虑对象。因此，当您撒谎时，计算机就像“哦，便便，这不是对象，我该怎么办？”。因此，由于单独的行并不能保证 T 是 Bird，因此无法进行某种类型的强制转换或等效。

Answer 1

在这种情况下，您可以使用反射来调用 GetBirdsFromServer 所需的 T - "<(T as Bird)>"。还修复了一些其他问题（IsAssignableFrom、ContinueWith - Cast 用于向上转换）：

public Task<Animal[]> GetAnimalsFromServer<T>() where T : Animal, new()
{
    if (typeof(Bird).IsAssignableFrom(typeof(T)))
    {
        var method = GetType().GetMethod(nameof(GetBirdsFromServer));
        var generic = method.MakeGenericMethod(typeof(T));
        var result = generic.Invoke(this, new object[] { });
        return (result as Task<Bird[]>)
                    .ContinueWith(x => x.Result.Cast<Animal>().ToArray());
    }
    //other similar code
}

public Task<Bird[]> GetBirdsFromServer<T>() where T : Bird, new()
{
    // Bird specific functionality here.
    if (typeof(T) == typeof(Pelican))        
        return _serverConnection.GetPelicansFromServer()
                    .ContinueWith(x => x.Result.Cast<Bird>().ToArray());        
    //other similar code
}

用法：

var task = probe.GetAnimalsFromServer<Penguin>();
//type of task.Result.FirstOrDefault() will be Animal
//but actual type will be Penguin

Answer 2

这里有一种方法可以让您的 GetAnimalsFromServer<T>() 在编译时工作。

关键是创建一个包含您要返回的所有类型的字典及其将类型返回为Task<Animal[]> 的方法。

Dictionary<Type, Func<Task<Animal[]>>> _getFromServer = new Dictionary<Type, Func<Task<Animal[]>>>()
{
    { typeof(Pelican), () => _serverConnection.GetPelicansFromServer().ContinueWith(t => t.Result.Cast<Animal>().ToArray()) },
    { typeof(Penguin), () => _serverConnection.GetPenguinsFromServer().ContinueWith(t => t.Result.Cast<Animal>().ToArray()) },
};

那么编写GetAnimalsFromServer<T>() 方法就变得非常简单了：

public Task<Animal[]> GetAnimalsFromServer<T>() where T : Animal, new()
{
    if (_getFromServer.ContainsKey(typeof(T)))
    {
        return _getFromServer[typeof(T)]();
    }
    return default(Task<Animal[]>);
}

我使用以下代码对此进行了测试：

void Main()
{
    GetAnimalsFromServer<Pelican>();
    GetAnimalsFromServer<Penguin>();
}

public class Animal { }

public class Bird : Animal { }

public class Pelican : Bird { }

public class Penguin : Bird { }

public static class _serverConnection
{
    public static Task<Pelican[]> GetPelicansFromServer()
    {
        Console.WriteLine("Got Pelicans");
        return Task.Run(() => new Pelican[] { });
    }
    public static Task<Penguin[]> GetPenguinsFromServer()
    {
        Console.WriteLine("Got Penguins");
        return Task.Run(() => new Penguin[] { });
    }
}

当我运行它时，我会在控制台上看到以下内容：

有鹈鹕 有企鹅

Answer 3

当你尝试时：

return GetBirdsFromServer<T>();

您基本上说您需要从Animal 类型的服务器获取鸟类。但是您将GetBirdsFromServer 中的T 定义为继承Bird 的类。您对返回所做的操作类似于 Animal (T) 继承自 Bird。

您需要做的是制定某种策略/工厂来获得您想要的响应。例如：

return GetBirdsFromServer<Pelican>();

值得一提的另一件事是，在这种情况下，泛型似乎有点过多（过度设计）。简单的多态继承就足够了。