Saya bertanya-tanya apakah seseorang bisa memberi saya gambaran mengapa saya akan menggunakannya dan keuntungan apa yang akan saya peroleh dalam proses itu.

Penggunaan kelas parsial terbesar adalah untuk mempermudah pembuat kode / perancang kode. Kelas parsial memungkinkan generator untuk hanya memancarkan kode yang mereka perlu memancarkan dan mereka tidak harus berurusan dengan pengeditan pengguna ke file. Pengguna juga bebas untuk membubuhi keterangan kelas dengan anggota baru dengan memiliki kelas parsial kedua. Ini memberikan kerangka kerja yang sangat bersih untuk memisahkan masalah.

Cara yang lebih baik untuk melihatnya adalah untuk melihat bagaimana desainer berfungsi sebelum kelas parsial. Perancang WinForms akan memuntahkan semua kode di dalam wilayah dengan komentar yang sangat keras tentang tidak memodifikasi kode. Itu harus memasukkan segala macam heuristik untuk menemukan kode yang dihasilkan untuk diproses nanti. Sekarang cukup membuka file designer.cs dan memiliki tingkat kepercayaan yang tinggi bahwa itu hanya berisi kode yang relevan dengan desainer.

Kegunaan lain adalah untuk membagi implementasi berbagai antarmuka, mis:

partial class MyClass : IF1, IF2, IF3
{
    // main implementation of MyClass
}


partial class MyClass
{
    // implementation of IF1
}

partial class MyClass
{
    // implementation of IF2
}

Selain dari jawaban lain ...

Saya telah menemukan mereka membantu sebagai batu loncatan dalam refactoring kelas dewa. Jika sebuah kelas memiliki banyak tanggung jawab (terutama jika itu adalah file kode yang sangat besar) maka saya merasa bermanfaat untuk menambahkan 1x parsial kelas per-tanggung jawab sebagai pass pertama untuk pengorganisasian dan kemudian refactoring kode.

Ini sangat membantu karena dapat membantu membuat kode lebih mudah dibaca tanpa benar-benar memengaruhi perilaku eksekusi. Hal ini juga dapat membantu mengidentifikasi kapan suatu tanggung jawab mudah untuk ditolak atau terkait erat dengan aspek-aspek lain.

Namun - untuk menjadi jelas - ini masih kode yang buruk, pada akhir pengembangan Anda masih menginginkan satu tanggung jawab per kelas ( BUKAN per kelas parsial). Itu hanya batu loncatan :)

1. Beberapa Pengembang Menggunakan Kelas Partial, beberapa pengembang dapat bekerja dengan mudah di kelas yang sama.
2. Code Generator Kelas parsial terutama digunakan oleh generator kode untuk memisahkan masalah yang berbeda
3. Metode Partial Menggunakan Kelas Partial Anda juga dapat mendefinisikan metode Partial di mana pengembang dapat dengan mudah mendefinisikan metode dan pengembang lain dapat menerapkannya.

4. Deklarasi Metode Parsial saja Bahkan kode dapat dikompilasi hanya dengan deklarasi metode dan jika implementasi metode ini tidak ada, kompiler dapat dengan aman menghapus potongan kode itu dan tidak ada kesalahan waktu kompilasi yang akan terjadi.

   Untuk memverifikasi poin 4. Cukup buat proyek winform dan sertakan baris ini setelah Form1 Konstruktor dan coba untuk mengkompilasi kode

   partial void Ontest(string s);

Berikut adalah beberapa hal yang perlu dipertimbangkan saat menerapkan kelas parsial: -

1. Gunakan kata kunci parsial di setiap bagian dari kelas parsial.
2. Nama setiap bagian dari kelas parsial harus sama tetapi nama file sumber untuk setiap bagian dari kelas parsial bisa berbeda.
3. Semua bagian dari kelas parsial harus berada dalam namespace yang sama.
4. Setiap bagian dari kelas parsial harus berada dalam rakitan atau DLL yang sama, dengan kata lain Anda tidak bisa membuat kelas parsial dalam file sumber dari proyek perpustakaan kelas yang berbeda.
5. Setiap bagian dari kelas parsial harus memiliki aksesibilitas yang sama. (yaitu: pribadi, publik atau dilindungi)
6. Jika Anda mewarisi kelas atau antarmuka pada kelas parsial maka itu diwarisi oleh semua bagian dari kelas parsial itu.
7. Jika bagian dari kelas parsial disegel maka seluruh kelas akan disegel.
8. Jika bagian dari kelas parsial adalah abstrak maka seluruh kelas akan dianggap sebagai kelas abstrak.

Salah satu kegunaan yang bagus adalah memisahkan kode yang dihasilkan dari kode tulisan tangan milik kelas yang sama.

Sebagai contoh karena LINQ ke SQL menggunakan kelas parsial Anda dapat menulis implementasi Anda sendiri dari bagian-bagian fungsionalitas tertentu (seperti hubungan Many-to-Many) dan potongan-potongan kode kustom tidak akan ditimpa ketika Anda kembali menghasilkan kode.

Hal yang sama berlaku untuk kode WinForms. Semua kode yang dihasilkan Perancang berjalan dalam satu file yang biasanya tidak Anda sentuh. Kode tulisan tangan Anda ada di file lain. Dengan begitu, saat Anda mengubah sesuatu di Designer, perubahan Anda tidak akan hilang begitu saja.

Memang benar bahwa Partial Class digunakan dalam pembuatan kode otomatis, satu penggunaan dapat mempertahankan file kelas besar yang mungkin memiliki ribuan baris kode. Anda tidak pernah tahu kelas Anda mungkin berakhir dengan 10 ribu baris dan Anda tidak ingin membuat kelas baru dengan nama yang berbeda.

public partial class Product
{
    // 50 business logic embedded in methods and properties..
}

public partial class Product
{
    // another 50 business logic embedded in methods and properties..
}
//finally compile with product.class file.

Penggunaan lain yang mungkin dapat dilakukan adalah bahwa lebih dari satu pengembang dapat bekerja pada kelas yang sama karena mereka disimpan di tempat yang berbeda. Orang-orang mungkin tertawa tetapi Anda tidak pernah tahu kadang-kadang bisa sedikit.

Product1.cs

public partial class Product
{
    //you are writing the business logic for fast moving product
}

Product2.cs

public partial class Product
{
    // Another developer writing some business logic...
}

Semoga ini masuk akal!

Kelas parsial span beberapa file.

Bagaimana Anda bisa menggunakan pengubah parsial pada deklarasi kelas C #?

Dengan kelas parsial, Anda dapat secara fisik memisahkan kelas menjadi beberapa file. Ini sering dilakukan oleh pembuat kode.

Contoh

Dengan kelas C # normal, Anda tidak dapat mendeklarasikan kelas dalam dua file terpisah dalam proyek yang sama. Tetapi dengan partialmodifikator, Anda bisa.

Ini berguna jika satu file umumnya diedit dan yang lainnya dihasilkan mesin atau jarang diedit.

Berikut ini contoh untuk diklarifikasi:

class Program
{
    static void Main()
    {
        A.A1();
        A.A2();
    }
}

Isi file A1.cs: C #

using System;

partial class A
{
    public static void A1()
    {
        Console.WriteLine("A1");
    }
}

Isi file A2.cs: C #

using System;

partial class A
{
    public static void A2()
    {
        Console.WriteLine("A2");
    }
}

Keluaran:

A1
A2

Dibutuhkan sebagian di sini.

Jika Anda menghapus partialpengubah, Anda akan mendapatkan kesalahan yang mengandung teks ini:

[Namespace ' <global namespace>' sudah berisi definisi untuk ' A'].

Tip:

Untuk memperbaikinya, Anda dapat menggunakan partialkata kunci, atau mengubah salah satu nama kelas.

Bagaimana kompiler C # menangani kelas parsial?

Jika Anda membongkar program di atas (menggunakan IL Disassembler), Anda akan melihat bahwa file A1.cs dan A2.cs dihilangkan. Anda akan menemukan bahwa kelas A hadir.

Kelas A akan berisi metode A1 dan A2 di blok kode yang sama. Kedua kelas digabung menjadi satu.

Hasil kompilasi dari A1.cs dan A2.cs: C #

internal class A
{
    // Methods
    public static void A1()
    {
        Console.WriteLine("A1");
    }

    public static void A2()
    {
        Console.WriteLine("A2");
    }
}

Ringkasan

• Kelas parsial dapat menyederhanakan situasi pemrograman C # tertentu.
• Mereka sering digunakan dalam Visual Studio saat membuat program Windows Forms / WPF.
• Kode C # yang dihasilkan mesin terpisah.
• Atau Anda dapat menemukan keseluruhan deskripsi di sini .

menjaga semuanya sebersih mungkin ketika bekerja dengan kelas-kelas besar, atau ketika bekerja di tim, Anda dapat mengedit tanpa mengesampingkan (atau selalu melakukan perubahan)

Penggunaan utama untuk kelas parsial adalah dengan kode yang dihasilkan. Jika Anda melihat jaringan WPF (Windows Presentation Foundation), Anda mendefinisikan UI Anda dengan markup (XML). Markup itu dikompilasi ke dalam kelas parsial. Anda mengisi kode dengan kelas parsial Anda sendiri.

Jika Anda memiliki kelas yang cukup besar yang tidak memungkinkannya untuk melakukan refactoring yang efektif, memisahkannya menjadi beberapa file membantu menjaga semuanya tetap teratur.

Misalnya, jika Anda memiliki database untuk situs yang berisi forum diskusi dan sistem produk, dan Anda tidak ingin membuat dua kelas penyedia yang berbeda (BUKAN hal yang sama dengan kelas proxy, hanya untuk memperjelas), Anda dapat buat kelas parsial tunggal dalam file yang berbeda, seperti

MyProvider.cs - logika inti

MyProvider.Forum.cs - metode yang berkaitan khusus dengan forum

MyProvider.Product.cs - metode untuk produk

Ini hanyalah cara lain untuk menjaga agar semuanya tetap teratur.

Juga, seperti yang orang lain katakan, ini tentang satu-satunya cara untuk menambahkan metode ke kelas yang dihasilkan tanpa menjalankan risiko penambahan Anda hancur saat berikutnya kelas dibuat ulang. Ini berguna dengan kode yang dihasilkan template (T4), ORM, dll.

Sebagai alternatif untuk arahan pra-kompiler.

Jika Anda menggunakan arahan pra-kompiler (yaitu #IF DEBUG) maka Anda berakhir dengan beberapa kode yang tampak kusut bercampur dengan kode rilis aktual Anda.

Anda dapat membuat kelas parsial terpisah untuk berisi kode ini, dan membungkus seluruh kelas parsial dalam arahan, atau menghilangkan file-kode tersebut agar tidak dikirim ke kompiler (secara efektif melakukan hal yang sama).

Referensi layanan adalah contoh lain di mana kelas parsial berguna untuk memisahkan kode yang dihasilkan dari kode yang dibuat pengguna.

Anda dapat "memperpanjang" kelas-kelas layanan tanpa ditimpa ketika Anda memperbarui referensi layanan.

Kegunaan lain yang saya lihat adalah,

Memperluas kelas abstrak besar tentang logika akses data,

saya memiliki berbagai file dengan nama Post.cs, Comment.cs, Pages.cs ...

in Post.cs 

public partial class XMLDAO :BigAbstractClass
{
// CRUD methods of post..
}


in Comment.cs 

public partial class XMLDAO :BigAbstractClass
{
// CRUD methods of comment..
}

in Pages.cs 

public partial class XMLDAO :BigAbstractClass
{
// CRUD methods of Pages..
}

Kebanyakan orang berkomentar bahwa partialseharusnya hanya digunakan untuk kelas yang memiliki file kode yang dihasilkan atau untuk antarmuka. Saya tidak setuju, dan inilah alasannya.

Sebagai satu contoh, mari kita lihat kelas C # System.Math ... itu kelas . Saya tidak akan mencoba memasukkan 70+ metode ke dalam file kode tunggal yang sama. Akan menjadi mimpi buruk untuk dipertahankan.

Menempatkan setiap metode matematika ke dalam file kelas parsial individual, dan semua file kode ke folder Math dalam proyek, akan menjadi organisasi yang jauh lebih bersih.

Hal yang sama dapat / akan berlaku untuk banyak kelas lain yang memiliki sejumlah besar fungsi yang beragam. Misalnya kelas untuk mengelola API PrivateProfile mungkin mendapat manfaat dengan dipecah menjadi seperangkat file kelas parsial yang bersih dalam folder proyek tunggal.

Secara pribadi, saya juga membagi apa yang oleh kebanyakan orang disebut kelas "helper" atau "utility" menjadi file parsial individual untuk setiap metode atau grup fungsional metode. Misalnya pada satu proyek, kelas string helper memiliki hampir 50 metode. Itu akan menjadi file kode yang panjang dan berat bahkan menggunakan wilayah. Secara signifikan lebih mudah untuk mempertahankan menggunakan file kelas parsial individual untuk setiap metode.

Saya hanya akan berhati-hati menggunakan kelas parsial dan menjaga semua tata letak file kode konsisten di seluruh proyek ketika melakukan ini. Seperti menempatkan enum publik kelas dan anggota privat kelas ke dalam Common.cs atau file dengan nama yang sama di folder, alih-alih menyebarkannya di seluruh file kecuali mereka khusus untuk hanya sebagian file yang terkandung di dalamnya.

Perlu diingat bahwa ketika Anda membagi kelas menjadi file yang terpisah, Anda juga kehilangan kemampuan untuk menggunakan bilah splitter editor teks yang memungkinkan Anda melihat dua bagian berbeda dari file saat ini secara bersamaan.

Kelas parsial memungkinkan untuk menambahkan fungsionalitas ke program yang dirancang hanya dengan menambahkan file sumber. Misalnya, program impor file dapat dirancang sehingga orang dapat menambahkan berbagai jenis file yang dikenal dengan menambahkan modul yang menangani mereka. Misalnya, konverter tipe file utama dapat menyertakan kelas kecil:

Kelas Publik Sebagian zzFileConverterRegistrar
    Event Register (ByVal mainConverter sebagai zzFileConverter)
    Sub registerAll (ByVal mainConverter sebagai zzFileConverter)
        RaiseEvent Register (mainConverter)
    End Sub
Kelas Akhir

Setiap modul yang ingin mendaftarkan satu atau lebih jenis konverter file dapat mencakup sesuatu seperti:

Kelas Publik Sebagian zzFileConverterRegistrar
    Private Sub RegisterGif (ByVal mainConverter sebagai zzFileConverter) Menangani Saya. Pendaftaran
        mainConverter.RegisterConverter ("GIF", GifConverter.NewFactory))
    End Sub
Kelas Akhir

Perhatikan bahwa kelas konverter file utama tidak "terkena" - itu hanya memperlihatkan kelas rintisan kecil yang dapat dihubungkan dengan modul tambahan. Ada sedikit risiko penamaan konflik, tetapi jika setiap rutin "register" modul add-in dinamai sesuai dengan jenis file yang ditangani, mereka mungkin tidak boleh menimbulkan masalah. Orang bisa menempel GUID atas nama subrutin pendaftaran jika ada yang khawatir tentang hal-hal seperti itu.

Edit / Addendum Agar lebih jelas, tujuan dari ini adalah untuk menyediakan sarana yang dengannya berbagai kelas terpisah dapat membuat program utama atau kelas mengetahui tentang mereka. Satu-satunya hal yang akan dilakukan oleh konverter file utama dengan zzFileConverterRegistrar adalah membuat satu instance dari itu dan memanggil metode registerAll yang akan menjalankan event Register. Modul apa pun yang ingin mengaitkan peristiwa itu dapat mengeksekusi kode arbitrer sebagai respons terhadapnya (itulah gagasannya) tetapi tidak ada apa pun yang dapat dilakukan modul dengan memperluas kelas zzFileConverterRegistrar secara tidak benar selain menentukan metode yang namanya cocok dengan sesuatu yang lain . Tentu saja akan mungkin bagi satu ekstensi yang ditulis secara tidak pantas untuk memutus ekstensi yang ditulis dengan tidak patut, tetapi solusi untuk itu adalah bagi siapa saja yang tidak ingin ekstensi itu diputuskan hanya dengan menuliskannya dengan benar.

Seseorang dapat, tanpa menggunakan kelas parsial, memiliki sedikit kode di suatu tempat di dalam kelas konverter file utama, yang terlihat seperti:

  RegisterConverter ("GIF", GifConvertor.NewFactory)
  RegisterConverter ("BMP", BmpConvertor.NewFactory)
  RegisterConverter ("JPEG", JpegConvertor.NewFactory)

tetapi menambahkan modul konverter lain akan memerlukan masuk ke bagian kode konverter dan menambahkan konverter baru ke daftar. Menggunakan metode parsial, itu tidak lagi diperlukan - semua konverter akan disertakan secara otomatis.

Kelas parsial baru-baru ini membantu dengan kontrol sumber di mana beberapa pengembang menambahkan ke satu file di mana metode baru ditambahkan ke bagian yang sama dari file (diotomatisasi oleh Resharper).

Ini mendorong untuk git menyebabkan konflik gabungan. Saya tidak menemukan cara untuk memberi tahu alat gabungan untuk mengambil metode baru sebagai blok kode lengkap.

Kelas parsial dalam hal ini memungkinkan pengembang untuk tetap menggunakan versi file mereka, dan kami dapat menggabungkannya kembali nanti dengan tangan.

contoh -

• MainClass.cs - memegang bidang, konstruktor, dll
• MainClass1.cs - kode pengembang baru saat mereka menerapkan
• MainClass2.cs - adalah kelas pengembang lain untuk kode baru mereka.

Dari MSDN :

1. Pada waktu kompilasi, atribut definisi tipe parsial digabungkan. Misalnya, pertimbangkan deklarasi berikut:

[SerializableAttribute]
partial class Moon { }

[ObsoleteAttribute]
partial class Moon { }

Mereka setara dengan deklarasi berikut:

[SerializableAttribute]
[ObsoleteAttribute]
class Moon { }

Berikut ini digabungkan dari semua definisi tipe parsial:

• Komentar XML

• antarmuka

• atribut parameter tipe-generik

• atribut kelas

• anggota

2.Hal lain, kelas parsial bersarang dapat juga parsial:

partial class ClassWithNestedClass
{
    partial class NestedClass { }
}

partial class ClassWithNestedClass
{
    partial class NestedClass { }
}

Berikut adalah daftar beberapa keuntungan dari kelas parsial.

Anda dapat memisahkan kode desain UI dan kode logika bisnis sehingga mudah dibaca dan dipahami. Misalnya Anda sedang mengembangkan aplikasi web menggunakan Visual Studio dan menambahkan formulir web baru maka ada dua file sumber, "aspx.cs" dan "aspx.designer.cs". Kedua file ini memiliki kelas yang sama dengan kata kunci parsial. Kelas ".aspx.cs" memiliki kode logika bisnis sementara "aspx.designer.cs" memiliki definisi kontrol antarmuka pengguna.

Ketika bekerja dengan sumber yang dibuat secara otomatis, kode dapat ditambahkan ke kelas tanpa harus membuat ulang file sumber. Misalnya Anda bekerja dengan LINQ ke SQL dan membuat file DBML. Sekarang ketika Anda drag dan drop tabel itu menciptakan kelas parsial di designer.cs dan semua kolom tabel memiliki properti di kelas. Anda memerlukan lebih banyak kolom dalam tabel ini untuk mengikat pada kisi UI tetapi Anda tidak ingin menambahkan kolom baru ke tabel database sehingga Anda dapat membuat file sumber terpisah untuk kelas ini yang memiliki properti baru untuk kolom itu dan itu akan menjadi kelas parsial. Sehingga itu memengaruhi pemetaan antara tabel database dan entitas DBML tetapi Anda bisa dengan mudah mendapatkan bidang tambahan. Ini berarti Anda dapat menulis kode sendiri tanpa mengacaukan kode yang dihasilkan sistem.

Lebih dari satu pengembang dapat secara bersamaan menulis kode untuk kelas.

Anda dapat mempertahankan aplikasi Anda dengan lebih baik dengan memadatkan kelas-kelas besar. Misalkan Anda memiliki kelas yang memiliki banyak antarmuka sehingga Anda dapat membuat banyak file sumber tergantung pada implementasi antarmuka. Sangat mudah untuk memahami dan memelihara antarmuka yang diimplementasikan di mana file sumber memiliki kelas parsial.

Setiap kali saya memiliki kelas yang berisi kelas bersarang dengan ukuran / kompleksitas yang signifikan, saya menandai kelas sebagai partialdan menempatkan kelas bersarang di file yang terpisah. Saya memberi nama file yang berisi kelas bersarang menggunakan aturan: [nama kelas]. [Nama kelas bersarang] .cs.

Blog MSDN berikut menjelaskan penggunaan kelas parsial dengan kelas bersarang untuk pemeliharaan: http://blogs.msdn.com/b/marcelolr/archive/2009/04/13/using-partial-classes-with-nested-classes-for- rawatan.aspx

Saya tahu pertanyaan ini benar-benar tua tetapi saya hanya ingin menambahkan pendapat saya tentang kelas parsial.

Salah satu alasan saya secara pribadi menggunakan kelas parsial adalah ketika saya membuat binding untuk sebuah program, terutama mesin-mesin negara.

Sebagai contoh, OpenGL adalah mesin negara, ada banyak metode yang semuanya dapat diubah secara global, namun, dalam pengalaman saya mengikat sesuatu yang mirip dengan OpenGL di mana ada banyak metode, kelas dapat dengan mudah melebihi 10k LOC.

Kelas parsial akan memecah ini untuk saya dan membantu saya menemukan metode dengan cepat.

Kelas parsial terutama diperkenalkan untuk membantu generator Kode, jadi kami (pengguna) tidak berakhir kehilangan semua pekerjaan kami / perubahan ke kelas yang dihasilkan seperti kelas ASP.NET's .designer.cs setiap kali kami regenerasi, hampir semua alat baru yang menghasilkan kode LINQ, EntityFrameworks, ASP.NET menggunakan kelas parsial untuk kode yang dihasilkan, sehingga kami dapat dengan aman menambahkan atau mengubah logika dari kode yang dihasilkan ini mengambil keuntungan dari kelas dan metode parsial, tetapi sangat hati-hati sebelum Anda menambahkan barang ke kode yang dihasilkan menggunakan kelas parsial lebih mudah jika kita merusak build tetapi yang terburuk jika kita memperkenalkan kesalahan runtime. Untuk detail lebih lanjut, lihat http://www.4guysfromrolla.com/articles/071509-1.aspx ini

Saya mencatat dua penggunaan yang saya tidak dapat menemukan secara eksplisit dalam jawabannya.

Mengelompokkan Item Kelas

Beberapa pengembang menggunakan komentar untuk memisahkan "bagian" yang berbeda dari kelas mereka. Misalnya, tim mungkin menggunakan konvensi berikut:

public class MyClass{  
  //Member variables
  //Constructors
  //Properties
  //Methods
}

Dengan kelas parsial, kita dapat melangkah lebih jauh, dan membagi bagian menjadi file yang terpisah. Sebagai suatu konvensi, suatu tim dapat mengakhiri setiap file dengan bagian yang sesuai dengannya. Jadi di atas kita akan memiliki sesuatu seperti: MyClassMembers.cs, MyClassConstructors.cs, MyClassProperties.cs, MyClassMethods.cs.

Seperti jawaban lain disinggung, apakah perlu membagi kelas atau tidak mungkin tergantung pada seberapa besar kelas dalam kasus ini. Jika kecil, mungkin lebih mudah memiliki semuanya dalam satu kelas master. Tetapi jika ada bagian yang terlalu besar, isinya dapat dipindahkan ke kelas parsial yang terpisah, agar kelas master tetap rapi. Sebuah konvensi dalam kasus itu mungkin meninggalkan komentar dalam mengatakan sesuatu seperti "Lihat kelas parsial" setelah judul bagian misalnya:

//Methods - See partial class

Mengelola Lingkup Menggunakan pernyataan / Namespace

Ini mungkin jarang terjadi, tetapi mungkin ada tabrakan namespace antara dua fungsi dari perpustakaan yang ingin Anda gunakan. Dalam satu kelas, Anda bisa paling banyak menggunakan klausa penggunaan untuk salah satunya. Untuk yang lain Anda membutuhkan nama atau alias yang benar-benar memenuhi syarat. Dengan kelas parsial, karena setiap namespace & menggunakan daftar pernyataan berbeda, satu dapat memisahkan dua set fungsi menjadi dua file terpisah.