Интерфейс для двух почти идентичных веб-ссылок в C#

Question

У меня есть 2 веб рефов, которые я не могу изменить:

Они почти идентичны, но если ссылка на один только принимает ProperCase и другие Uppercamelcase.

Пример

не только реквизит является вещь, но и целые классами с его реквизитом и методами

@EDIT: К сожалению, я понял, что это гораздо сложнее, чем первоначально заявил:

Не только реквизит это предмет, но целые классы с его опорами и методами и внутренние классы. Хотя они используются только как структуры, внутренние классы имеют одинаковую проблему.

public class Foobar 
{ 
    public string Logmsgno; 
    public string Revno; 
    public string Reqsox; 
    public void Dosomething(); 
    public Barbaz Mybarbaz; 
    public List<quux> Myquuxlist; 
} 

И другие есть такие имена, как

public class FooBar 
{ 
    public string LogMsgNo; 
    public string RevNo; 
    public string ReqSox; 
    public void DoSomething(); 
    public BarBaz MyBarBaz; 
    public List<Quux> MyQuuxList; 
} 

Есть простой способ сделать интерфейс для обоих?

TIA!

Answer 1

Без надлежащего повторного факторинга, чтобы обновить все и изменить имена, да, вы МОЖЕТЕ с небольшим количеством дыма и зеркал. Создайте интерфейс, основанный на НОВЫХ значениях, которые вы ХОТИТЕ им, затем измените их, чтобы соответственно использовать getter/setter, чтобы сохранить оригинал, а не сломать его.

Чтобы расширить ваш расширенный вопрос. Вы должны настроить каждый из этих уровней тоже .. Определить интерфейс для класса и «Barbaz» «BarBaz», чтобы ваш внешний класс может иметь объект

public interface IYourBarBazInterface 
{ 
    string BarBazProp1 { get; set; } 
    string AnotherProp { get; set; } 
} 

public interface IQuux 
{ 
    int QuuxProp { get; set; } 
    string AnotherQuuxProp { get; set; } 
} 

public interface IYourCommonInterface 
{ 
    string LogMsgNo { get; set; }; 
    string RevNo { get; set; }; 
    string ReqSox { get; set; }; 

    // Similar principle of declarations, but interface typed objects 
    IYourBarBazInterface MyBarBaz { get; set; } 
    List<IQuux> MyQuuxList; 
    void DoSomething(); 
} 



public class Foobar : IYourCommonInterface 
{ 
    public string Logmsgno; 
    public string Revno; 
    public string Reqsox; 
    public void Dosomething(); 

    // your existing old versions keep same name context 
    // but showing each of their respective common "interfaces" 
    public IYourBarBazInterface mybarbaz; 
    public List<IQuux> myQuuxlist = new List<IQuux>(); 


    // these are the implementations of the interface... 
    public string LogMsgNo 
    { get { return Logmsgno; } 
     set { Logmsgno = value; } 
    } 

    public string RevNo 
    { get { return Revno; } 
     set { Revno = value; } 
    } 

    public string ReqSox 
    { get { return Reqsox; } 
     set { Reqsox = value; } 
    } 

    public void DoSomething() 
    { Dosomething(); } 

    // Now, the publicly common Interface of the "IYourCommonInterface" 
    // that identify the common elements by common naming constructs. 
    // similar in your second class. 
    public IYourBarBazInterface MyBarBaz 
    { get { return mybarbaz; } 
     set { mybarbaz = value; } 
    } 

    public List<IQuux> MyQuuxList 
    { get { return myQuuxlist; } 
     set { myQuuxlist = value; } 
    } 
} 


public class FooBar : IYourCommonInterface 
{ 
    // since THIS version has the proper naming constructs you want, 
    // change the original properties to lower case start character 
    // so the interface required getter/setter will be properly qualified 

    public string logMsgNo; 
    public string revNo; 
    public string reqSox; 

    public IYourBarBazInterface MyBarbaz; 
    public List<IQuux> Myquuxlist; 



    // these are the implementations of the interface... 
    public string LogMsgNo 
    { get { return logMsgMo; } 
     set { logMsgNo = value; } 
    } 

    public string RevNo 
    { get { return revNo; } 
     set { revNo = value; } 
    } 

    public string ReqSox 
    { get { return reqSox; } 
     set { reqSox = value; } 
    } 


    // Since your "DoSomething()" method was already proper case-sensitive 
    // format, you can just leave THIS version alone 
    public void DoSomething() 
    { .. do whatever .. } 



    public IYourBarBazInterface MyBarBaz 
    { get { return MyBarbaz; } 
     set { MyBarbaz = value; } 
    } 

    public List<IQuux> MyQuuxList 
    { get { return myquuxlist; } 
     set { myquuxlist = value; } 
    } 

} 

Answer 2

К сожалению, нет. Нет. C# чувствителен к регистру (включая интерфейсы). Чтобы оба они соответствовали одному интерфейсу, регистр должен совпадать. Если вы это сделаете, классы все равно будут одинаковыми.

Ваш единственный вариант - создать интерфейс, который использовал бы один из методов обсадной колонтитулы, реализовать его на обоих классах, а затем добавить код в один класс (с соглашением об именах, которое вы не выбрали) для прохождения через вызовы :

public interface IFooBar 
{ 
    string LogMsgNo { get; set; } 
    string RevNo { get; set; } 
    string ReqSox { get; set; } 
    void DoSomething(); 
} 

public class Foobar : IFooBar 
{ 
    public string Logmsgno; 
    public string Revno; 
    public string Reqsox; 
    public void Dosomething(); 

    public string LogMsgNo 
    { 
     get { return Logmsgno; } 
     set { Logmsgno = value; } 
    } 

    // And so on 
} 

UPDATE

После просмотра ваших изменений, вещи становятся гораздо более сложным. Вам нужно будет сделать то же самое со всеми внутренними классами, а затем ваши интерфейсы свяжутся с интерфейсами нижнего уровня. Такая же концепция, просто больше работы.

Answer 3

Если бы мне пришлось обработать это, я, скорее всего, напишу метод расширения для преобразования из одного типа в другой. Некоторая рефлексия будет выполнять большую часть работы. new Foobar().ToFooBar().ToFoobar() Или напишите класс, с которым я всегда буду взаимодействовать, и в последнем пункте вам нужно получить доступ к правильной реализации, вызовите ToFoobar().