Apakah masuk akal untuk mendefinisikan antarmuka jika saya sudah memiliki kelas abstrak?

Saya memiliki kelas dengan beberapa fungsi standar / bersama. Saya gunakan abstract classuntuk itu:

public interface ITypeNameMapper
{
    string Map(TypeDefinition typeDefinition);
}

public abstract class TypeNameMapper : ITypeNameMapper
{
    public virtual string Map(TypeDefinition typeDefinition)
    {
        if (typeDefinition is ClassDefinition classDefinition)
        {
            return Map(classDefinition);
        }
        ...

        throw new ArgumentOutOfRangeException(nameof(typeDefinition));
    }

    protected abstract string Map(ClassDefinition classDefinition);
}

Seperti yang Anda lihat, saya juga memiliki antarmuka ITypeNameMapper. Apakah masuk akal untuk mendefinisikan antarmuka ini jika saya sudah memiliki kelas abstrak TypeNameMapperatau abstract classcukup?

TypeDefinition dalam contoh minimal ini juga abstrak.

Ya, karena C # tidak mengizinkan banyak pewarisan kecuali dengan antarmuka.

Jadi jika saya memiliki kelas yang merupakan TypeNameMapper dan SomethingelseMapper saya bisa melakukannya:

class MultiFunctionalClass : ITypeNameMapper, ISomethingelseMapper 
{
    private TypeNameMapper map1
    private SomethingelseMapper map2

    public string Map(TypeDefinition typeDefinition) { return map1.Map(typeDefintion);}

    public string Map(OtherDef otherDef) { return map2.Map(orderDef); }
}

Antarmuka dan kelas abstrak melayani tujuan yang berbeda:

• Antarmuka mendefinisikan API dan milik klien bukan implementasinya.
• Jika kelas berbagi implementasi maka Anda dapat mengambil manfaat dari kelas abstrak .

Dalam contoh Anda, interface ITypeNameMappertentukan kebutuhan klien dan abstract class TypeNameMappertidak menambah nilai apa pun.

Seluruh konsep antarmuka dibuat untuk mendukung keluarga kelas yang memiliki API bersama.

Ini secara eksplisit mengatakan bahwa setiap penggunaan antarmuka menyiratkan bahwa ada (atau diharapkan) lebih dari satu implementasi spesifikasinya.

Kerangka kerja DI telah memperkeruh perairan di sini karena banyak dari mereka memerlukan antarmuka meskipun hanya akan ada satu implementasi - bagi saya ini adalah overhead yang tidak masuk akal karena dalam banyak kasus hanya cara yang lebih kompleks dan lebih lambat untuk memanggil yang baru, tetapi adalah apa adanya.

Jawabannya ada pada pertanyaan itu sendiri. Jika Anda memiliki kelas abstrak, Anda sedang mempersiapkan pembuatan lebih dari satu kelas turunan dengan API umum. Dengan demikian, penggunaan antarmuka ditunjukkan dengan jelas.

Jika kita ingin menjawab pertanyaan secara eksplisit, penulis mengatakan, "Apakah masuk akal untuk mendefinisikan antarmuka ini jika saya sudah memiliki kelas abstrak TypeNameMapper atau kelas abstrak sudah cukup?"

Jawabannya adalah ya dan tidak - Ya, Anda harus membuat antarmuka meskipun Anda sudah memiliki kelas dasar abstrak (karena Anda tidak boleh merujuk ke kelas dasar abstrak dalam kode klien apa pun), dan tidak, karena Anda seharusnya tidak membuat kelas dasar abstrak tanpa adanya antarmuka.

Jelas bahwa Anda belum cukup memikirkan API yang ingin Anda bangun. Munculkan API terlebih dahulu, lalu berikan implementasi parsial jika diinginkan. Fakta bahwa kelas dasar abstrak Anda mengetik kode memeriksa sudah cukup untuk memberi tahu Anda itu bukan abstraksi yang tepat.

Seperti pada kebanyakan hal dalam OOD, ketika Anda berada di alur dan memiliki model objek Anda dilakukan dengan baik, kode Anda akan memberi tahu Anda tentang apa yang terjadi selanjutnya. Mulailah dengan sebuah antarmuka, terapkan antarmuka itu di kelas yang Anda butuhkan. Jika Anda menemukan diri Anda menulis kode yang serupa, ekstrak menjadi kelas dasar abstrak - itu antarmuka yang penting, kelas dasar abstrak hanyalah pembantu dan mungkin ada lebih dari satu.

Ini cukup sulit dijawab tanpa mengetahui sisa aplikasi.

Dengan asumsi Anda menggunakan beberapa jenis model DI dan telah merancang kode Anda agar dapat diperluas sebisa mungkin (sehingga Anda dapat menambahkan TypeNameMapperdengan mudah) saya akan mengatakan ya.

Alasan untuk:

• Anda secara efektif mendapatkannya secara gratis, karena kelas dasar mengimplementasikan interfaceAnda tidak perlu khawatir tentang hal itu dalam implementasi anak
• Sebagian besar kerangka kerja IoC dan perpustakaan Mocking mengharapkan interfaces. Sementara banyak dari mereka yang bekerja dengan kelas abstrak itu tidak selalu diberikan dan saya sangat percaya dalam mengikuti jalan yang sama dengan 99% pengguna perpustakaan lainnya jika memungkinkan.

Alasan menentang:

• Sebenarnya (seperti yang telah Anda tunjukkan), Anda TIDAK BENAR-BENAR perlu
• Jika class/ interfaceperubahan ada sedikit overhead tambahan

Semua hal dipertimbangkan saya akan mengatakan bahwa Anda harus membuat interface. Alasannya cukup dapat diabaikan tetapi, sementara mungkin untuk menggunakan abstrak dalam mengejek dan IoC sering jauh lebih mudah dengan antarmuka. Namun pada akhirnya, saya tidak akan mengkritik kode rekan jika mereka sebaliknya.