C＃组成和多重继承设计

如何解决C＃组成和多重继承设计

我在为我的作业设计时遇到麻烦。 对于分配，我将具有2个继承层次结构，并且我需要模仿多个继承功能和叉积，因此robotDog，robotBigDog，robotSmallDog，attackRobotDog等...似乎只是进行多重继承最终将成为9个不同的类文件，可能不是最好的方法。

例如：

public class dog{
    public virtual void bark{ Console.WriteLine("woof")};
}

public class bigDog : dog{
    public override void bark{ Console.WriteLine("WOOF")};

}

public class smallDog : dog{
    public override void bark{ Console.WriteLine("arf arf")};

}



public class robot{
    public virtual void action{ Console.WriteLine("moves")}
}

public class attackRobot : robot{
    public virtual void action{ Console.WriteLine("attacks")}
}

public class serviceRobot : robot{
    public virtual void action{ Console.WriteLine("serves")}
}

我本来打算做一个包含狗和机器人的一类的双重构成，因为smallDog和bigDog可以代表狗，而AttackRobot和serviceRobot可以代表机器人。

public class robotDog{
dog myDog;
robot myRobot;
public robotDog(dog typeDog,robot typeRobot){
    myDog = typeDog;
    myRobot = typeRobot;
}
.
. various functionality 
.

}

使用双重合成功能并且有一个要求狗和机器人的构造函数是否可行？还是有其他方法来思考/解决这个问题？

解决方法

在C＃中不能具有多个继承，但是可以具有多个接口。 您可以使用界面来定义狗和机器人的外观，创建不同口味的狗和机器人，然后将它们组合到具有某些默认值（可以覆盖的默认值）的RobotDog类中，即

using System;

namespace ConsoleApp1
{

    public interface IDog
    {
        void bark();
    }

    public interface IRobot
    {
        void action();
    }

    public class dog : IDog
    {
        public virtual void bark() { Console.WriteLine("woof"); }
    }
    public class bigDog : dog
    {
        public override void bark() { Console.WriteLine("WOOF"); }
    }

    public class smallDog : dog
    {
        public override void bark() { Console.WriteLine("arf arf"); }
    }

    public class robot : IRobot
    {
        public virtual void action() { Console.WriteLine("buzz,click"); }
    }

    public class attackRobot : robot
    {
        public override void action() { Console.WriteLine("attacks"); }
    }

    public class serviceRobot : robot
    {
        public override void action() { Console.WriteLine("attacks"); }
    }

    public interface IRobotDog : IDog,IRobot
    {
        IDog dog { get; set; }
        IRobot robot { get; set; }
    }

    public class RobotDog : IRobotDog
    {
        public IDog dog { get; set; }
        public IRobot robot { get; set; }

        public RobotDog()
        {
            dog = new dog();
            robot = new robot();
        }
        public RobotDog(IDog dogType)
        {
            dog = dogType;
            robot = new robot();
        }
        public RobotDog(IRobot robotType)
        {
            dog = new dog();
            robot = robotType;
        }
        public RobotDog(IDog dogType,IRobot robotType)
        {
            dog = dogType;
            robot = robotType;
        }

        public void bark() { dog.bark(); }
        public void action() { robot.action(); }
    }

    class Program
    {
        static void Main(string[] args)
        {
            RobotDog robotDog = new RobotDog();
            robotDog.bark();
            robotDog.action();

            robotDog = new RobotDog(new bigDog(),new attackRobot());
            robotDog.bark();
            robotDog.action();

            robotDog = new RobotDog(new bigDog());
            robotDog.bark();
            robotDog.action();

            robotDog = new RobotDog(new attackRobot());
            robotDog.bark();
            robotDog.action();

            robotDog = new RobotDog();
            robotDog.dog = new bigDog();
            robotDog.bark();
            robotDog.action();
        }
    }
}

,

我想从Xavier提供的内容中扩展一点。界面无非是“合同”。以最简单的形式，任何继承接口的类都必须在其中声明函数/方法/属性。因此，以这种方式，任何其他试图依赖于其定义的公开组件的对象都知道它可以，并且不会丢失。现在，作为开发人员，您可以实现所需的功能，甚至可以拥有一个空函数，前提是该函数确实存在但不执行任何操作。

public interface IDog
{
    void bark();
}

public interface IRobot
{
    void action();
}

首先，只是简单的狗或机器人。请注意，每个接口都从接口实现了各自的“必需”方法。

public class Dog : IDog
{
    public void bark()
    {
        Console.WriteLine("Woof");

    }
}

public class Robot : IRobot
{
    public void action()
    {
        Console.Write("Activate jet pack,fly");
    }
}

以下注意，机器狗从没有真正的狗或机器人类。但是，它确实将每个接口的两个单独要求分别实现为两者的一个主要类。

public class RoboticDog : IDog,IRobot
{
    public void bark()
    {
        Console.WriteLine("Woof -beep- woof");

    }

    public void action()
    {
        Console.Write("Activate jet pack,flying with fur"); 
    }
}

现在，让我们看看它们如何单独运行。

    static void Main(string[] args)
    {
        object testDog = new Dog();
        object testRobot = new Robot();
        object testBoth = new RoboticDog();

        WhatCanIDo(testDog);
        WhatCanIDo(testRobot);
        WhatCanIDo(testBoth);
    }

    public void WhatCanIDo( object theThing )
    {
        // Here I am checking if the object is of a class type
        // the inherits from IDog.  If so,I can type-cast it as such
        // and then call its "bark()" method as required to exist from interface.
        if (theThing is IDog)
            ((IDog)theThing).bark();

        // likewise if the object has interface of an IRobot
        if (theThing is IRobot)
            ((IRobot)theThing).action();
    }

,

我为您创建了一个小型控制台应用程序，其中包含一些小技巧，这些技巧提示了如何在需要通过基类的接口时进行捕获，反之亦然。

SELECT publisherfullname
FROM publisher
WHERE publisherid IN (
  SELECT publisherid
  FROM published_by
  GROUP BY bookdescid
  HAVING count(bookdescid) > 1);