无法隐式转换类型 - 泛型

Question

我有一个通用类Zone<T> where T: Media.Medium。在这个类中，我有一个方法public void AddNode(Node node)，其中我有一个语句node.ParentZone = this，它会引发这个编译器错误：

无法将类型“Zone”隐式转换为 '区域'

但我不明白为什么public abstract class Node 有public Zone<Media.Medium> ParentZone 字段和Zone<T> where T: Media.Medium 类受where T: Media.Medium 约束，所以在任何情况下T 都是Media.Medium。

这里是孤立的代码：（完整的Zone<T>和Node的相关部分）

public class Zone<T> where T: Media.Medium
{
    public readonly Type MediaType = typeof(T);
    public readonly Guid ID = new Guid();

    private readonly List<Node> _nodes = new List<Node>();

    public void AddNode(Node node)
    {
        foreach (var port in node.GetPorts())
        {
            port.Medium = Activator.CreateInstance<T>();
        }

//下面一行编译出错

        node.ParentZone = this; 

// 不能将类型 'Zone' 隐式转换为 '区域'

        _nodes.Add(node);
    }



    public List<Node> GetNodes() => new List<Node>(_nodes);

    public void RemoveNode(Node node) => _nodes.Remove(node);


}





public abstract class Node
{       
    public Zone<Media.Medium> ParentZone;

    ...
}

---

更新 #1：

这段代码的目标是：我想将Node 对象添加到Zone 对象，Zone 对象有一个Node 对象列表。每当我将Node 添加到Zone 时，我想将该Zone 对象设置为Node 对象的父对象。

我愿意进行任何重构以实现这一目标。如果有更好的方式，它不应该是这样的。

Answer 1

您应该清楚，泛型约束不提供泛型类型之间的可分配性。或者以不同的方式表达：如果泛型类继承自另一个类并共享相同类型参数，则它可以分配给另一个类。例如：

class Zone<T> where T : Medium { }

class ChildZone<T>: Zone<T>  where T : Medium { }

class Medium { }

class ChildMedium : Medium { }

什么有效：

Zone<Medium> mediumZone = new ChildZone<Medium>();
Zone<ChildMedium> childMediumZone = new ChildZone<ChildMedium>();

什么不起作用：

Zone<Medium> mediumZone = new Zone<ChildMedium>();
ChildZone<Medium> childMediumZone = new ChildZone<ChildMedium>();

为什么？因为继承在泛型类中起作用，而不是在泛型参数中。考虑一下：

class Zone<T> {
   T Value { get; set; }
}

Zone<Medium> 的实例可以在其Value 属性中读取和类型为Medium 的项目。这意味着它可以读写Medium 和ChildMedium。相比之下，Zone<ChildMedium> 只能读取和写入 ChildMedium。这里的问题是设置器，因为不可能将Medium 分配给Zone<ChildMedium>.Value，但不能分配给Zone<Medium>.Value。这使得类型不兼容。

如果您的Zone 类是一个接口，并且您确保它只返回一个类型为 T 的值，但您不能设置该类型的值，则可以使用covariance：

interface IZone<out T> {
    T Value { get; }
}

如果你需要读取和写入值，你唯一的选择是让Node也泛型并传递泛型约束：

namespace Core.Nodes
{
    public abstract class Node<T> where T : Media.Medium
    {       
        public Zone<T> ParentZone;

        //...
    }
}

Answer 2

您的 Node 类声明似乎无效

public abstract class Node<T> where T: Media.Medium
{       
    public Zone<T> ParentZone;
    ...
}

Answer 3

我相信这是一个经典的协变/逆变问题。如果你不想让 Node 通用（也许它根本不必是通用的？）然后试着摆弄这个：

https://docs.microsoft.com/en-us/dotnet/standard/generics/covariance-and-contravariance

https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/covariance-contravariance/index

如果您明确声明您要达到的目标，您可以更改您的示例并使其发挥作用。需要添加接口IZone。

public interface IZone<out T> where T : Media.Medium
{
    //important stuff here
}

public class Zone<T> : IZone<T> where T : Media.Medium
{
    ...
}

public abstract class Node
{
    public IZone<Media.Medium> ParentZone;

}

Answer 4

你说过 T 类型继承自 Media.Medium，而不是 Zone<T> 继承自 Media.Medium。这是一个简单的示例：

class Program
{
    class A<T> where T: B
    {
        public void Foo(B b)
        {
            T t = Activator.CreateInstance<T>();
            //this is OK
            b = t;
            //this is not
            b = this;
        }
    }
    class B
    {            
    }
    class C : B
    {
        public void Foo(B b)
        {
            //this is ok
            b = this;
        }
    }
}