matriz genérica de niño genérico C#

Question

Tengo un contenedor clase padre que puede contener cualquier tipo de nodo, donde nodo es una subclase de una clase genérica específica a los padres, así:

public class ContainerBase<NodeType, ObjectType> 
    where NodeType : NodeBase<ObjectType> where ObjectType : ObjectBase { 
} 

public abstract class NodeBase<T> where T : ObjectBase { 
    ContainerBase<NodeBase<T>, T> container; 
    public NodeBase(ContainerBase<NodeBase<T>, T> owner) { 
     container = owner; 
    } 
} 

Lo quiero hacer es crear subclases concretas para simplificar, que implementan tipos de objetos estándar:

public class ContainerNormal : ContainerBase<NodeNormal, ObjectNormal> { 
} 

public class NodeNormal : NodeBase<ObjectNormal> { 
    //This doesn't work 
    public NodeNormal(ContainerNormal owner) : base(owner) { } 
} 

que un poco entender por qué la llamada al constructor base no funciona. Está intentando convertir un ContainerNormal a un ContainerBase<NodeBase<ObjectNormal>, ObjectNormal> que realmente no funciona.

Entonces, ¿qué patrón de diseño me falta para que esto funcione, verdad? ¿O simplemente tengo que tomar un ContainerBase<NodeBase<ObjectNormal>,ObjectNormal> en el constructor, aunque no necesariamente sea un objeto ContainerNormal?

Answer 1

Explorar: Covariance and contravariance, pero esto debería funcionar:

public class Container<TNode, T> where TNode : Node<T> { } 

public abstract class Node<T> 
{ 
    Container<Node<T>, T> container; 

    public Node(Container<Node<T>, T> owner) 
    { 
     this.container = owner; 
    } 
} 

public class ContainerNormal<T> : Container<Node<T>, T> { } 

public class NodeNormal<T> : Node<T> 
{ 
    public NodeNormal(ContainerNormal<T> container) 
     : base(container) 
    { 
    } 
} 

public class ContainerNormal : ContainerNormal<string> { } 

public class NodeNormal : NodeNormal<string> 
{ 
    public NodeNormal(ContainerNormal container) 
     : base(container) 
    { 
    } 
} 

Answer 2

En C# 4 se puede lograr esto mediante la interfaz genérica de covarianza:

public class ContainerBase<NodeType, ObjectType> : IContainerBase<NodeType, ObjectType> 
    where NodeType : NodeBase<ObjectType> where ObjectType : ObjectBase { 
} 

public abstract class NodeBase<T> where T : ObjectBase { 
    IContainerBase<NodeBase<T>, T> container; 
    public NodeBase(IContainerBase<NodeBase<T>, T> owner) { 
     container = owner; 
    } 
} 

public class ContainerNormal : ContainerBase<NodeNormal, ObjectNormal> { 
} 

public interface IContainerBase<out NodeType, ObjectType> 
    where NodeType : NodeBase<ObjectType> where ObjectType : ObjectBase { 
} 

public class NodeNormal : NodeBase<ObjectNormal> { 
    //This doesn't work 
    public NodeNormal(ContainerNormal owner) : base(owner) { } 
} 

public class ObjectNormal : ObjectBase {} 

public class ObjectBase{} 

Por supuesto, esto sólo funcionará si su interfaz IContainerBase puede no tener ninguna función que tendrían un NodeType como entrada. Por ejemplo, esto funcionaría:

public interface IContainerBase<out NodeType, ObjectType> 
    where NodeType : NodeBase<ObjectType> where ObjectType : ObjectBase 
{ 
    NodeType NodeTypeProp {get;} 
} 

... pero esto no lo haría:

public interface IContainerBase<out NodeType, ObjectType> 
    where NodeType : NodeBase<ObjectType> where ObjectType : ObjectBase 
{ 
    NodeType NodeTypeProp {get;set;} // "set" not allowed on "out" type 
} 

Una nota más: Usted cuenta de lo que tenía que nombrar la propiedad "NodeTypeProp" en lugar de "NodeType "¿?" Eso es porque no estamos siguiendo las convenciones de nomenclatura de C#. Usted debe prefijo a los nombres de tipo genérico con "T":

public interface IContainerBase<out TNodeType, TObjectType> 
    where TNodeType : NodeBase<TObjectType> where TObjectType : ObjectBase 

Answer 3

Puede puede cambiar la definición de contenedor normal de la siguiente manera:

public class ContainerNormal : ContainerBase<NodeBase<ObjectNormal>, ObjectNormal> 
{ 
} 

Answer 4

Hay un truco que puedes hacer que creo que obtendría lo que deseas. Podría darle a NodeBase un parámetro genérico adicional que debe heredar de NodeBase. Esto da una definición de tipo que parece recursiva, pero el compilador tiene una forma de resolverlo. Algo como esto debería funcionar:

public class NodeBase<T, TNode> : 
    where T : ObjectBase 
    where TNode : NodeBase<T, TNode> 
{ 
    private ContainerBase<TNode, T> container; 

    protected NodeBase(ContainerBase<TNode, T> owner) 
    { container = owner; } 
} 

public class ContainerBase<NodeType, ObjectType> : 
    where NodeType : NodeBase<ObjectType, NodeType> 
    where ObjectType : ObjectBase 
{ 
    public NodeType GetItem() { ... } 
} 

public class NodeNormal : NodeBase<ObjectNormal, NodeNormal> 
{ 
    public NodeNormal(ContainerNormal owner) : 
     base(owner) { } 
} 

public class ContainerNormal : 
    ContainerBase<NodeNormal, ObjectNormal> 
{ 
    //GetItem would return NodeNormal here 
}