Вы думаете, что “автоматическая интерфейсная реализация” была бы полезна в.NET / [закрытый] C#

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

Хорошо я думаю, что другие ответы помогут Вам понять использование интерфейса к абстрактной логике в различных реальных классах, я также думаю, что можно выполнить что-то подобное тому, что Вы хотите использовать инструменты рефакторинга, встроенные в 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; }
}

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

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

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

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

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

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

string Name {get;set;}

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

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

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

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

Это:

IPerson iperson = new Person();

уже законно в C#.

Править: Для разъяснения - код выше законен, учитывая следующее:

interface IPerson { }

class Person : IPerson { }

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

К сожалению, эта опция не подходит, и мне приходится иметь дело с заглушками Not реализуемых исключений

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

1. Можно записать класс Человека сначала.
2. Можно извлечь интерфейс путем получения по запросу участников до интерфейса IPerson.

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

ОБНОВЛЕНИЕ

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

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; } } 
}

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

ОБНОВЛЕНИЕ 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; } в классе то же, они на самом деле нет:

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

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

Наконец, когда Вы действительно указываете реализацию интерфейса Visual Studio действительно выполняет synctactic волшебство, которое автоматически делает те тупики свойства для Вас.