Как вы думаете, "реализация интерфейса авто" будет полезно в .NET/C#

Question

Рассмотрим это:

public class interface Person : IPerson 
{ 
    int ID { get; protected set; } 
    string FirstName { get; set; } 
    string LastName { get; set; } 
    string FullName { get { return FirstName + " " + LastName; } } 
} 

И это:

public class StubPerson : IPerson 
{ 
    int ID { get { return 0; protected set { } } 
    string FirstName { get { return "Test" } set { } } 
    string LastName { get { return "User" } set { } } 
    string FullName { get { return FirstName + " " + LastName; } } 
} 

Использование:

IPerson iperson = new Person(); 

Или:

IPerson ipersonStub = new StubPerson(); 

Или:

IPerson ipersonMock = mocks.CreateMock<IPerson>(); 

Так в действительности мы объявляющего интерфейс IPerson и Person класс одновременно:

public class interface Person : IPerson 

Как вы думаете, что было бы полезно есть такая поддержка в .NET/C#?

Edit:

Из-за массовой путаницы я думаю, что нужно уточнить предложенную цель:

Без этой функции вы должны написать:

interface IPerson 
{ 
    int ID { get; } 
    string FirstName { get; set; } 
    string LastName { get; set; } 
    string FullName { get; } 
} 

, а также это:

public class Person : IPerson 
{ 
    int ID { get; protected set; } 
    string FirstName { get; set; } 
    string LastName { get; set; } 
    string FullName { get { return FirstName + " " + LastName; } } 
} 

Я вообще не предлагаю никаких семантических изменений.

Answer 1

Я считал the same sort of thing a while ago, особенно для использования в случае, когда у вас есть только одна производственная реализация интерфейса, но вы хотите издеваться над ним для тестирования. В настоящий момент это немного напоминает файлы .c/.h.

Я подозреваю, в конце концов, что преимущества этого перевешиваются дополнительной сложностью как на языке, так и после этого считывания кода. Мне все равно было бы интересно, если бы он исследовался более тщательно, хотя. Даже в этом случае в моем списке приоритетов есть другие вещи: более высокая поддержка неизменности:

Answer 2

Я думаю, что мне не хватает смысла - что вы делаете, смешивая класс и интерфейс вместе? Какую проблему вы решаете с помощью этого подхода?

Это:

IPerson iperson = new Person(); 

уже легальным в C#.

Edit: Для уточнения - приведенный выше код является законным, учитывая следующее:

interface IPerson { } 

class Person : IPerson { } 

Answer 3

Нет, потому что вы будете вынуждены подвергать все публичные член интерфейса. Попробуйте ReSharper, и больше не беспокойтесь об этом.

Answer 4

Позвольте мне увидеть, если я понимаю, что вы спрашиваете:

Почему мы не можем объявить интерфейс:

interface IPerson 
{ 
    string Name {get;set;} 
    int ID {get;set;} 
} 

и классы, которые реализуют этот интерфейс наследует его свойства без необходимости повторно объявить их:

class Person : IPerson { } 
//person now has properties Name and ID 

причина вы не можете сделать это, даже если текст вашего кода интерфейса и код класса очень похожи, они средний очень различные вещи. Интерфейс просто говорит: «У конструктора будет строка Name с getter и setter». Это класс, который говорит «return private field при вызове getter для имени». Даже если вы используете ярлык auto-property, чтобы компилятор реализовал эту логику, все равно логический, который принадлежит к классу. Просто потому, что:

string Name {get;set;} 

выглядит такой же, в интерфейсе и в классе, это не означает, что даже отдаленно то же самое.

Было бы очень опасно, если бы компилятор реализовал произвольную логику для выполнения ваших контрактов для вас, вместо того, чтобы жаловаться во время компиляции, чтобы вы их не реализовали. Это может привести к ошибкам, которые очень сложно отследить. Когда компиляторы возвращаются к поведению по умолчанию, когда поведение не определено, это очень и очень плохая идея.

Answer 5

Resharper могут обеспечить эту функциональность, например,

1. Вы можете написать свой класс Person первым.
2. Вы можете извлечь свой интерфейс по адресу pulling members up в интерфейс IPerson.

Следовательно, у вас могут быть созданные для Visual Studio ауты создания экземпляра Visual Studio.

UPDATE

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

public class interface Person : IPerson 
{ 
    int ID { get; protected set; } 
    string FirstName { get; set; } 
    string LastName { get; set; } 
    string FullName { get { return FirstName + " " + LastName; } } 
} 

Вы должны понимать, что интерфейс не является абстрактным класс. Интерфейс - это всего лишь контракт, вид сбоку, что означает, что он расскажет объекту, чего ожидать в другом объекте, не заботясь о том, как он реализован.

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

В приведенном выше случае, ваш «интерфейс» является недействительным, так как:

• вы не можете объявить области действия ограничений на интерфейсах (государственные, частные, защищенный, внутренний), как это деталь реализации
• вы не можете объявить реализацию по умолчанию (например,Ваша FullName собственность), потому что еще раз, что это деталь реализации

Мне кажется, что вы действительно хотите это абстрактный класс, например,

public abstract class BasePerson 
{ 
    public abstract int ID { get; protected set; } 
    public string FirstName { get; set; } 
    public string LastName { get; set; } 
    public virtual string FullName { get { return FirstName + " " + LastName; } } 
} 

Я просто угадать, но может быть, это то, что вам действительно нужно.

UPDATE 2

Хорошо, я думаю, что я получаю на то, что вы хотите, чтобы это произошло, так что вы хотите, чтобы иметь возможность написать это:

public interface IPerson 
{ 
    int ID { get; set; } 
    string FirstName { get; set; } 
    string LastName { get; set; } 
    string FullName { get; } 
} 

А потом для вашего Реализация должна только написать следующее:

public class Person : IPerson 
{ 
    public int ID { get; protected set; } 
    public string FullName { get { return FirstName + " " + LastName; } } 
} 

Не нужно указывать свойства FirstName и LastName.

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

Во-вторых, тот факт, что в то время как в наших глазах string FirstName { get; set; } в интерфейсе и public string FirstName { get; set; } в классе одни и те же, на самом деле они не так:

• в интерфейсе, определение собственности будет указано, что сигнатуры методов для методов getter и/или setter будут доступны для всех классов, реализующих этот интерфейс.
• в классе определение свойства даст указание CLR создать анонимный объект, который будет хранить значение указанного свойства.

Тонкая разница для программиста, миры для компилятора.

И наконец, когда вы укажете, что вы реализуете интерфейс, Visual Studio выполняет синтаксическую магию, которая автоматически делает эти заглушки для вас.

Answer 6

Ну, я думаю, что другие ответы помогут вам понять использование интерфейса для абстрактной логики в разных конкретных классах, я также думаю, что вы можете сделать что-то похожее на то, что хотите, используя инструменты рефакторинга, встроенные в VS.

Определите класс ...

public class Person 
{ 
    public int ID { get; protected set; } 
    public string FirstName { get; set; } 
    public string LastName { get; set; } 
    public string FullName { get { return FirstName + " " + LastName; } } 
} 

Затем щелкните правой кнопкой мыши, выберите Рефакторинг -> Извлечь интерфейс.

Это создаст отдельный файл, содержащий интерфейс для определения класса, затем вы можете сформировать интерфейс и реализовать классы соответственно.

Извлеченные Интерфейс:

interface IPerson 
{ 
    string FirstName { get; set; } 
    string FullName { get; } 
    int ID { get; } 
    string LastName { get; set; } 
} 

Answer 7

Я считаю, Eiffel делает что-то вроде этого на .NET, в целях поддержки множественного наследования. Объявление класса автоматически создает соответствующий интерфейс.Когда тип класса упоминается, компилятор вместо этого вместо этого ссылается на тип интерфейса. Главное исключение - в выражениях конструктора, конечно.

Answer 8

Я бы по крайней мере хотел, чтобы Visual Studio реализовал мои свойства из интерфейса как свойства auto, если я его попрошу для этого.

К сожалению, этот вариант не дает и мне приходится иметь дело с не Реализованы исключениями окурков

Answer 9

Я думаю, что лучше абстракция для этого является признаком, или, как я описал here, роль. Это похоже на интерфейс с кодом. Ваш пример может быть закодирован следующим образом:

public role RPerson { 
    int ID { get; protected set; } 
    string FirstName { get; set; } 
    string LastName { get; set; } 
    string FullName { get { return FirstName + " " + LastName; } } 
} 

public class Person : RPerson { } 

public class StubPerson : RPerson { 
    int ID { get { return 0; protected set { } } 
    string FirstName { get { return "Test" } set { } } 
    string LastName { get { return "User" } set { } } 
    string FullName { get { return FirstName + " " + LastName; } } 
} 

// ... 

RPerson rperson = new Person(); 

RPerson rpersonStub = new StubPerson();