Интерфейс срещу множествено наследяване в C#

Защо не съдържате екземпляр от клас A и клас B в клас C. Използвайте Композиция

class C
{
//class C properties
public A objA{get;set;}
public B objeB{get;set;}
}

След това можете да получите достъп

C objc = new C();
objc.objA.Property1 = "something";
objc.objB.Property1 = "something from b";

вижте статията Композиция срещу наследяване

РЕДАКТИРАНЕ:

ако използвам интерфейс вместо клас A, B (в интерфейса не можем да съдържа полета)

Е, интерфейсите не могат да съдържат полета, ако дефинирате такова, ще получите грешка при компилиране. Но интерфейсите могат да съдържат свойства с изключение на това, че не можете да посочите спецификатори за достъп, тъй като всички елементи на интерфейса се считат за public. Можете да дефинирате свойства за интерфейс „A“ и „B“ като:

public interface IA
{
     int Property1 { get; set; }
}


public interface IB
{
    int Property2 { get; set; }
}

След това можете да ги внедрите в клас C като:

public class C : IA, IB
{
    public int Property1 { get; set; }
    public int Property2 { get; set; }
}

По-късно можете да ги използвате като:

C objC = new C();
objC.Property1 = 0;
objC.Property1 = 0;

Интерфейсите могат да имат свойства, но ако искате да използвате и методите, може да се наложи инжектиране на композиция или зависимост.

Interface A
{
   int PropA {get; set;}
}


Interface B
{
  int PropB {get; set;}
}

class C : A, B
{

}

// поставя тези изрази в някакъв метод

C c = new C();
c.PropA = 1;
c.PropB = 2;

Интерфейсите не са решение за липсата на множествено наследяване. Те просто не правят едни и същи неща. Най-близкото, което можете да получите, е да направите C да бъде подклас на A и да има свойство от тип B. Може би, ако ни кажете какво трябва да правят A, B и C, можем да дадем отговор, който по-добре отговаря на вашите нужди...

Интерфейсите могат да съдържат свойства, т.е.:

public interface IFoo
{
    string Bar { get; set; }
}

Помислете как свойствата са изложени по различен начин на клиента, когато използвате заместник-композиция на наследяване.

Наследство:

    var myCclass = new Cclass;
    myClass.propertyA;
    myClass.propertyB;
    myClass.propertyC;
    // and so on

състав:

 var myCclass = new Cclass;
    myCclass.bClass.propertyB;
    myCclass.aClass.propertyA;
    myCclass.propertyC;

Наследяването дава по-чист API - нещо добро.

Композицията изисква да знам нещо за вътрешната структура на класа - не е толкова добро нещо. Това нарушава закона на Деметра - по-известен като принципа на най-малкото знание. Можете да заобиколите това, като имате свойства на Cclass, които едно към едно излагат/връщат свойствата на Bclass & Aclass - и вашите препратки към Bclass & Aclass тогава ще бъдат частни или защитени в Cclass. И Cclass има пълен контрол върху това, което е изложено, вместо да зависи от A & B, за да няма публични неща, които не сте изложили.

Съгласен съм с @AlejoBrz, интерфейсите не са подходящи тук.

Аз също давам знак за „предпочитане на композицията пред наследяването“. Но това е насока, а не твърдо правило.

Интерфейсите не могат да съдържат полета, но могат да съдържат свойства. В повечето случаи свойствата могат да се използват като полета и не е трудно да се каже:

interface ISomeProperties
  {int prop1 {get;set;}; string prop2 {get; set;}}
interface IMoreProperties
  {string prop3 {get;set;}; double prop4 {get; set;}}
interface ICombinedProperties : ISomeProperties, IMoreProperties; 
  { }

Като се има предвид място за съхранение от тип ICombinedProperties, човек може да получи достъп до всичките четири свойства директно и без суетене.

Трябва да се отбележи обаче, че има няколко неща, които могат да се правят с полета, които не могат да се правят със свойства. Например, докато поле може да бъде предадено на Interlocked.Increment, свойство не може; опитът за Interlocked.Increment свойство чрез копирането му в променлива, извикването на Interlocked.Increment върху това и след това копирането на резултата обратно в свойството може да "работи" в някои случаи, но ще се провали, ако две нишки се опитат да направят едно и също нещо едновременно (би е възможно, например и двете нишки да прочетат стойност 5, да я увеличат до 6 и след това да запишат обратно 6, докато две нишки извикват Interlocked.Increment на поле, което първоначално е било равно на 5, гарантирано ще даде 7.).

За да се заобиколи това, може да е необходимо интерфейсът да включва някои методи, които или изпълняват взаимосвързан метод на поле (например може да има функция, която извиква Interlocked.Increment на полето и връща резултата) и/или включва функции, които ще извикване на определен делегат с поле като параметър ref (напр.

delegate void ActionByRef<T1>(ref T1 p1);
delegate void ActionByRef<T1,T2>(ref T1 p1, ref T2 p2);
delegate void ActionByRef<T1,T2,T3>(ref T1 p1, ref T2 p2, ref T3 p3);
interface IThing
{ // Must allow client code to work directly with a field of type T.
  void ActOnThing(ActionByRef<T> proc);
  void ActOnThing<ExtraT1>(ActionByRef<T, ExtraT1> proc, ref ExtraT1 ExtraP1);
  void ActOnThing<ExtraT1, ExtraT2>
       (ActionByRef<T> proc, ref ExtraT1 ExtraP1, ref ExtraT2 ExtraP2);
}

Като се има предвид екземпляр на интерфейса, човек може да направи нещо като:

  theInstance.ActOnThing(
    (ref int param) => Threading.Interlocked.Increment(ref param)
  );

или, ако имаше локални променливи maskValue и xorValue и искаше атомно да актуализира полето с field = (field & maskValue) ^ xorValue:

  theInstance.ActOnThing(
    (ref int Param, ref int MaskValue, ref int XorValue) => {
        int oldValue,newValue;
        do {oldValue = param; newValue = (oldValue & MaskValue) ^ XorValue;
        while (Threading.Interlocked.CompareExchange(ref Param, newValue, oldValue) !=
          oldValue),
    ref maskValue, ref xorValue);
  );

Ако имаше само няколко вида действия, които човек би искал да извърши върху полетата, най-лесно би било просто да ги включите в интерфейса. От друга страна, подходът, даден по-горе, позволява на интерфейса да изложи своите полета по такъв начин, че да позволи на клиентите да извършват произволни последователности от действия върху тях.