Gemeinsame Schnittstelle für zwei Drittanbieter-Klassen, die ich nicht kontrolliere. Externer Polymorphismus?

Question

Ich brauche hier eine kleine Musterrichtung. Neu in C#.

Ich arbeite mit einem Devipaket von Drittanbietern, das einen Webdienst umschließt. Es gibt zwei spezifische Klassen, mit denen ich mich befasse, die zwar relativ ähnlich sind, sich aber in zwei verschiedenen Namespaces im DevKit befinden, und es gibt keine gemeinsame Basisklasse. Ich möchte jedoch beide gegen eine gemeinsame Schnittstelle programmieren. Ich habe willkürlich eine Implementierung zusammengeschustert, die den Wrapper im Wesentlichen umhüllt, aber ich bin ziemlich sicher, dass es nicht die effizienteste Methode aufgrund des unaufhörlichen Castings ist.

Ich habe durch Artikel über Adapter, Schnittstellen, Erweiterungsmethoden usw. gegraben. Aber ich habe wenig Zeit, also wenn ich einen Schub in eine Richtung bekommen könnte, würde das sehr geschätzt werden.

using ThirdParty.TypeA.Employee; 
using ThirdParty.TypeB.Employee; 

public class Employee 
{ 
    private object genericEmployee; 

    private EmployeeType empType; 

    public enum EmployeeType 
    { 
      TypeA = 0; 
      TypeB = 1; 
    } 

    public Employee(Object employee, EmployeeType type) 
    { 
     genericEmployee = employee; 
     empType = type; 
    } 

    public String Name 
    { 
     if (empType == EmployeeType.TypeA) 
      return (ThirdParty.TypeA.Employee)genericEmployee.Name; 
     else 
      return (ThirdParty.TypeB.Employee)genericEmployee.Name; 
    } 

    public String Age 
    { 
     if (empType == EmployeeType.TypeA) 
      return (ThirdParty.TypeA.Employee)genericEmployee.Age; 
     else 
      return (ThirdParty.TypeB.Employee)genericEmployee.Age; 
    } 
} 

Rev 2:

class EmployeeTypeAAdapter : TypeA, IEmployeeAdapter 
{ 
    TypeA _employee; 
    public EmployeeTypeAAdapter(TypeA employee) 
    { 
     _employee = employee 
    } 

    public String Name 
    { 
     get { return _employee.Name; } 
     set { _employee.Name = value; } 
    } 

     public String Balance 
     { 
     get 
     { 
      if (_employee.Balance != null) 
      { 
       decimal c = _employee.Balance.Amount; 
       return String.Format("{0:C}", c); 
      } 
      else 
      { 
       return ""; 
      } 
      } 
     } 

     //... 
} 

class EmployeeTypeBAdapter : TypeB, IEmployeeAdapter 
{ 
    TypeB _employee; 
    public EmployeeTypeAAdapter(TypeB employee) 
    { 
     _employee = employee 
    } 

    public String Name 
    { 
     get { return _employee.Name; } 
     set { _employee.Name = value; } 
    } 

     public String Balance 
     { 
     get 
     { 
      if (_employee.Balance != null) 
      { 
       decimal c = _employee.Balance.Amount; 
       return String.Format("{0:C}", c); 
      } 
      else 
      { 
       return ""; 
      } 
      } 
     } 

    //.... 
} 

Answer 1

versuchen, diesen Ansatz:

public interface IEmployeeAdapter 
{ 
    string Age { get; set; } 
    string Name { get; set; } 
} 

class EmployeeTypeAAdapter : TypeA, IEmployeeAdapter 
{ 
    public EmployeeTypeAAdapter(TypeA employee) { } 
} 

class EmployeeTypeBAdapter : TypeB, IEmployeeAdapter 
{ 
    public EmployeeTypeBAdapter(TypeB employee) { } 
} 

public static class EmployeeAdapterFactory 
{ 
    public static IEmployeeAdapter CreateAdapter(object employee, EmployeeType type) 
    { 
     switch (type) 
     { 
      case EmployeeType.TypeA: return new EmployeeTypeAAdapter((TypeA)employee); 
      case EmployeeType.TypeB: return new EmployeeTypeBAdapter((TypeB)employee); 
     } 
    } 

    // or without enum 

    public static IEmployeeAdapter CreateAdapter(object employee) 
    { 
     if (employee is TypeA) return new EmployeeTypeAAdapter((TypeA)employee); 
     if (employee is TypeB) return new EmployeeTypeABdapter((TypeB)employee); 
    } 

    // or better introduce sort of type map 
} 

Ein weiterer Eigenname ist EmployeeProxy, wie Sie bevorzugen.

Answer 2

Was Sie versuchen, ist bekannt als Duck typing. Sie können dies mithilfe von Adapterklassen und einer gemeinsam genutzten Schnittstelle durchführen, aber das manuelle Erstellen dieser Adapter erfordert viel repetitiven Klebecode. Eine Möglichkeit, den Klebercode zu schreiben, besteht darin, den Adaptertyp dynamisch zu konstruieren. Sie können dies selbst über IL Emit tun (eine lohnende Übung, wenn Sie noch nie eine Chance hatten, damit zu spielen, obwohl es einige Grenzfälle zu beachten gibt.) Wenn Sie nur daran interessiert sind, es zum Laufen zu bringen, Sie können jedoch auch this project als Startpunkt auswählen. Der C# -Dynamic-Typ könnte ebenfalls verwendet werden (und endet mit der gleichen Code-Generierung im Hintergrund), aber Sie erhalten keine Referenz, die Sie an nicht-dynamischen Code weitergeben können, als wäre es eine Schnittstelle Art.