Bir Arabirimi Genel Yöntemlerle Uygulayın

Question

Bu konuda boş bir çizim yapıyorum ve yazdığım daha önceki bir örneği bulamıyorum. Bir sınıfla genel bir arayüz uygulamaya çalışıyorum. Arabirimi uyguladığımda, bir şeyin doğru çalışmadığını düşünüyorum çünkü Visual Studio sürekli olarak Genel Arabirim'deki tüm yöntemleri kullanmıyorum diyerek hatalar üretir.

public interface IOurTemplate<T, U> 
{ 
    IEnumerable<T> List<T>() where T : class; 
    T Get<T, U>(U id) 
     where T : class 
     where U : class; 
} 

Peki benim sınıf gibi görünmelidir:

İşte Birlikte çalıştığım şeyi bir saplama var?

Answer 1

Çok gibi, arabirime yeni bir biçim olmalıdır:

public interface IOurTemplate<T, U> 
     where T : class 
     where U : class 
{ 
    IEnumerable<T> List(); 
    T Get(U id); 
} 

Sonra genel bir sınıf olarak bunu uygulayabilirsiniz:

public class OurClass<T,U> : IOurTemplate<T,U> 
     where T : class 
     where U : class 
{ 
    IEnumerable<T> List() 
    { 
     yield return default(T); // put implementation here 
    } 

    T Get(U id) 
    { 

     return default(T); // put implementation here 
    } 
} 

Veya, somut olarak uygulayabilirsiniz:

public class OurClass : IOurTemplate<string,MyClass> 
{ 
    IEnumerable<string> List() 
    { 
     yield return "Some String"; // put implementation here 
    } 

    string Get(MyClass id) 
    { 

     return id.Name; // put implementation here 
    } 
} 

Answer 2

ben muhtemelen bu gibi arayüzü yeniden tanımlamak istediğiniz düşünüyorum:

public interface IOurTemplate<T, U> 
    where T : class 
    where U : class 
{ 
    IEnumerable<T> List(); 
    T Get(U id); 
} 

Sana yöntemleri (yeniden kullanım), beyan olduğunuz jenerik arayüzünün genel parametreleri kullanmak istiyorum düşünüyorum; ve muhtemelen kendilerine (arabirimden farklı) genel parametrelerle genel yöntemler yapmak istemezsiniz.

bunu yeniden tanımlandı olarak arayüzü, böyle bir sınıf tanımlayabilirsiniz Verilen:

class Foo : IOurTemplate<Bar, Baz> 
{ 
    public IEnumerable<Bar> List() { ... etc... } 
    public Bar Get(Baz id) { ... etc... } 
} 

Ya da bu gibi genel bir sınıf tanımlayın:

class Foo<T, U> : IOurTemplate<T, U> 
    where T : class 
    where U : class 
{ 
    public IEnumerable<T> List() { ... etc... } 
    public T Get(U id) { ... etc... } 
} 

Answer 3

- düzenle

Diğer cevaplar daha iyidir, ancak nasıl görünmesi gerektiği konusunda kafanız karıştığında VS'nin sizin için arabirimi uygulayabileceğini unutmayın.

Aşağıda açıklanan işlem. Tek yaptığım yazma arayüzü, daha sonra VS oluşturmak için açılır için üzerine tıklayın ve küçük simge için beklemek olduğunu

class X : IOurTemplate<string, string> 
{ 
    #region IOurTemplate<string,string> Members 

    IEnumerable<T> IOurTemplate<string, string>.List<T>() 
    { 
     throw new NotImplementedException(); 
    } 

    T IOurTemplate<string, string>.Get<T, U>(U id) 
    { 
     throw new NotImplementedException(); 
    } 

    #endregion 
} 

Not:

Eh, Visual Studio bu gibi görünmelidir söylüyor Benim için uygulama :)