Интерфейс для двух почти идентичных веб-ссылок в 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;
}

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

ТИА!

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
}

ОБНОВИТЬ

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

Answer 3

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