C#通用速记和向上转换

我一直在玩接口和泛型

我想要的是一个

Foo

作为

Foo

的简写，这明智吗？以下是公认的做法吗

using System.Diagnostics;

namespace MyNamespace
{
    public class Foo<T> : Foo<T, int> where T : class
    {
    }

    public class Foo<T, U> where T : class
    {
        public void Bar()
        {
            Debug.WriteLine("this: " + GetType().Name + ", T: " + typeof(T).Name + ", U: " + typeof(U).Name);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var fooT = new Foo<string>();
            var fooTU = new Foo<string, int>();

            fooT.Bar();
            fooTU.Bar(); 
        }
    }
}

使用系统诊断；
名称空间MyNamespace
{
公共类Foo:Foo其中T:class
{
}
公共类Foo其中T:class
{
公共空白栏（）
{
WriteLine（“this:”+GetType（）.Name+”，T:“+typeof（T.Name+”，U:”+typeof（U.Name））；
}
}
班级计划
{
静态void Main（字符串[]参数）
{
var fooT=newfoo（）；
var fooTU=新Foo（）；
脚杆（）；
fooTU.Bar（）；
}
}
}

我真正的问题是。。。是否可以从

Foo

向上（向下）转换为

Foo

，其中

T

是同一类型。说这句话有意义吗，或者这与协变/逆变有关（我至今仍不明白）

对我来说，一个有点无知的人，在这个例子中，

Foo

和

Foo

是相同的类型，但当然是

（（Foo）fooTU）.Bar（）不工作

我真正的问题是。。。是否可以从
Foo
向上（向下？）转换为
Foo
，其中T是相同的类型。说这句话有意义吗，或者这与协变/逆变有关（我至今仍不明白）

如果实际对象的类型为
Foo
，则可以从
Foo
强制转换为
Foo
。他们有相同的名字这一事实在这里是完全不相关的，所以让我们改变一下：

class Foo<T, U> {}
class Bar<T> : Foo<T, int>

class Foo{}
酒吧类别：富

现在：

Foo-Foo=new-Foo（）；
Bar=（Bar）foo；//砰，扔

但是：

Foo-Foo=newbar（）；
Bar=（Bar）foo；//这很好

泛型在这里很不相关，真的。。。这是铸造的正常规则

我真正的问题是。。。是否可以从
Foo
向上（向下？）转换为
Foo
，其中T是相同的类型。说这句话有意义吗，或者这与协变/逆变有关（我至今仍不明白）

如果实际对象的类型为
Foo
，则可以从
Foo
强制转换为
Foo
。他们有相同的名字这一事实在这里是完全不相关的，所以让我们改变一下：

class Foo<T, U> {}
class Bar<T> : Foo<T, int>

class Foo{}
酒吧类别：富

现在：

Foo-Foo=new-Foo（）；
Bar=（Bar）foo；//砰，扔

但是：

Foo-Foo=newbar（）；
Bar=（Bar）foo；//这很好

泛型在这里很不相关，真的。。。这是铸造的正常规则

是否可以从
Foo
向上转换为
Foo
，其中T为相同类型

不安全-这就像从
动物
到
狗
-它可能是
狗
，但如果不是这样，您将在运行时获得异常

出于同样的原因，您也不能将
Foo
视为
Foo

是否可以从
Foo
向上转换为
Foo
，其中T为相同类型

不安全-这就像从
动物
到
狗
-它可能是
狗
，但如果不是这样，您将在运行时获得异常

出于同样的原因，您也不能将
Foo
视为
Foo

在本例中，Foo和Foo是相同的类型

这是不正确的
Foo
是
Foo
，但
Foo
不一定是
Foo
。这就是为什么您可以从
Foo
转换为
Foo
，但反之亦然

在本例中，Foo和Foo是相同的类型

这是不正确的
Foo
是
Foo
，但
Foo
不一定是
Foo
。这就是为什么您可以从
Foo
转换为
Foo
，但不能从
Foo
转换为
Foo
。
如果您尽可能减少示例，这会有所帮助-如果您的“实际问题”只是关于类
Foo
和
Foo
，那么就不用担心接口了。如果你真的对接口感兴趣，请澄清它们与你的问题之间的关系。如果你尽可能减少你的示例，这会有所帮助-如果你的“实际问题”只是关于类
Foo
和
Foo
，那么就不要为接口操心了。如果您确实对接口感兴趣，请澄清它们与您的问题的相关性。
Foo<string, int> foo = new Bar<string>();
Bar<string> bar = (Bar<string>) foo; // This is fine