0

我想访问基类中的派生类成员：

class Program
{
    static void Main(string[] args)
    {
        B b = new B();
        b.FieldTest = 5;
        b.MethodeTest();

    }
}

public class A
{
    public void MethodeTest()
    {
        //will return B
        Type t = this.GetType();
        Console.WriteLine(t);

        var temp = ???.FieldTest;
        //i want that these return 5
        Console.WriteLine(temp);
        Console.ReadLine();
    }
}

public class B:A
{
    public int FieldTest;
}

我不确定这些是可能的，但我希望你有任何想法来解决它。

谢谢

4

6 回答 6

6

好吧，您可以使用动态类型来做到这一点：

dynamic dynamicThis = this;
var temp = dynamicThis.FieldTest;

...但这是一个非常奇怪的要求。如果this实际上只是的一个实例A，或者实际上是一个没有此类成员的不同子类的实例，您会期望发生什么？基本上这是一个狡猾的设计。

目前尚不清楚您要实现什么，但您可能希望创建A一个具有所有子类都可以实现的抽象属性的抽象类。（请注意，您不能使字段抽象...）

如果这没有帮助，请提供更多详细信息，说明您首先尝试这样做的原因。

于 2013-02-26T16:19:29.493 回答
1

你不能按照你的例子展示它的方式来做到这一点。基类对派生类的实现一无所知。

但是，您可以做的是在基类中定义一个虚拟方法或属性，可以在派生类中实现，并返回所需的值（模板方法模式）：

public class A
{
   protected virtual int FieldTest { get { return 0; } }

   public void TestMethod()
   {
        Console.WriteLine ("FieldTest: " + FieldTest);
   }

}

public class B : A
{
   protected override int FieldTest { get { return 5; } }
}

public class C : A 
{
   protected override int FieldTest { get { return 10; } }
}
于 2013-02-26T16:19:11.863 回答
1

基类无权访问派生类的字段。需要这样做可能是应用程序结构错误。

于 2013-02-26T16:22:16.747 回答
0

使您的方法虚拟化，并在派生类中覆盖它。您可以调用方法的基类实现，也可以添加特定于派生类的新行为：

public class A
{
    public virtual void MethodeTest()
    {
        //will return B
        Type t = this.GetType();
        Console.WriteLine(t);
        Console.ReadLine();
    }
}

public class B:A
{
    public int FieldTest;

    public override void MethodeTest()
    {
        base.MethodeTest(); // base class implementation

        Console.WriteLine(FieldTest); // FieldTest is available here
        Console.ReadLine();
    }
}
于 2013-02-26T16:20:23.443 回答
0

除非每个A人都有一个FieldTest属性，否则你不能在不检查 theA是否实际上是一个B.

var b = a as B;
if (b != null)
{
   b.FieldTest;
}
于 2013-02-26T16:21:09.443 回答
0

您不必从基类访问派生类成员。相反，您的设计应该允许更多派生类型提供实现，然后调用基类。或者，如果调用在多个派生类型之间共享，那么逻辑应该属于基类。

因为您似乎需要使用单个方法执行调用，所以正常的覆盖应该可以工作。一个人为的例子，

class Animal
{
   public virtual bool Speak() { //return true.  Assume all animals make a sound }
}

class Dog : Animal
{
  public override bool Speak() { //Bark and return base.Speak() }
}

现在如果 Dog 定义Eat()， Animal 不应该看执行derived.Eat。相反，Eat 应该在 Animal 中定义并由派生类调用。

于 2013-02-26T16:37:25.470 回答