具有派生属性的派生类

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的实例具有DerivedType类型的MyProperty属性，而不是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派生的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是类似的。