Свободные интерфейсы и множественное наследование в 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 тоже Transport.

Если это не отношение «есть», это не наследование. И это объяснение того, почему множественное наследование не поддерживается в C # и Java, и это не приветствуется большинством людей, которых я знаю в C ++. Объект почти никогда не бывает двумя вещами одновременно.

Не злоупотребляйте наследованием просто для экономии строк кода. Даже если сохранение строк кода было законной целью (с чем я не согласен), в этом даже нет необходимости. Здесь вам могут помочь две другие конструкции.

Во-первых, об отношении. То, что вы ищете, - это совершенно другое отношение. Не «является», а «можно использовать как». Вот тут-то и пригодятся интерфейсы. Интерфейсы определяют, в качестве чего можно использовать объект. Таким образом, у вас может быть два интерфейса IBox и ICircle. Тогда ваша CircleAndBox вещь может реализовать оба интерфейса, таким образом, укажите, что она может использоваться как оба.

Во-вторых, вы можете использовать еще одно отношение, чтобы облегчить жизнь. Вы не сохраните строки кода. Но вы убедитесь, что ваш CircleAndBox всегда имеет правильное поведение, определенное в классах Circle и Box. Для этого вы можете использовать агрегацию вместе с шаблоном делегирования. Агрегация - это отношение, которое говорит «имеет». Поэтому сделайте свой CircleAndBox класс частным объектом Circle и частным объектом Box, затем реализуйте интерфейсы ICircle и IBox, просто вызвав соответствующий метод / свойство / событие для соответствующих частных объектов, и верните то, что они возвращают.

Presto, у вас есть класс, который имеет (агрегацию) экземпляр 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. Я не уверен, что это послужит цели.

Кроме того, это не сработает, если вы не контролируете хотя бы один из классов, которые хотите наследовать.