Question

所以我只想为我的所有函数使用一个类Object，但我不想直接使用该类，而是需要访问派生类的成员。

举个例子：

class A {
    public A() {

    }

    public void DoSomething() { }
}

class B : A {
    public B() {

    }

    public void DoSomethingBetter() { }
}

class C : A {
    public C() {

    }

    public void DoSomethingBest() { }
}

class Runner {
    public static void Main(String[] args) {
        A objB = new B();
        objB.DoSomethingBetter(); //Won't compile

        A objC = new C();
        objC.DoSomethingBest(); //Won't compile
    }
}

我不想将它们初始化为B objB = new B（），这不是目的，我已经知道这可能是一个解决方案。我需要为此使用父类。

由于

Answer 1

如果您要使用不同的名称声明方法，则必须在代码中实例化显式类型。

如果方法都以不同的方式执行相同的功能，则应该从基类覆盖该方法，而不是使用其他名称重新实现它。

public class A
{
    public virtual void DoSomething()
    {
         // some implementation
    }
}

public class B : A
{
    public override void DoSomething()
    {
        // body of DoSomethingBetter
    }
}

public class C : A
{
    public override void DoSomething()
    {
        // body of DomSomethingBest
    }
}

您的应用程序正文将简化为：

A b = new B();
A c = new C();

b.DoSomething() // uses logic of DoSomethingBetter
c.DoSomething() // uses logic of DoSomethingBest

Answer 2

你正在寻找的可能是最重要的吗？

您可以使A类抽象，以及其中的方法。然后将实际的实现放在派生类中：

abstract class A {

    public A() {
    }

    public abstract void DoSomething() { }
}

class B : A {

    public B() {
    }

    public override void DoSomething() { }
}

class C : A {

    public C() {
    }

    public override void DoSomething() { }
}

class Runner {
    public static void Main(String[] args) {
        A objB = new B();
        objB.DoSomething(); // Uses the B implementation

        A objC = new C();
        objC.DoSomething(); // Uses the C implementation
    }
}

Answer 3

不是100％肯定你要完成的任务，但如果出于某种原因你不想像其他人所建议的那样覆盖，这是一个选项。

class A {
    public A() {

    }

    public void DoSomething() { }
}

class B : A {
    public B() {

    }

    public void DoSomethingBetter() { }
}

class C : A {
    public C() {

    }

    public void DoSomethingBest() { }
}

class Runner {
    public static void Main(String[] args) {
        A objB = new B();
        if (objB is B)
            ((B)objB).DoSomethingBetter();

        A objC = new C();
        if (objC is C) 
            ((C)objC).DoSomethingBest();
    }
}

编辑：执行此操作的更有效方法如下（它将运行2个强制转换而不是4个）：

class A {
    public A() {

    }

    public void DoSomething() { }
}

class B : A {
    public B() {

    }

    public void DoSomethingBetter() { }
}

class C : A {
    public C() {

    }

    public void DoSomethingBest() { }
}

class Runner {
    public static void Main(String[] args) {
        A objB = new B();
        B objAB = objB as B;
        if (objAB != null)
            objAB.DoSomethingBetter();

        A objC = new C();
        C objAC = objC AS C;
        if (objAC != null) 
            objAC.DoSomethingBest();
    }
}

Answer 4

在没有看到您的实际代码的情况下，我倾向于同意其他所有人，他们说您应该再次尝试使用简单的覆盖来解决您的问题。

尽管如此，我还是有一些玩弄这个问题的乐趣，并设法编写了一个没有投射的解决方案。

享受！

public class BattlePlan
{
    public Action<Puppy> ExecutePuppyAttack { get; set; }
    public Action<Pigeon> ExecutePigeonAttack { get; set; }
}

public abstract class Animal
{
    public abstract void Attack(BattlePlan battlePlan);
}

public class Puppy : Animal
{
    public void Bite(bool barkFirst)
    {
        // optionally bark at the intruder,
        // then bite as deeply as needed.
    }

    public override void Attack(BattlePlan battlePlan)
    {
        battlePlan.ExecutePuppyAttack(this);
    }
}

public class Pigeon : Animal
{
    public void Bombard(int altitude)
    {
        // ewww. nuff said.
    }

    public override void Attack(BattlePlan battlePlan)
    {
        battlePlan.ExecutePigeonAttack(this);
    }
}


public class EvilMasterMind
{
    private bool _puppiesMustBark = true;
    private int _pigeonAltitude = 100;

    public void Attack()
    {
        var battlePlan = new BattlePlan
        {
            ExecutePuppyAttack = e => e.Bite(_puppiesMustBark),
            ExecutePigeonAttack = e => e.Bombard(_pigeonAltitude)
        };

        var animals = new List<Animal>
        {
            new Puppy(),
            new Pigeon()
        };

        foreach (var animal in animals)
        {
            animal.Attack(battlePlan);
        }

    }
}

C＃Base和2个派生类初始化

4 个答案: