Come creare proprietà auto implementate quando si implementa un'interfaccia in una classe?

Question

Quando implemento un'interfaccia per la prima volta in una classe, desidero che sia il resharper 6 o lo studio visivo 2010 implementino le mie proprietà come proprietà implementate automaticamente e non inseriscano il valore predefinito di lanciare NonImplementedException() ;. Come posso fare questo? Per esempio:

public interface IEmployee 
{ 
// want this to stay just like this when implemented into class 
ID { get; set; } 
} 

public class Employee : IEmployee 
{ 
// I do not want the throw new NonImplemented exception 
// I want it to just appear as an auto implemented property 
// as I defined it in the interface 
public int ID 
     { 
      get 
      { 
       throw new NotImplementedException(); 
      } 
      set 
      { 
       throw new NotImplementedException(); 
      } 
     } 
} 

Perché questo accade tutto il tempo, mi sto trovando a dover refactoring costantemente e rimuovere manualmente quelli gettare nuova UnImplimented) eccezioni (e manualmente rendono le proprietà siano automatica implementata ... un dolore! Dopotutto, l'ho definito come una proprietà auto implementata nella mia interfaccia.

Qualsiasi aiuto o consiglio molto apprezzato! Grazie.

Answer 1

Nota: le scorciatoie da tastiera R # potrebbero essere diverse, sto usando lo schema di tastiera 2.x di Resharper.

Se si dichiara l'interfaccia sulla classe e quindi utilizzare Alt + Inserisci e selezionare “Attuare membri”:

allora si otterrà l'implementazione di default, che risulta essere lancio NotImplementedException, a meno che non lo cambi.

Ma se si ignora il corso consigliato di azione e di utilizzare invece Alt + Inserire per aprire il menu Genera, è possibile selezionare “Missing membri”:

questo aprirà Genera finestra dove è possibile scegliere di implementare la proprietà (o in) come auto-implementato:

che farà esattamente quello che vuoi:

class Employee : IEmployee 
{ 
    public int Id { get; set; } 
} 

Answer 2

Dopo tutto, l'ho definito come una proprietà auto-implementata nella mia interfaccia.

No, non l'hai fatto. L'hai dichiarata come proprietà senza un'implementazione. Questo è tutto tu può fare fare in un'interfaccia: stai solo dicendo che le classi che implementano l'interfaccia devono fornire le implementazioni concrete di tali proprietà.

Personalmente sarei diffidare di avere troppe scrivibili proprietà all'interno di interfacce - se questo è qualcosa che si trovano "Succede tutte le volte" Mi chiedo se si sta utilizzando le interfacce in cui, eventualmente, le classi astratte sarebbero più appropriati.

In termini della tua domanda esatta: non so se è possibile modificare l'implementazione di default VS o R # prevede interfacce - ma vorrei resistere comunque a tali modifiche, ad essere onesti.

MODIFICA: in Opzioni R #, "Generazione codice", è possibile scegliere tra lanciare un'eccezione, restituire un valore predefinito o fornire codice non compilabile. È possibile che questo farà ciò che vuoi. Fai un tentativo, ma ti esorto comunque a riflettere attentamente prima di intraprendere questa strada.

Answer 3

Un'interfaccia non ha lo scopo di specificare in che modo verranno implementati i metodi, quindi non c'è modo di aggirarlo utilizzando l'interfaccia. Una soluzione sarebbe quella di creare una classe base astratta con le proprietà autoattive e ereditare quella classe invece di implementare direttamente l'interfaccia.

Answer 4

Oltre alla risposta di Jon ... se si vuole veramente cambiare questo (out of box) il comportamento di Visual Studio e la creazione di proprietà di auto quando implementare l'interfaccia, è possibile provare una delle seguenti ...

1. Usa T4 per la generazione di codice - http://msdn.microsoft.com/en-us/library/bb126445.aspx

2. Scrivi un plugin personalizzato per Visual Studio utilizzando VS SDK raggiungere questo

Answer 5

Non è correlato a questa domanda completamente, tuttavia, un approccio diverso quando si dispone di più di tali proprietà in un'interfaccia, invece di interfaccia si può avere una classe e fai riferimento a quella classe come tipo di ritorno nella tua classe principale. Puoi creare una classe e fare riferimento a quella classe nella tua classe principale. Esempio

public class Asset 
{ 
    public int AssetTrackingID { get; set; } 

    public Category AssetCategoryInfo { get; set; } 

    public Manufacturer AssetManufacturerInfo { get; set; } 

    public ManufacturerModel AssetModelInfo { get; set; } 

    public Status AssetStatusInfo { get; set; } 

    public EmployeeDetails AssetEmployeeInfo { get; set; } 

    public string AssetNumber { get; set; } 

    public string SerialNumber { get; set; } 

    public DateTime? AcquiredDate { get; set; } 

}

Answer 6

Ecco una rapida soluzione che ho trovato in VS2015. Segna la tua classe come astratta quindi implementa l'interfaccia in modo astratto. Questo aggiunge le proprietà automatiche per te, quindi devi semplicemente sostituire "astratto" con "" nel tuo file. Quindi puoi rimuovere la parola chiave astratta dalla tua classe.

Answer 7

Nel caso di VS2015 sto usando un ricerca e sostituzione macro come una soluzione:

Find: 
(\r|\n| |\t)+\{(\r|\n| |\t)+get(\r|\n| |\t)+\{(\r|\n| |\t)+throw(\r|\n| |\t)+new(\r|\n| |\t)+NotImplementedException\(\);(\r|\n| |\t)+\}(\r|\n| |\t)+set(\r|\n| |\t)+\{(\r|\n| |\t)+throw(\r|\n| |\t)+new(\r|\n| |\t)+NotImplementedException\(\);(\r|\n| |\t)+\}(\r|\n| |\t)+\} 

replace: 
{get;set;}