Bir arabirim diğer arabirimlerden miras alırsa 'boş' sayılır mı?

Boş arayüzler genellikle anlayabildiğim kadarıyla kötü uygulamaları düşünür - özellikle nitelikler gibi şeylerin dil tarafından desteklendiği yerlerde.

Ancak, bir arabirim diğer arabirimlerden miras alırsa 'boş' sayılır mı?

interface I1 { ... }
interface I2 { ... } //unrelated to I1

interface I3
    : I1, I2
{
    // empty body
}

Uygulayan her şeyin uygulanması I3gerekir I1ve I2devralınan farklı sınıflardan nesneler I3daha sonra birbirinin yerine kullanılabilir (aşağıya bakın), I3 boş çağırmak doğru mu? Eğer öyleyse bunu mimarileştirmenin daha iyi bir yolu ne olurdu?

// with I3 interface
class A : I3 { ... }
class B : I3 { ... }

class Test {
    void foo() {
        I3 something = new A();
        something = new B();
        something.SomeI1Function();
        something.SomeI2Function();
    }
}

// without I3 interface
class A : I1, I2 { ... }
class B : I1, I2 { ... }

class Test {
    void foo() {
        I1 something = new A();
        something = new B();
        something.SomeI1Function();
        something.SomeI2Function(); // we can't do this without casting first
    }
}

I3'ü uygulayan her şeyin I1 ve I2'yi uygulaması gerekir ve I3'ü devralan farklı sınıflardan nesneler daha sonra birbirinin yerine kullanılabilir (aşağıya bakın), bu yüzden I3'ü boş çağırmak doğru mu? Eğer öyleyse bunu mimarileştirmenin daha iyi bir yolu ne olurdu?

"Paketleme" I1ve I2içine I3hoş bir (?) Kısayol veya her ikisinin de uygulanmasını istediğiniz yere bir tür sözdizimi şekeri sunar.

Bu yaklaşımdaki sorun açıkça uygulayan diğer geliştiriciler duramazsın ki I1 ve I2 yan yana, ancak her iki yönde çalışmaz - ederken : I3eşdeğerdir : I1, I2, : I1, I2bir eşdeğer değildir : I3. İşlevsel olarak aynı olsalar bile, her ikisini de destekleyen I1ve destekleyici I2olarak algılanmayacak bir sınıf I3.

Bu, aynı şeyi gerçekleştirmenin iki yolunu sunduğunuz anlamına gelir - "manuel" ve "tatlı" (sözdizimi şekerinizle). Kod tutarlılığı üzerinde kötü bir etkisi olabilir. Burada, orada ve başka bir yerde aynı şeyi başarmanın 2 farklı yolunu sunmak zaten 8 olası kombinasyonla sonuçlanıyor :)

void foo() {
    I1 something = new A();
    something = new B();
    something.SomeI1Function();
    something.SomeI2Function(); // we can't do this without casting first
}

Tamam, yapamazsın. Ama belki de bu aslında iyi bir işarettir?

Eğer I1ve I2farklı sorumluluklar ima (Aksi ilk etapta bunları ayırmak gerek olmazdı), sonra belki foo()denemek ve yapmak yanlıştır somethingtek seferde iki farklı sorumluluklarını yerine?

Başka bir deyişle, foo()Tek Sorumluluk ilkesini ihlal ediyor olabilir ve onu çıkarmak için döküm ve çalışma zamanı kontrolleri gerektirmesi, bizi bu konuda endişe verici kırmızı bir bayraktır.

DÜZENLE:

fooBunun uygulayan bir şeyi almasını sağlamakta ısrar ettiyseniz I1ve I2bunları ayrı parametreler olarak iletebilirsiniz:

void foo(I1 i1, I2 i2) 

Ve aynı nesne olabilirler:

foo(something, something);

fooAynı örnek olup olmamaları ne yapar ?

Ama umursamıyorsa (örneğin, vatansız olmadıkları için) veya bunun çirkin göründüğünü düşünüyorsanız, bunun yerine jenerikler kullanılabilir:

void Foo<T>(T something) where T: I1, I2

Artık genel kısıtlamalar, dış dünyayı hiçbir şeyle kirletmezken istenen etkiyi halleder. Bu, derleme zamanı kontrollerine dayanan deyimsel C # ve genel olarak daha doğru hissediyor.

Bir I3 : I2, I1şekilde sendika türlerini kutunun dışında desteklemeyen bir dilde taklit etme çabası olarak görüyorum (C # veya Java desteklemiyor, ancak sendika türleri fonksiyonel dillerde mevcut).

Dil tarafından gerçekten desteklenmeyen bir yapıyı taklit etmeye çalışmak genellikle karmaşıktır. Benzer şekilde, C # 'da mixins öykünmek istiyorsanız uzantı yöntemleri ve arabirimler kullanabilirsiniz . Mümkün? Evet. İyi bir fikir? Emin değilim.

Bir sınıfın her iki arabirimi de uygulamasında özel bir önem varsa, o zaman her ikisinden de miras kalan üçüncü bir arabirim oluştururken yanlış bir şey görmüyorum. Ancak, aşırıya kaçan şeylerin tuzağına düşmemeye dikkat ederdim. Bir sınıf birinden veya diğerinden veya her ikisinden miras alabilir. Programımın bu üç durumda bolca sınıfları olmadıkça, her ikisi için de bir arayüz oluşturmak biraz fazladır ve kesinlikle bu iki arayüzün birbiriyle ilişkisi yoksa (IComparableAndSerializable arayüzleri lütfen).

Size her iki arabirimden miras kalan soyut bir sınıf oluşturabileceğinizi ve bu soyut sınıfı I3 yerine kullanabileceğinizi hatırlatırım. Bence bunu yapmaman gerektiğini söylemek yanlış olur, ama en azından iyi bir sebebin olmalı.

Boş arayüzler genellikle kötü uygulama olarak kabul edilir

Katılmıyorum. İşaretleyici arabirimleri hakkında bilgi edinin .

Tipik bir arabirim, bir uygulayıcı sınıfın desteklemesi gereken işlevselliği (yöntem bildirimleri biçiminde) belirtirken, bir işaretçi arabiriminin bunu yapması gerekmez. Sadece böyle bir arayüzün varlığı, uygulayıcı sınıfın belirli davranışını gösterir.