C# Mehrfachvererbung

Question

Derzeit im Studium der C# mit ASP.NET MVC 4 mit Code First Approach. Ich bin Visual Basic Developer und jetzt möchte ich C# starten. Und jetzt kam ich über die Situation, in der ich mehrfache Vererbung handhaben muss. Aber es ist mit Klasse nicht möglich, dachte ich. Also, wie soll ich diese Klassen verwalten ich habe:

//I have the Following Person Class which Hold Common Properties 
//and a Type of Person e.g : Student, Faculty, Administrative 
public class Person 
{ 
    public int Id { get; set; } 
    public string FirstName { get; set; } 
    public string LastName { get; set; } 
    public string Type { get; set; } 
} 


//This is my Student Class, which is Derived from Person 
public class Student:Person 
{ 
    public DateTime DateOfBirth { get; set; } 
    public DateTime EnrollmentDate { get; set; } 
    public string Remarks { get; set; } 


    public bool Approved { get; set; } 
    public DateTime ApprovedDate { get; set; } 
    public int ApprovedUserId { get; set; } 
} 


//This is my Faculty Class, which is also Derived from Person 
public class Faculty : Person 
{ 
    public DateTime HiredDate { get; set; } 


    public bool Approved { get; set; } 
    public DateTime ApprovedDate { get; set; } 
    public int ApprovedUserId { get; set; } 
} 

Was ich möchte, ist genehmigt, ApprovedDate und ApprovedUserId ebenfalls üblich. Ich will diese Eigenschaften angeben wie:

public class Approve { 
    public bool Approved { get; set; } 
    public DateTime ApprovedDate { get; set; } 
    public int ApprovedUserId { get; set; } 
} 

Und wollen, wie verwenden:

public class Student:Person,Approve 
{ 
    public DateTime DateOfBirth { get; set; } 
    public DateTime EnrollmentDate { get; set; } 
    public string Remarks { get; set; } 
} 

Und ich kann diese Dinge nicht innerhalb PERSON setzen. Weil ich dies zu einer anderen Klasse verwenden muss, aber das sind keine Personen.

Dann, wie ich dies tun erreichen ...

Bitte geben Sie mir ein Beispiel für die oben beschriebene Situation.

Bitte Hilfe. Und vielen Dank im Voraus.

Answer 1

Eine mögliche Lösung wäre, um Ihre Hierarchie zu ändern:

public class PersonWithApprove : Person { // TODO: replace with non disgusting name 
    public bool Approved { get; set; } 
    // etc... 
} 

public class Student : PersonWithApprove { 
} 

public class Faculty : PersonWithApprove { 
} 

Oder Sie könnten eine Schnittstelle erstellen:

public interface IApprove { 
    bool Approved { get; set; } 
    // etc 
} 

public class Student : Person, IApprove { 
} 

Das könnte dir auch verlasse die Klasse Approve als solche und habe Klassen mit einer Eigenschaft dieses t yp:

public class Student : Person { 
    Approve _approve = new Approve(); 
    public Approve Approve { 
     get { return _approve; } 
    } 
} 

Answer 2

können Sie Composite-Muster verwenden

public class Student:Person 
    { 
     public Approve App { get; set; } 
     public DateTime DateOfBirth { get; set; } 
     public DateTime EnrollmentDate { get; set; } 
     public string Remarks { get; set; } 
    } 

Answer 3

Es ist ein gutes Beispiel, IMHO, Schnittstellen hier zu verwenden, so etwas wie die:

// Interfaces: 

    // General person 
    public interface IPerson { 
    int Id { get; set; } 
    string FirstName { get; set; } 
    string LastName { get; set; } 
    string Type { get; set; } 
    } 

    // Approvable person 
    public interface IApprovable { 
    bool Approved { get; set; } 
    DateTime ApprovedDate { get; set; } 
    int ApprovedUserId { get; set; } 
    } 

    // Student is a IPerson + IApprovable 
    public interface IStudent: IPerson, IApprovable { 
    DateTime DateOfBirth { get; set; } 
    DateTime EnrollmentDate { get; set; } 
    } 

    // So classes will be 

    public class Approve: IApprovable { 
    ... //TODO: Implement IApprovable interface here 
    } 

    public class Faculty: IPerson, IApprovable { 
    public DateTime HiredDate { get; set; } 

    ... //TODO: Implement IPerson interface here 
    ... //TODO: Implement IApprovable interface here 
    } 

    public class Student: IStudent { 
    public string Remarks { get; set; } 

    ... //TODO: Implement IStudent interface here 
    } 

Answer 4

Kurzantwort

stattdessen mit Hilfe von Schnittstellen Betrachten, das für Mehrfachvererbung ermöglichen und kann mit dem Schlüsselwort interface deklariert werden.

Lange Antwort

Vererbung von mehreren Basisklassen in C# ist illegal. Klassen können nur eine Basisklasse haben, während sie eine beliebige Anzahl von Schnittstellen implementieren können. Es gibt several reasons for this, aber es kommt meistens darauf an, dass Mehrfachvererbung viel mehr Komplexität in eine Klassenhierarchie einführt.

Schnittstellen werden verwendet, um eine Gruppe allgemeiner Funktionen (Methoden und Eigenschaften) zu deklarieren, die von der Klasse implementiert werden müssen.

Ihre vorhandenen Code ändern Schnittstellen (statt Mehrfachvererbung) zu verwenden, können Sie Folgendes tun:

public interface IApprove // Defines a set of functionality that a class must implement. 
{ 
    // All these properties must be inherited as public when implemented. 
    bool Approved { get; set; } // Property declaration. 
    DateTime ApprovedDate { get; set; } 
    int ApprovedUserId { get; set; } 
} 

public class Student : Person, IApprove 
{ 
    public DateTime DateOfBirth { get; set; } 
    public DateTime EnrollmentDate { get; set; } 
    public string Remarks { get; set; } 

    #region IApprove Implementation 

    private bool _approved; // Private variable that is accessed through the 'Approved' property of the 'IApprove' interface. 
    public bool Approved // Defines 'Approved' inherited from IApprove 
    { 
     get { return _approved; } 
     set { _approved = value; } 
    } 

    private DateTime _approvedDate; 
    public DateTime ApprovedDate // Defines 'ApprovedDate' inherited from IApprove. 
    { 
     get { return _approvedDate; } 
     set { _approvedDate = value; } 
    } 

    private int _approvedUserId; 
    public int IApprove.ApprovedUserId // Alternative syntax to define an interfaces property. 
    { 
     get { return _approvedUserId; } 
     set { _approvedUserId = value; } 
    } 

    #endregion 
} 

Dieser Ansatz die Implementierung eines IApprove abstrahiert Schnittstelle und, wie Mehrfachvererbung, erlaubt der Benutzer auf Objekte, die implementieren IApprove zu implementieren, noch ihre konkrete Art ist unbekannt (oder irrelevant).

Weitere Informationen über die Verwendung von Schnittstellen in C# beziehen sich auf:

http://msdn.microsoft.com/en-us/library/87d83y5b.aspx

Answer 5

folgendes Beispiel verwendet es zwei Schnittstellen:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 


//////// 
//////// 
/// Multiple Inheritance With Interfaces 

public interface Interface1 
{ 
    void func1(); 
    void fun(); 
} 

public interface Interface2 
{ 
    void func2(); 
    void fun(); 
} 

public class MyTestBaseClass : Interface1, Interface2 
{ 
    void Interface1.func1() 
    { 
     Console.WriteLine("From MyInterface1 Function()"); 
     return; 
    } 


    void Interface2.func2() 
    { 
     Console.WriteLine("From MyInterface2 Function()"); 
     return; 
    } 

    void Interface1.fun() 
    { 
     Console.WriteLine("fun1()"); 
    } 

    void Interface2.fun() 
    { 
     Console.WriteLine("fun2()"); 
    } 


    public static void Main() 
    { 
     MyTestBaseClass myclass = new MyTestBaseClass(); 
     ((Interface1)myclass).func1(); 
     ((Interface2)myclass).func2(); 
    } 

} 

Answer 6

Einige grundlegende Beispiel mit der Decorator Designmuster:

public class Class1 
{ 
    public void Method1() 
    { 
     Console.write($"Class1: Method1, MyInt: {MyInt}"); 
    } 

    public int MyInt { get; set; } 
} 

public class Class2 
{ 
    public void Method2() 
    { 
     Console.write($"Class2: Method2, MyInt: {MyInt}");  
    } 

    public int MyInt { get; set; } 
} 

public class MultipleClass 
{ 
    private Class1 class1 = new Class1(); 
    private Class2 class2 = new Class2(); 

    public void Method1() 
    { 
     class1.Method1(); 
    } 
    public void Method2() 
    { 
     class2.Method2(); 
    } 

    private int _myInt; 
    public int MyInt 
    { 
     get { return this._myInt; } 
     set 
     { 
      this._myInt = value; 
      class1.MyInt = value; 
      class2.MyInt = value; 
     } 
    } 
} 

Demo: erste

MultipleClass multipleClass = new MultipleClass(); 
multipleClass.Method1(); //OUTPUT: Class1: Method1, MyInt: 1 
multipleClass.Method2(); //OUTPUT: Class2: Method2, MyInt: 1 
multipleClass.MyInt = 1;