การใช้อินเทอร์เฟซสำหรับการจัดหมวดหมู่เป็นเรื่องที่ผิดหรือไม่

ตัวอย่างเช่น:

บอกฉันได้เรียนA, ,B Cฉันมีสองอินเตอร์เฟซที่ช่วยให้เรียกพวกเขาและIAnimal สืบทอดจาก และมีs ในขณะที่ไม่ได้ แต่มันก็เป็นIDogIDogIAnimalABIDogCIAnimal

ส่วนที่สำคัญคือIDogไม่มีการใช้งานเพิ่มเติม มันใช้เพื่ออนุญาตAและBไม่Cผ่านการโต้แย้งเป็นวิธีการบางอย่าง

นี่คือการปฏิบัติที่ไม่ดีหรือไม่?

อินเทอร์เฟซที่ไม่มีสมาชิกใด ๆ หรือมีสมาชิกเดียวกันกับอินเทอร์เฟซอื่นที่สืบทอดมาจากอินเทอร์เฟซเดียวกันที่เรียกว่าตัวทำเครื่องหมายส่วนติดต่อและคุณกำลังใช้เป็นตัวทำเครื่องหมาย

ไม่ใช่แนวปฏิบัติที่ไม่ถูกต้อง แต่สามารถเปลี่ยนอินเตอร์เฟส (คุณลักษณะ) ได้หากภาษาที่คุณใช้รองรับ

ฉันสามารถพูดได้อย่างมั่นใจว่ามันไม่ได้เลวร้ายเพราะฉันได้เห็นรูปแบบการใช้งาน "อินเทอร์เฟซของตัวทำเครื่องหมาย" ในโครงการ Orchard

นี่คือตัวอย่างจากโครงการออร์ชาร์ด

public interface ISingletonDependency : IDependency {}

/// <summary>
/// Base interface for services that may *only* be instantiated in a unit of work.
/// This interface is used to guarantee they are not accidentally referenced by a singleton dependency.
/// </summary>
public interface IUnitOfWorkDependency : IDependency {}

/// <summary>
/// Base interface for services that are instantiated per usage.
/// </summary>
public interface ITransientDependency : IDependency {}

โปรดดูที่เครื่องหมายอินเตอร์เฟซ

ใช่มันเป็นการปฏิบัติที่ไม่ดีในเกือบทุกภาษา

ประเภทไม่ได้มีการเข้ารหัสข้อมูล พวกมันช่วยในการพิสูจน์ว่าข้อมูลของคุณไปในที่ที่มันต้องการและพฤติกรรมเหมือนที่มันจำเป็นต้องทำ เหตุผลเพียงอย่างเดียวของประเภทย่อยคือถ้าพฤติกรรมที่หลากหลายเปลี่ยนไป (และไม่เสมอไป)

เนื่องจากไม่มีการพิมพ์สิ่งที่ IDog สามารถทำได้นั้นบอกเป็นนัย โปรแกรมเมอร์คนหนึ่งคิดอย่างหนึ่งอีกคนคิดอีกอย่างและเลิกกัน หรือสิ่งที่แสดงเพิ่มขึ้นตามที่คุณต้องการการควบคุมที่ละเอียดยิ่งขึ้น

[แก้ไข: การชี้แจง]

สิ่งที่ฉันหมายถึงคือคุณกำลังใช้ตรรกะบางอย่างบนพื้นฐานของส่วนต่อประสาน ทำไมวิธีการบางอย่างสามารถทำงานร่วมกับสุนัขและสัตว์อื่น ๆ ? ความแตกต่างนั้นเป็นสัญญาโดยนัยเนื่องจากไม่มีสมาชิกจริงที่ให้ความแตกต่าง ไม่มีข้อมูลจริงในระบบ ข้อแตกต่างคืออินเทอร์เฟซ (ดังนั้นความคิดเห็น 'ไม่พิมพ์') และสิ่งที่หมายถึงจะแตกต่างกันระหว่างโปรแกรมเมอร์ [/ แก้ไข]

บางภาษามีกลไกลักษณะที่ไม่เลวร้ายเกินไป แต่คนเหล่านั้นมักจะมุ่งเน้นไปที่ความสามารถไม่ใช่การปรับแต่ง ฉันมีประสบการณ์เล็กน้อยกับพวกเขาดังนั้นจึงไม่สามารถพูดกับแนวทางปฏิบัติที่ดีที่สุดที่นั่นได้ ใน C ++ / Java / C # แม้ว่า ... ไม่ดี

ฉันรู้ C # เท่านั้นดังนั้นฉันไม่สามารถพูดสิ่งนี้สำหรับการเขียนโปรแกรม OO โดยทั่วไป แต่เป็นตัวอย่าง C # หากคุณต้องการจัดหมวดหมู่คลาสตัวเลือกที่ชัดเจนคืออินเตอร์เฟสคุณสมบัติ enum หรือแอตทริบิวต์ที่กำหนดเอง โดยปกติฉันจะเลือกอินเทอร์เฟซไม่ว่าคนอื่นจะคิดอย่างไร

if(animal is IDog)
{
}
if(animal.Type == AnimalType.Dog)
{
}
if(animal.GetType().GetCustomAttributes(typeof(DogAttribute), false).Any())
{
}


var dogs1 = animals.OfType<IDog>();
var dogs2 = animals.Where(a => a.Type == AnimalType.Dog);
var dogs3 = animals.Where(a => a.GetType().GetCustomAttributes(typeof(DogAttribute), false).Any());


var dogsFromDb1 = session.Query<IDog>();
var dogsFromDb2 = session.Query<Animal>().Where(a => a.Type == AnimalType.Dog);
var dogsFromDb3 = session.Query<Animal>().Where(a => a.GetType().GetCustomAttributes(typeof(DogAttribute),false).Any());


public void DoSomething(IDog dog)
{
}
public void DoSomething(Animal animal)
{
    if(animal.Type != AnimalType.Dog)
    {
        throw new ArgumentException("This method should be used for dogs only.");
    }
}
public void DoSomething(Animal animal)
{
    if(!animal.GetType().GetCustomAttributes(typeof(DogAttribute), false).Any())
    {
        throw new ArgumentException("This method should be used for dogs only.");
    }
}

ไม่มีอะไรผิดปกติกับการมีอินเตอร์เฟสซึ่งสืบทอดอินเตอร์เฟสอื่นโดยไม่เพิ่มสมาชิกใหม่หากการใช้งานทั้งหมดของอินเตอร์เฟสหลังนั้นคาดว่าจะสามารถทำสิ่งที่เป็นประโยชน์ซึ่งการใช้งานบางอย่างของอดีตอาจไม่เป็นประโยชน์ แท้จริงแล้วมันเป็นรูปแบบที่ดีซึ่ง IMHO ควรใช้ในสิ่งต่าง ๆ เช่น. net Framework โดยเฉพาะอย่างยิ่งเนื่องจากผู้ใช้ที่คลาสจะมีข้อ จำกัด ตามนัยโดยอินเทอร์เฟซที่ได้รับมามากกว่านั้นสามารถบ่งชี้ว่า , โดยไม่ต้องเปลี่ยนรหัสการประกาศใช้งานหรือการประกาศใด ๆ

ตัวอย่างเช่นสมมติว่าฉันมีอินเทอร์เฟซ:

อินเตอร์เฟส IMaybeMutableFoo {
  Bar Thing {get; set;} // และคุณสมบัติอื่น ๆ เช่นกัน
  บูล IsMutable;
  IImmutableFoo AsImmutable ();
}
อินเตอร์เฟส IImmutableFoo: IMaybeMutableFoo {};

การดำเนินการของIImmutableFoo.AsImmutable()คาดว่าจะกลับมา; การใช้คลาสที่ไม่แน่นอนIMaybeMutableFoo.AsImmutable()นั้นคาดว่าจะส่งคืนออบเจ็กต์ที่เปลี่ยนแปลงไม่ได้อย่างล้ำลึกซึ่งมีสแนปช็อตของข้อมูล รูทีนที่ต้องการเก็บสแน็ปช็อตของข้อมูลที่เก็บไว้ใน a IMaybeMutableFooสามารถเสนอโอเวอร์โหลดได้:

โมฆะสาธารณะ StoreData (IImmutableFoo ThingToStore)
{
  // การจัดเก็บข้อมูลอ้างอิงจะเพียงพอเนื่องจาก ThingToStore เป็นที่รู้กันว่าไม่เปลี่ยนรูป
}
โมฆะสาธารณะ StoreData (IMaybeMutableFoo ThingToStore)
{
  StoreData (ThingToStore.AsImmutable ()); // เรียกโอเวอร์โหลดที่เจาะจงมากขึ้น
}

ในกรณีที่คอมไพเลอร์ไม่ได้รู้ว่าสิ่งที่จะถูกเก็บไว้เป็นก็จะเรียกIImmutableFoo AsImmutable()ฟังก์ชั่นควรกลับอย่างรวดเร็วหากรายการไม่สามารถเปลี่ยนแปลงได้ แต่การเรียกใช้ฟังก์ชันผ่านอินเทอร์เฟซยังคงใช้เวลา หากคอมไพเลอร์รู้ว่าไอเท็มนั้นมีอยู่แล้วIImmutableFooมันสามารถข้ามการเรียกฟังก์ชันที่ไม่มีความจำเป็นได้