Мені було цікаво, чи може хтось дати мені огляд того, чому я буду їх використовувати та яку перевагу я отримаю в процесі.

Найбільше використання часткових класів - це полегшити життя генераторам / дизайнерам кодів. Часткові класи дозволяють генератору просто випромінювати код, який їм потрібно випромінювати, і їм не доведеться мати справу з правками користувача у файл. Користувачі також можуть коментувати клас новими членами, маючи другий частковий клас. Це забезпечує дуже чисту основу для розділення проблем.

Кращий спосіб поглянути на це - побачити, як функціонували дизайнери перед частковими заняттями. Дизайнер WinForms виплюнув би весь код всередині регіону з чітко сформульованими коментарями щодо не зміни коду. Доводилося вставляти всілякі евристики, щоб знайти згенерований код для подальшої обробки. Тепер він може просто відкрити файл дизайнера.cs і мати високу впевненість, що він містить лише код, відповідний дизайнеру.

Інше використання - це розділити реалізацію різних інтерфейсів, наприклад:

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


partial class MyClass
{
    // implementation of IF1
}

partial class MyClass
{
    // implementation of IF2
}

Окрім інших відповідей ...

Я вважаю їх корисними як кроком для реконструкції бого-класів. Якщо клас має декілька обов'язків (особливо, якщо це дуже великий файл коду), тоді я вважаю вигідним додати 1x частковий клас відповідальності в якості першого пропуску для організації, а потім рефакторингу коду.

Це дуже допомагає, тому що може допомогти зробити код набагато більш читабельним, не впливаючи на поведінку виконавця. Це також може допомогти визначити, коли відповідальність легко перетворити, або вона чітко пов'язана з іншими аспектами.

Однак - щоб було зрозуміло - це все-таки поганий код, в кінці розробки ви все одно хочете однієї відповідальності за клас ( НЕ за частковий клас). Це просто трамплін :)

1. Кілька розробників використовують часткові класи, кілька розробників можуть легко працювати на одному класі.
2. Генератор коду Часткові класи в основному використовуються генератором кодів, щоб розділити різні проблеми
3. Часткові методи використовуючи часткові класи, ви також можете визначити часткові методи, а також тоді, коли розробник може просто визначити метод, а інший розробник може це застосувати.

4. Декларація лише з частковим методом Навіть код збирається лише з декларацією методу, і якщо реалізація методу відсутня, компілятор може безпечно видалити цей фрагмент коду, і помилка часу компіляції не відбудеться.

   Для перевірки пункту 4. Просто створіть проект winform і включіть цей рядок після конструктора Form1 і спробуйте скласти код

   partial void Ontest(string s);

Ось деякі моменти, які слід враховувати під час впровадження часткових класів:

1. Використовуйте часткове ключове слово у кожній частині часткового класу.
2. Ім'я кожної частини часткового класу має бути однаковим, але ім'я вихідного файлу для кожної частини часткового класу може бути різним.
3. Усі частини часткового класу повинні знаходитися в одному просторі імен.
4. Кожна частина часткового класу повинна бути в одній збірці або DLL, іншими словами, ви не можете створити частковий клас у вихідних файлах з іншого проекту бібліотеки класів.
5. Кожна частина часткового класу повинна мати однакову доступність. (тобто: приватні, державні чи захищені)
6. Якщо ви успадковуєте клас або інтерфейс на частковому класі, то він успадковується всіма частинами цього часткового класу.
7. Якщо частина часткового класу запечатана, то весь клас буде запечатаний.
8. Якщо частина часткового класу абстрактна, то весь клас вважатиметься абстрактним класом.

Одним із великих можливостей є відокремлення згенерованого коду від рукописного коду, що належить до одного класу.

Наприклад, оскільки LINQ до SQL використовує часткові класи, ви можете написати власну реалізацію певних фрагментів функціональності (наприклад, багато-багато-багато стосунків), і ці фрагменти користувацького коду не будуть перезаписані при повторному генеруванні коду.

Те саме стосується коду WinForms. Весь код, створений дизайнером, зберігається в одному файлі, який ви, як правило, не торкаєтесь. Ваш рукописний код зберігається в іншому файлі. Таким чином, коли ви щось змінюєте в дизайнері, ваші зміни не здуваються.

Це правда, що Partial Class використовується в автоматичному генеруванні коду, одне використання може бути підтримкою великого файлу класу, який може мати тисячу рядків коду. Ви ніколи не знаєте, що ваш клас може закінчитися 10 тисячами рядків, і ви не хочете створювати новий клас з іншою назвою.

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.

Іншим можливим використанням може бути те, що більше одного розробника може працювати в одному класі, оскільки вони зберігаються в різних місцях. Люди можуть сміятися, але ти ніколи не знаєш, що іноді може бути пригорш.

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...
}

Сподіваюся, це має сенс!

Часткові класи охоплюють кілька файлів.

Як можна використовувати частковий модифікатор у декларації класу C #?

За допомогою часткових класів ви можете фізично розділити клас на кілька файлів. Це часто роблять генератори коду.

Приклад

З звичайними класами C # ви не можете оголосити клас у двох окремих файлах в одному проекті. Але з partialмодифікатором ви можете.

Це корисно, якщо один файл зазвичай редагується, а другий створюється машинним або рідко редагується.

Ось приклад для уточнення:

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

Зміст файлу A1.cs: C #

using System;

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

Зміст файлу A2.cs: C #

using System;

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

Вихід:

A1
A2

Тут потрібно частково.

Якщо ви видалите partialмодифікатор, ви отримаєте помилку, що містить цей текст:

[Простір імен ' <global namespace>' вже містить визначення для ' A'].

Порада:

Щоб виправити це, ви можете або скористатися partialключовим словом, або змінити одне з назв класу.

Як компілятор C # має справу з частковими класами?

Якщо розібрати вищевказану програму (використовуючи IL Disassembler), ви побачите, що файли A1.cs та A2.cs усунені. Ви побачите, що клас А присутній.

Клас A буде містити методи A1 і A2 в одному кодовому блоці. Два класи були об'єднані в один.

Складений результат A1.cs і A2.cs: C #

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

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

Підсумок

• Часткові класи можуть спростити певні ситуації програмування на C #.
• Вони часто використовуються у Visual Studio при створенні програм Windows Forms / WPF.
• Сгенерований машиною код C # є окремим.
• Або ви можете знайти весь опис тут .

щоб все було максимально чистим під час роботи з величезними класами чи під час роботи в команді, ви можете редагувати, не змінюючи їх (або завжди вводячи зміни)

Основне використання для часткових класів - з генерованим кодом. Якщо ви подивитесь на мережу WPF (Windows Presentation Foundation), ви визначите свій інтерфейс з розміткою (XML). Ця розмітка складається в часткові класи. Ви заповнюєте код власними частковими класами.

Якщо у вас достатньо великий клас, який не піддається ефективному рефакторингу, розділення його на кілька файлів допомагає організовувати речі.

Наприклад, якщо у вас є база даних для веб-сайту, що містить дискусійний форум і систему продуктів, і ви не хочете створювати два різних класи провайдерів (НЕ те саме, що проксі-клас, просто щоб було зрозуміло), ви можете створити єдиний частковий клас у різних файлах, наприклад

MyProvider.cs - основна логіка

MyProvider.Forum.cs - методи, що стосуються конкретно форуму

MyProvider.Product.cs - методи для продуктів

Це просто інший спосіб організувати речі.

Крім того, як говорили інші, мова йде про єдиний спосіб додати методи до згенерованого класу, не ризикуючи знищити ваші доповнення наступного разу, коли клас відновиться. Це стане в нагоді з генерованим шаблоном (T4) кодом, ORM тощо.

Як альтернатива директивам перед компілятором.

Якщо ви використовуєте директиви попереднього компілятора (а саме #IF DEBUG), то у вас з’являється якийсь кодовий вигляд коду, змішаний з вашим фактичним кодом випуску.

Ви можете створити окремий частковий клас, який міститиме цей код, і або загортати весь частковий клас у директиву, або упускати цей код-файл від надсилання компілятору (фактично роблячи те ж саме).

Посилання на сервіси - ще один приклад, коли часткові класи корисні для відділення створеного коду від створеного користувачем коду.

Ви можете "розширити" класи сервісів, не перезаписуючи їх під час оновлення посилання на службу.

Ще одне використання, яке я бачив,

Розширення великого абстрактного класу щодо логіки доступу до даних,

у мене є різні файли з іменами 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..
}

Більшість людей зауважує це partial слід використовувати лише для класу, який має згенерований файл коду, або для інтерфейсів. Я не згоден, і ось чому.

Для прикладу розглянемо клас C # System.Math ... це клас . Я б не намагався вкласти 70+ методів все в один і той самий файл коду. Це було б кошмаром.

Розміщення кожного математичного методу в окремих файлах часткового класу та всіх файлів коду в папці Math в проекті було б значно чіткішою організацією.

Те саме могло б / було би справедливо для багатьох інших класів, які мають велику кількість різноманітних функціональних можливостей. Наприклад, клас для управління API PrivateProfile може отримати користь, розділившись на чистий набір файлів часткового класу в одній папці проекту.

Особисто я також розділив те, що більшість людей називає класи "помічники" або "корисні" на окремі часткові файли для кожного методу або методу функціональної групи. Наприклад, в одному проекті клас помічників струн має майже 50 методів. Це був би тривалий кодовий файл коду, навіть використовуючи регіони. Значно простіше підтримувати, використовуючи окремі файли часткового класу для кожного методу.

Я б просто обережно використовував часткові класи та дотримувався послідовності розміщення всіх файлів коду протягом проекту. Наприклад, розміщення будь-яких загальнодоступних переписувачів та приватних членів класу в загальній файлі Common.cs або аналогічному імені в папці, замість того, щоб поширювати їх по файлам, якщо вони не стосуються лише часткового файлу, в якому вони містяться.

Майте на увазі, що, розділяючи клас на окремі файли, ви також втрачаєте можливість використовувати панель розщеплення текстового редактора, яка дозволяє переглядати два різні розділи поточного файлу одночасно.

Часткові класи дозволяють додати функціональність до відповідно розробленої програми лише додаванням вихідних файлів. Наприклад, програма імпорту файлів може бути спроектована таким чином, щоб можна було додати різні типи відомих файлів, додавши модулі, які ними обробляють. Наприклад, основний конвертер типів файлів може містити невеликий клас:

Частковий публічний клас zzFileConverterRegistrar
    Реєстр подій (ByVal mainConverter як zzFileConverter)
    ПідреєстрВсі (ByVal mainConverter як zzFileConverter)
        Регістр RaiseEvent (mainConverter)
    Кінець Під
Кінцевий клас

Кожен модуль, який бажає зареєструвати один або кілька типів конвертора файлів, може включати щось на зразок:

Частковий публічний клас zzFileConverterRegistrar
    Приватний підреєстрGif (ByVal mainConverter як zzFileConverter) обробляє Me.Register
        mainConverter.RegisterConverter ("GIF", GifConverter.NewFactory))
    Кінець Під
Кінцевий клас

Зауважте, що основний клас перетворювача файлів не "піддається впливу" - він просто відкриває невеликий клас заглушки, до якого можуть підключитися додаткові модулі. Існує невеликий ризик іменування конфліктів, але якщо процедура "реєстрації" кожного модуля надбудови називається відповідно до типу файлу, який він обробляє, вони, ймовірно, не повинні створювати проблем. Можна назвати GUID у назві підпрограми реєстрації, якщо хтось турбується про такі речі.

Редагування / Додаток Щоб було зрозуміло, мета цього - забезпечити засоби, за допомогою яких різноманітні окремі класи можуть повідомити про них основну програму чи клас. Єдине, що головний конвертер файлів зробить із zzFileConverterRegistrar, це створити один його примірник та викликати метод registerAll, який запустить подію «Реєстрація». Будь-який модуль, який хоче підключити цю подію, може виконати довільний код у відповідь на це (ось і вся ідея), але нічого не можна зробити, якщо модуль неправильно розширить клас zzFileConverterRegistrar, крім визначення методу, ім'я якого відповідає тому чимому іншому . Безумовно, можливо, що одне неправильно написане розширення зламає інше неправильно написане розширення, але рішення для того, хто не хоче, щоб його розширення було просто записане належним чином.

Можна, не користуючись частковими класами, мати трохи коду десь в основному класі перетворювача файлів, який виглядав так:

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

але додавання іншого модуля перетворювача потребує переходу в цю частину коду перетворювача та додавання нового перетворювача до списку. Використовуючи часткові методи, це вже не потрібно - всі перетворювачі включаються автоматично.

Часткові класи нещодавно допомогли з керуванням джерелами, де кілька розробників додавали до одного файлу, де нові методи були додані до тієї самої частини файлу (автоматизована Resharper).

Ці поштовхи до git викликали конфлікти злиття. Я не знайшов способу сказати інструменту злиття, щоб прийняти нові методи як повний блок коду.

Часткові класи в цьому відношенні дозволяють розробникам дотримуватися версії свого файлу, і ми можемо об'єднати їх згодом вручну.

приклад -

• MainClass.cs - містить поля, конструктор тощо
• MainClass1.cs - новий код розробників під час їх реалізації
• MainClass2.cs - ще один клас розробників для їх нового коду.

Від MSDN :

1.В час компіляції атрибути визначень часткового типу об'єднуються. Наприклад, розгляньте такі декларації:

[SerializableAttribute]
partial class Moon { }

[ObsoleteAttribute]
partial class Moon { }

Вони еквівалентні наступним деклараціям:

[SerializableAttribute]
[ObsoleteAttribute]
class Moon { }

Нижче наведено об'єднання всіх визначень часткового типу:

• XML коментарі

• інтерфейси

• атрибути параметрів загального типу

• атрибути класу

• члени

2. Інша річ, вкладені часткові класи також можуть бути частковими:

partial class ClassWithNestedClass
{
    partial class NestedClass { }
}

partial class ClassWithNestedClass
{
    partial class NestedClass { }
}

Ось перелік деяких переваг часткових класів.

Ви можете відокремити код дизайну інтерфейсу та код бізнес-логіки, щоб його було легко читати та розуміти. Наприклад, ви розробляєте веб-додаток за допомогою Visual Studio і додаєте нову веб-форму, тоді є два вихідні файли, "aspx.cs" та "aspx.designer.cs". Ці два файли мають один клас із частковим ключовим словом. Клас ".aspx.cs" має код логіки бізнесу, тоді як "aspx.designer.cs" має визначення управління інтерфейсом користувача.

Під час роботи з автоматично створеним джерелом код можна додати до класу без необхідності відтворювати вихідний файл. Наприклад, ви працюєте з LINQ в SQL і створюєте файл DBML. Тепер, коли ви перетягуєте таблицю, вона створює частковий клас у дизайнер.cs, а всі стовпці таблиці мають властивості в класі. Вам потрібно більше стовпців у цій таблиці для прив’язки до сітки інтерфейсу користувача, але ви не хочете додавати новий стовпець до таблиці бази даних, щоб ви могли створити окремий вихідний файл для цього класу, який має нове властивість для цього стовпця, і він буде бути частковим класом. Отже, це впливає на відображення між таблицею баз даних та об'єктом DBML, але ви можете легко отримати додаткове поле. Це означає, що ви можете писати код самостійно, не возившись із створеним системою кодом.

Більше одного розробника може одночасно записати код для класу.

Ви можете підтримувати свою програму краще, ущільнюючи великі класи. Припустимо, у вас є клас, який має декілька інтерфейсів, щоб ви могли створювати декілька вихідних файлів залежно від реалізації інтерфейсу. Легко зрозуміти та підтримувати інтерфейс, реалізований на якому вихідний файл має частковий клас.

Щоразу, коли у мене є клас, який містить вкладений клас, який має будь-який значний розмір / складність, я позначаю клас як partialі кладу вкладений клас в окремий файл. Я називаю файл, що містить вкладений клас за допомогою правила: [назва класу]. [Вкладене ім'я класу] .cs.

Наступний блог MSDN пояснює використання часткових класів із вкладеними класами для збереження: http://blogs.msdn.com/b/marcelolr/archive/2009/04/13/using-partial-classes-with-nested-classes-for- maintainability.aspx

Я знаю, що це питання справді старе, але я просто хотів би додати свою часткову заняття.

Однією з причин того, що я особисто використовую часткові класи - це коли я створюю прив’язки для програми, особливо державних машин.

Наприклад, OpenGL - це державна машина, є купа методів, які можна змінити в усьому світі, однак, з мого досвіду, прив'язуючи щось подібне до OpenGL, де існує так багато методів, клас може легко перевищувати LOC 10k.

Часткові заняття розберуть це для мене і допоможуть мені швидко знайти методи.

Часткові класи в основному вводяться, щоб допомогти генераторам коду, тому ми (користувачі) не втрачаємо всю свою роботу / зміни в таких сформованих класах, як клас .designer.cs ASP.NET щоразу, коли ми регенеруємо, майже всі нові інструменти, що генерують. код LINQ, EntityFrameworks, ASP.NET використовують часткові класи для згенерованого коду, тому ми можемо сміливо додавати або змінювати логіку цих згенерованих кодів, користуючись частковими класами та методами, але будьте дуже обережні, перш ніж додавати речі до згенерованого коду за допомогою часткових класів простіше, якщо ми порушимо збірку, але найгірше, якщо ми введемо помилки виконання. Більш детально ознайомтеся з цим http://www.4guysfromrolla.com/articles/071509-1.aspx

Зазначу два звичаї, які я не могла знайти чітко у відповідях.

Групування предметів класу

Деякі розробники використовують коментарі для розділення різних "частин" свого класу. Наприклад, команда може використовувати таку конвенцію:

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

З частковими класами ми можемо піти на крок далі і розділити розділи на окремі файли. Як правило, команда може суфіксувати кожен файл із відповідним йому розділом. Отже, у вищесказаному ми мали б щось на зразок: MyClassMembers.cs, MyClassConstructors.cs, MyClassProperties.cs, MyClassMethods.cs.

Як і інші відповіді, на які, напевно, варто розділити клас чи ні, ймовірно, залежить від того, наскільки великий клас у цьому випадку. Якщо вона невелика, можливо, простіше мати все в одному майстер-класі. Але якщо будь-який із цих розділів стає занадто великим, його вміст можна перенести в окремий частковий клас, щоб зберегти майстер-клас акуратним. У такому випадку умовою може бути коментар, коли після заголовка розділу можна сказати щось на кшталт "Див. Частковий клас"

//Methods - See partial class

Керування сферою використання операторів / простору імен

Це, мабуть, рідкісне явище, але можливо зіткнення простору імен між двома функціями з бібліотек, які ви хочете використовувати. У одному класі ви можете максимум використовувати клавішу використання для одного з них. Для інших вам знадобиться повністю кваліфіковане ім’я або псевдонім. З частковими класами, оскільки кожен простір імен та перелік висловлювань різний, можна розділити два набори функцій на два окремих файли.