Плавни интерфейси и множествено наследяване в C#

Нека CircleAndBox не наследява от нито един клас, а по-скоро препраща към обекти от тези класове. Ще трябва да предефинира методите от всеки клас. Можете да добавите неявни преобразувания към Circle и Box, за да позволите използването му в контексти, където се очакват препратки към тези обекти.

public class CircleAndBox
{
    public Circle Circle { get; private set; }
    public Box Box { get; private set; }

    public CircleAndBox()
    {
        Circle = new Circle();
        Box = new Box();
    }

    public CircleAndBox Radius(string radius)
    {
        Circle.Radius(radius);
        return this;
    }

    public CircleAndBox Width(string width)
    {
        Box.Width(width);
        return this;
    }

    public static implicit operator Circle(CircleAndBox self)
    {
        return self == null ? null : self.Circle;
    }

    public static implicit operator Box(CircleAndBox self)
    {
        return self == null ? null : self.Box;
    }
}

Имайте предвид, че имплицитните преобразувания няма да запазят типа на обекта, така че не трябва да използвате тази техника за предаване на CircleAndBox към метод, приемащ Box и очаквайки резултатът от другата страна да бъде CircleAndBox.

CircleAndBox cb = new CircleAndBox();

// Implicit conversion, b contains a Box object.
Box b = cb;

// Compile-time error CS0030.
cb = (CircleAndBox)b;

Наследяване означава "е а".

Ball е RoundThing. Circle е RoundThing. Box е SquareThing. Lamborghini е Car, а Car е Transport. Bus и Bicycle също са Transports.

Ако не е връзка „е а“, това не е наследство. И в това е обяснението защо множественото наследяване не се поддържа в C# и Java и не се препоръчва от повечето хора, които познавам в C++. Един обект почти никога не е две неща едновременно.

Не злоупотребявайте с наследяването само за да запазите кодови редове. Дори ако запазването на кодови редове е легитимна цел (с което не съм съгласен), то дори не е необходимо. Две други конструкции могат да ви помогнат тук.

Първо, за връзката. Това, което търсите, е съвсем различна връзка. Не "е", а "може да се използва като". Това е мястото, където идват интерфейсите. Интерфейсите определят за какво може да се използва даден обект. Така че можете да имате два интерфейса IBox и ICircle. След това вашето CircleAndBox нещо може да имплементира и двата интерфейса, като по този начин указва, че може да се използва и като двата.

Второ, можете да използвате още едно отношение, за да улесните живота си. Няма да запазвате кодови редове. Но ще се уверите, че вашият CircleAndBox винаги има правилното поведение, дефинирано в класовете Circle и Box. За това можете да използвате агрегиране, заедно с модела на делегиране. Агрегирането е релация, която казва "има". Така че накарайте вашия CircleAndBox клас да има частен Circle обект и частен Box обект, след което имплементирайте интерфейсите ICircle и IBox просто като извикате съответния метод/свойство/събитие на съответните частни обекти и върнете това, което връщат.

Така че, вие имате клас, който има (агрегиране) Circle и Box екземпляр, към който действително да прехвърлите работата, който ги излага, като има същите методи (делегиране) и които по този начин могат да бъдат използва се като(интерфейс) кръгикато кутия.

Използвайте интерфейси:

IBox и ICircle

public interface IBox
{
    Circle Width(string width)
}

public interface ICircle
{
    Circle Radius(string radius)
}

public class Circle : ICircle
{
    private int _radius { get; set; }

    public Circle Radius(string radius)
    {
        _radius = radius;
        return this;
    }
}

public class Box : IBox
{
    private int _width { get; set; }

    public Circle Width(string width)
    {
        _width = width;
        return this;
    }
}

public class CircleAndBox : ICircle, IBox
{
    // should contain methods from both Circle and Box, but return CircleAndBox
}

Не мисля, че можете да направите точно това, което очаквате, тъй като C# (и .Net като цяло) не поддържа множествено наследяване на класове. Можете да наследите от един клас и да реализирате интерфейс.

Например:

interface iBox
{
  iBox Width(string width); //Assuming you want Box here and not Circle
}

След това имате Box

class Box : iBox ...

Сега можете да имате

public class CircleAndBox : Circle, iBox
{
private Box _helper;
public iBox Width(string width) { _helper.Width(width); return this; }
}

Това не е точно това, което искате, но според мен е толкова близо, колкото позволява C#. Ако желаете да използвате слаби типове, има и метод за делегиране за предаване на неща към _helper без изрично прилагане на всеки метод. При директно делегиране обаче няма да върнете вашия обект CircleAndBox, а вместо това обекта _helper. Не съм сигурен, че това ще послужи за целта.

Също така, това няма да работи, ако не контролирате поне един от класовете, които искате да наследите.