Question

我有两个派生自基类X的类。基类包含类T的属性.X的两个子类都应包含一个派生自T的属性。

我想要实现的是在基类X中声明T的属性并将其用于多个方法中，同时在X的派生类中使用T的相同属性，但将其识别为派生类来自T的类，所以每次我想使用它时都不需要它。

我的一个解决方案是从基类中删除属性并为每个派生类的X复制方法，但这会破坏使用继承的目的。

这样的事情是可以实现的吗？

internal class TestObject
{
    public string ID;
    public XObject obj;
    //....
} 

internal class TestDocument : TestObject
{
    public XDocument obj; //<--- want to be able to call obj in my methods 
    //as if it were an XDocument type but relate to the obj property in the base class
    //....
} 

internal class XObject
{
    //....
}

internal class XDocument : XObject
{
    //....
}

Answer 1

泛型应该适合你：

class Base<T> where T: MyType
{
    T MyProperty { get; set; }
    public void DoSomething()
    {
        // do something with MyProperty
    }
}

MyType是Base内属性的基类。

然后在派生类中，您可以定义泛型约束，例如

class Derived : Base<DerivedType>
{
}

现在，Derived的实例的属性MyProperty的类型为DerivedType，而不是MyType。

因此，在您的情况下，TestObject应与此类似：

internal class TestObject<T> where T: XObject 
{
    public string ID;
    public T obj;
    //....
}    
internal class TestDocument : TestObject<XDocument>
{
    // obj is here of type XDocument
}

Answer 2

使属性的类型成为基类的通用参数：

class PropertyTypeBase { }
class PropertyTypeA : PropertyTypeBase { }

class Base<T> where T : PropertyTypeBase
{
    public T Property { get; }
}

class Foo :  Base<PropertyTypeA>
{
    public Foo()
    {
        PropertyTypeBase x = Property;
        PropertyTypeA a = Property;
    }
}

Answer 3

最简单的方法是使基类具有通用性，并约束从某个类派生的泛型参数：

class BaseProp { }
class DerivedPropA: BaseProp { }
class DerivedPropB : BaseProp { }

abstract class X<T>
    where T: BaseProp
{
    public T Value { get; set; }

    public abstract void With(T value);
}
class A : X<DerivedPropA>
{
    public override void With(DerivedPropA value)
    {
        this.Value = value;
    }
}

class B : X<DerivedPropB>
{
    public override void With(DerivedPropB value)
    {
        this.Value = value;
    }
}

Answer 4

这可以通过使用泛型来实现。

首先，让我解释一下示例类。让我们说这些是你的属性：

public class BaseHead {}
public class OrganicHead : BaseHead {}
public class CyborgHead : BaseHead {}

现在，您希望在个人课程中实现这些目标：

public class BaseCreature {}
public class OrganicCreature : BaseCreature {}
public class CyborgCreature : BaseCreature {}

解决方案：

public class BaseCreature<THead> where THead : BaseHead 
{
    public THead Head { get; set; }

    public BaseCreature(THead head)
    {
        this.Head = head;
    }       
}

我们制作BaseCreature通用
我们将THead类型限制为仅允许BaseHead或派生自BaseHead的类型

但是，我们还希望确保正确的生物（有机/机器人）只使用正确的头部（有机/机器人）。这可以通过从具有特定泛型类型的BaseCreature派生来完成：

public class OrganicCreature : BaseCreature<OrganicHead> 
{
    public OrganicCreature(OrganicHead head) : base(head) 
    {

    }
}

CyborgCreature类似。

假设你想让每个生物都可以使用每种类型的头部。如果这是你想要的，那么你需要保持通用参数通用：

public class OrganicCreature<THead> : BaseCreature<THead>  where THead : BaseHead 
{
    public OrganicCreature(THead head) : base(head)
    {

    }
}

CyborgCreature类似。

派生类具有派生属性

4 个答案: