Prinsip pepejal adalah lima prinsip reka bentuk untuk meningkatkan pemeliharaan kod dan skalabilitas dalam pengaturcaraan berorientasikan objek. Mereka adalah: 1. Prinsip Tanggungjawab Tunggal (SRP) menghendaki kelas hanya menganggap satu tanggungjawab, seperti memisahkan generasi laporan dari penghantaran e -mel; 2. Prinsip pembukaan dan penutupan (OCP) menekankan bahawa lanjutan disokong melalui antara muka atau kelas abstrak tanpa mengubah kod asal, seperti menggunakan antara muka ishape untuk merealisasikan pengiraan kawasan grafik yang berbeza; 3. Prinsip Penggantian Richter (LSP) menghendaki subkelas boleh menggantikan kelas induk tanpa memusnahkan logik, seperti persegi tidak boleh tersilap mewarisi segi empat tepat, mengakibatkan tingkah laku yang tidak normal; 4. Prinsip pengasingan antara muka (ISP) menganjurkan antara muka halus, seperti percetakan dan fungsi pengimbasan untuk mengelakkan kebergantungan berlebihan; 5. Prinsip Inversion Prinsip (DIP) yang bergantung kepada abstrak dan bukannya pelaksanaan konkrit, seperti pemprosesan pesanan dan kaedah pembayaran melalui antara muka ipaymentprocessor.

Pasti! Prinsip -prinsip pepejal adalah lima prinsip reka bentuk yang bertujuan untuk membuat reka bentuk perisian lebih mudah difahami, fleksibel, dan dikekalkan. Mereka amat berguna dalam pengaturcaraan berorientasikan objek, seperti dalam C#. Mari kita pecahkan mereka dengan penjelasan mudah dan contoh praktikal bagaimana mereka memohon di C#.

Prinsip Tanggungjawab Tunggal (SRP)

Kelas sepatutnya hanya mempunyai satu sebab untuk berubah - bermakna ia harus melakukan satu perkara dan melakukannya dengan baik.

Mengapa penting:
Apabila kelas mengendalikan pelbagai tugas, perubahan dalam satu kawasan tidak disangka -sangka mempengaruhi orang lain. Dengan memisahkan kebimbangan, kod anda menjadi lebih mudah untuk menguji, debug, dan diperluaskan.

Contoh dalam C#:
Katakan anda mempunyai ReportGenerator yang membuat laporan dan juga menghantar e -mel. Jika logik e -mel berubah, anda perlu mengubah suai kelas yang sama yang mengendalikan generasi laporan - melanggar SRP. Sebaliknya, perpecahan ini menjadi dua kelas: ReportGenerator dan EmailService .

 ReportGenerator Kelas Awam {
    rentetan awam generateReport () {
        // logik untuk menjana laporan
        kembali "Laporan Kandungan";
    }
}

e -melservice kelas awam {
    public void sendEmail (kandungan rentetan) {
        // logik untuk menghantar e -mel
    }
}

Prinsip Terbuka/Ditutup (OCP)

Entiti perisian (kelas, modul, fungsi) harus dibuka untuk lanjutan tetapi ditutup untuk pengubahsuaian.

Cara menggunakannya di C#:
Gunakan antara muka atau kelas abstrak supaya anda boleh menambah tingkah laku baru tanpa menukar kod sedia ada.

Contoh:
Katakan anda mempunyai aplikasi laci bentuk yang menyokong bentuk yang berbeza. Daripada mengubah kaedah setiap kali anda menambah bentuk baru, tentukan antara muka:

 antara muka awam Ishape {
    kawasan berganda ();
}

Rectangle Kelas Awam: Ishape {
    lebar double awam {get; tetapkan; }
    ketinggian dua kali ganda {get; tetapkan; }
    kawasan double public () => lebar * ketinggian;
}

Lingkaran Kelas Awam: Ishape {
    Radius double awam {get; tetapkan; }
    kawasan double awam () => Math.pi * radius * radius;
}

Sekarang anda boleh membuat bentuk baru tanpa menyentuh logik lukisan.

Prinsip Penggantian Liskov (LSP)

Objek superclass harus digantikan dengan objek subkelasnya tanpa melanggar permohonan.

Apa maksudnya dalam amalan:
Jika anda menggunakan warisan, kelas yang diperoleh harus berkelakuan seperti kelas asas mereka. Jika tidak, menggantikannya boleh menyebabkan pepijat.

Contoh bendera merah:
Bayangkan kelas Square yang mewarisi dari Rectangle . Jika menetapkan Width dan Height secara bebas memecahkan definisi persegi, maka Square bukan pengganti yang tepat untuk Rectangle , melanggar LSP.

Untuk membetulkannya, memikirkan semula struktur warisan atau mengelakkan memaksa hubungan yang tidak sejajar dengan tingkah laku yang diharapkan.

Prinsip Pengasingan Antara Muka (ISP)

Pelanggan tidak boleh dipaksa bergantung pada antara muka yang mereka tidak gunakan.

Dalam C#, fikirkan:
Daripada mempunyai satu antara muka yang besar dengan banyak kaedah, memecahnya menjadi yang lebih kecil, lebih spesifik. Dengan cara itu, kelas hanya perlu melaksanakan apa yang sebenarnya digunakan.

Kes dunia nyata:
Katakan anda mempunyai antara muka mesin yang merangkumi ciri -ciri percetakan dan pengimbasan. Tidak semua peranti menyokong kedua -duanya. Jadi bukannya:

 antara muka awam IMACHINE {
    void print ();
    tidak sah imbasan ();
}

Berpecah:

 Iprinter antara muka awam {
    void print ();
}

ISCanner antara muka awam {
    tidak sah imbasan ();
}

kelas awam SimplePrinter: iPrinter {
    cetak void awam () { / * boleh mencetak * /}
}

Dengan cara ini, setiap kelas hanya melaksanakan apa yang diperlukan.

Prinsip Penyongsangan Ketergantungan (DIP)

Modul peringkat tinggi tidak boleh bergantung kepada modul peringkat rendah. Kedua -duanya bergantung kepada abstraksi. Juga, abstraksi tidak boleh bergantung kepada butiran - butiran harus bergantung kepada abstraksi.

Cara memohon di C#:
Gunakan suntikan ketergantungan dan program terhadap antara muka dan bukannya kelas konkrit.

Contoh:
Daripada OrderProcessor peringkat tinggi secara langsung memberi instantiating PaymentProcessor , menyuntik abstraksi:

 Interface Public IpaymentProcessor {
    tidak sah proses (jumlah perpuluhan);
}

kelas awam CreditCardProcessor: IpaymentProcessor {
    PROSES PROSES PUBLIC (jumlah perpuluhan) {
        // Mengendalikan pembayaran kad kredit
    }
}

Pesanan Kelas Awam {
    swasta readonly ipaymentprocessor _paymentprocessor;

    Pesanan PublicProcessor (IpaymentProcessor PaymentProcessor) {
        _PaymentProcessor = PaymentProcessor;
    }

    checkout void awam (jumlah perpuluhan) {
        _PaymentProcessor.ProcessPayment (jumlah);
    }
}

Ini menjadikannya mudah untuk menukar kaedah pembayaran tanpa menulis semula sistem pesanan.

Prinsip -prinsip ini bukan peraturan yang ketat - mereka adalah garis panduan untuk membantu menulis lebih bersih, lebih banyak kod yang dikekalkan. Memohon mereka dengan bijak dalam C# boleh membawa kepada seni bina yang lebih baik dan sakit kepala yang lebih sedikit kemudian.

Atas ialah kandungan terperinci Bolehkah anda menerangkan prinsip-prinsip yang kukuh dan aplikasi mereka dalam reka bentuk berorientasikan objek C#?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!