Що так погано в одиночних? [зачинено]

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

Переповнення стека особливо припускає, що всі згодні з тим, що Singletons є злими. Чому?

Будь ласка, підтримайте свої відповіді " фактами, посиланнями чи певною експертизою "

Перефразоване від Брайана Кнопка:

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

2. Вони порушують принцип єдиної відповідальності : завдяки тому, що вони контролюють власне створення та життєвий цикл.

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

4. Вони зберігають стан протягом усього життя програми. Ще одне враження від тестування, оскільки у вас може виникнути ситуація, коли потрібно замовити тести, що для одиничних тестів є великим "ні". Чому? Оскільки кожен одиничний тест повинен бути незалежним від іншого.

Сінглтони вирішують одну (і лише одну) задачу.

Суперечка ресурсів.

Якщо у вас є якийсь ресурс, це

( 1 ) може мати лише один екземпляр, і

( 2 ) вам потрібно керувати цим єдиним екземпляром,

вам потрібен сингл .

Прикладів не так багато. Файл журналу - великий. Ви не хочете просто відмовитися від одного файлу журналу. Ви хочете належним чином очистити, синхронізувати та закрити. Це приклад єдиного спільного ресурсу, яким потрібно керувати.

Рідко буває, що вам потрібен сингл. Причина, що вони погані, полягає в тому, що вони відчувають себе глобальними, і вони є повністю платним членом книги GoF Design Patterns .

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

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

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

Місько Гевери від Google має кілька цікавих статей саме на цю тему ...

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

Синглтони - це не що інше, як глобальна держава. Глобальна держава робить це, щоб ваші об'єкти могли таємно влаштовувати речі, які не задекларовані в їх API, і, як результат, Singletons перетворюють ваші API в патологічних брехунів.

Там, де всі Singletons Gone, вказується на те, що введення залежності залежно від того, щоб отримати екземпляри до конструкторів, які вимагають їх, що полегшує основну потребу позаду поганих, глобальних синглтонів, описаних у першій статті.

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

Люди думають, що Сінглтон є злом, тому що вони використовують його для глобальних. Саме через цю плутанину Сінглтон дивиться вниз. Будь ласка, не плутайте одиночних та глобальних. Якщо використовувати його за призначенням, призначеному для нього, ви отримаєте надзвичайну користь від шаблону Singleton.

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

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

Так в основному:

public MyConstructor(Singleton singleton) {
    this.singleton = singleton;
}

а не:

public MyConstructor() {
    this.singleton = Singleton.getInstance();
}

Я вважаю, що така схема називається ін'єкцією залежності і, як правило, вважається хорошою справою.

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

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

Однотонні також є проблемою з точки зору тестування. Вони, як правило, ускладнюють написання ізольованих одиничних тестів. Інверсія управління (IoC) та ін'єкція залежності є моделями, призначеними для подолання цієї проблеми об'єктно-орієнтованим способом, який піддається одиничному тестуванню.

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

Існує також багатопотоковий сценарій, коли одиночні кнопки можуть стати вузьким місцем, а також проблема синхронізації.

Синглтон реалізується за допомогою статичного методу. Статистичні методи уникають людям, які проводять тестування, оскільки їх не можна глузувати чи заглушувати. Більшість людей на цьому сайті є великими прихильниками тестування одиниць. Загальноприйнятою умовою для їх уникнення є використання інверсії схеми управління .

Сінглтон також поганий, якщо мова йде про кластеризацію . Тому що тоді у вас більше немає «рівно одного сингтона» у вашій заяві.

Розглянемо таку ситуацію: Як розробник, ви повинні створити веб-додаток, який має доступ до бази даних. Щоб одночасні виклики бази даних не конфліктували між собою, ви створюєте збереження потоку SingletonDao:

public class SingletonDao {
    // songleton's static variable and getInstance() method etc. omitted
    public void writeXYZ(...){
        synchronized(...){
            // some database writing operations...
        }
    }
}

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

На сьогодні все добре.

Тепер, подумайте, що ви хочете налаштувати декілька примірників вашого веб-програми в кластері. Тепер у вас раптом щось таке:

Це звучить дивно, але зараз у вашому додатку багато одинаків . І саме так не повинно бути одиночний: Маючи багато предметів. Це особливо погано, якщо ви, як показано в цьому прикладі, хочете здійснювати синхронізовані дзвінки до бази даних.

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

1. Він легко (ab) використовується як глобальна змінна.
2. Класи, які залежать від синглів, порівняно складніше одиничного тестування ізольовано.

Монополія - ​​це диявол, а одиночні особи з нечитаним / незмінним станом є "справжньою" проблемою ...

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

Глобальний - це погано, оскільки:

• а. Це викликає конфлікт у просторі імен
• б. Це викриває державу необґрунтовано

Якщо мова йде про Сінглтон

• а. Явний вихідний спосіб викликати їх, запобігає конфліктам, тому вкажіть a. це не проблема
• б. Однотонні без штату є (як фабрики) - це не проблема. Синглтони зі станом можуть знову потрапляти у дві категорії, ті, які є незмінними або записуються один раз і читаються багато (файли конфігурацій / властивостей). Це непогано. Змінні одинарники, які є власниками довідок, - це ті, про які ви говорите.

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

Як це стосується монополії?

Щоб розпочати гру монополії, спочатку:

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

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

Отже, ви граєте в монополію з друзями Бобом, Джо та Едом. Ви швидко будуєте свою імперію і споживаєте частку ринку з експоненціальною швидкістю. Ваші опоненти слабшають, і ви починаєте пахнути кров’ю (образно). Ваш приятель Боб вклав усі свої гроші на блокування мереж якнайбільше властивостей малої вартості, але він не отримує високої віддачі від інвестицій так, як він очікував. Боб, як удача від удачі, приземляється на ваш Boardwalk і вирізаний з гри.

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

Тоді, замість того, щоб один з них виграв, процес починається все спочатку. Раптом, кінцевий набір правил стає рухомою ціллю, і гра перероджується у тип соціальних взаємодій, який би став основою кожного рейтингового реаліті-шоу з високим рейтингом після Survivor. Чому, тому що правила змінюються і немає єдиної думки щодо того, як / чому / що вони повинні представляти, і що ще важливіше, ніхто не приймає рішення. У цей момент кожен гравець в грі створює свої власні правила і настає хаос, поки двоє з гравців не надто втомилися, щоб не відставати від шараду і повільно здаватися.

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

Як це стосується програмування?

Окрім усіх очевидних проблем безпеки та синхронізації, що існують із змінними синглтонами ... Якщо у вас є один набір даних, який може читатись / маніпулювати кількома різними джерелами одночасно та існує протягом життя програми, це, мабуть, вдалий час відступити і запитати «чи я тут використовую правильний тип структури даних».

Особисто я бачив, як програміст зловживає синглом, використовуючи його як якесь скручене сховище баз даних між програмами. Попрацювавши над кодом безпосередньо, я можу засвідчити, що це було повільним (через всі замки потоку, необхідними для забезпечення його потокової безпеки) і кошмаром для роботи (через непередбачуваний / переривчастий характер помилок синхронізації), і майже неможливо перевірити в умовах "виробництва". Звичайно, система могла бути розроблена за допомогою опитування / сигналізації для подолання деяких проблем продуктивності, але це не вирішило б проблеми з тестуванням, і чому б не турбуватися, коли «справжня» база даних вже може виконати таку ж функціональність у набагато більш надійній / масштабований спосіб.

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

Сінглтон - це не про один екземпляр!

На відміну від інших відповідей, я не хочу говорити про те, що не так з Singletons, але щоб показати вам, наскільки вони потужні та приголомшливі при правильному використанні!

• Проблема : Singleton може стати проблемою в багатопотоковому середовищі.
  Рішення : Використовуйте процес одноразового завантаження для ініціалізації всіх залежностей вашого одиночного.
• Проблема : важко знущатися з одинаків.
  Рішення : Використовуйте заводський зразок методу для глузування

Ви можете нанести MyModelна карту TestMyModelклас, який успадковує його, і скрізь, коли MyModelбуде TestMyModelзроблено ін'єкцію, ви отримаєте вкладення. - Проблема : одиночні кнопки можуть спричинити витік пам'яті, оскільки вони ніколи не утилізуються.
Рішення : Ну, розпоряджайтесь ними! Реалізуйте зворотний дзвінок у вашій програмі, щоб правильно розпоряджатися одиночними кнопками, ви повинні видалити всі пов’язані з ними дані та, нарешті, видалити їх із Заводу.

Як я вже зазначив у заголовку синглтон - це не про один екземпляр.

• Singletons покращує читабельність : Ви можете подивитися на свій клас і побачити, який сингтон вводили, щоб зрозуміти, що це за залежності.
• Singletons покращує технічне обслуговування : Після того, як ви видалили залежність із класу, ви щойно видалили інженентну інженерію , вам не потрібно йти та редагувати велику посилання інших класів, які щойно перемістили вашу залежність (Це для мене смердючий код @Jim Burger )
• Singletons покращує пам’ять та продуктивність . Коли у вашій програмі відбувається щось, і для цього потрібен довгий ланцюжок зворотних викликів, ви витрачаєте пам’ять та продуктивність, використовуючи Singleton, ви скорочуєте середнього чоловіка та покращуєте продуктивність та використання пам'яті ( уникаючи зайвих локальних змінних змінних).

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

Дві найбільші викрутки, які я бачу, це: трактувати це як глобальне & не в змозі визначити закриття Singleton.

Усі говорять про Сінглтона як про глобальних, тому що вони в основному є. Однак багато (на жаль, не всі) негараздів у глобальному масштабі пов'язані не з глобальністю, а з тим, як ви цим користуєтеся. Те саме стосується і одиночних. Насправді тим більше, що "одиничний екземпляр" насправді не повинен означати "глобально доступний". Це скоріше природний побічний продукт, і враховуючи все погане, що, як ми знаємо, випливає з цього, ми не повинні поспішати з використанням глобальної доступності. Як тільки програмісти бачать Singleton, вони, здається, завжди отримують доступ до нього безпосередньо через його метод екземпляра. Натомість ви повинні перейти до нього так само, як і будь-який інший об’єкт. Більшість кодів навіть не повинні знати, що він має справу з Singleton (вільне з'єднання, правда?). Якщо лише невеликий шматочок коду отримує доступ до об'єкта, такого як він є глобальним, багато шкоди не скасовується.

Контекст Сінглтона також дуже важливий. Визначальною характеристикою Сінглтона є те, що існує "лише один", але правда полягає в тому, що він "лише один" в якомусь контексті / просторі імен. Зазвичай вони є однією з: одна на нитку, процес, IP-адресу або кластер, але також може бути одна на процесор, машину, простір імен мови / завантажувач класів / що завгодно, підмережа, Інтернет тощо.

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

Якщо ви уникнете цих помилок, Singletons все ще може бути PITA, але він готовий бачити, що багато найгірших проблем значно полегшуються. Уявіть Java Singleton, який чітко визначається як один раз для завантажувача класів (це означає, що йому потрібна політика безпеки потоку), з визначеними методами створення та знищення та життєвим циклом, який диктує, коли і як вони будуть викликатися, і чий "екземпляр" метод має захист пакунків, тому до нього, як правило, доступ здійснюється через інші, не глобальні об'єкти. Все-таки потенційне джерело неприємностей, але, безумовно, набагато менше проблем.

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

Дивіться Вікіпедію Singleton_pattern

Деякі люди, які вважають, що вона надмірно використана, її вважають анти-зразком, вводячи зайві обмеження в ситуаціях, коли фактично не потрібен єдиний екземпляр класу. [1] [2] [3] [4]

Посилання (лише відповідні посилання зі статті)

1. ^ Алекс Міллер. Шаблони, які я ненавиджу №1: Сінглтон , липень 2007 року
2. ^ Скотт Денсмор. Чому одинаки злі , травень 2004 року
3. ^ Стів Єгге. Сінглтон вважався дурним , вересень 2004 року
4. ^ JB Rainsberger, IBM. Розумно використовуйте одинаків , липень 2001 року

Справа не в тому, що самі одинаки погані, але схема дизайну GoF є. Єдиний справді аргумент, що є дійсним - це те, що модель дизайну GoF не піддається тестуванню, особливо якщо тести виконуються паралельно.

Використання одного примірника класу є дійсною конструкцією, якщо ви застосовуєте в коді такі засоби:

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

2. Переконайтесь, що Singleton захищений від потоку. Це дано.

3. Сингл має бути простим за своєю суттю і не надто складним.

4. Під час виконання вашої програми, коли одиночні кнопки потрібно передати певному об'єкту, використовуйте фабрику класів, яка будує цей об’єкт і фабрика класів передає екземпляр singleton до класу, який йому потрібен.

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

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

Я хотів би сказати 4 пункти у прийнятій відповіді, сподіваюся, хтось може пояснити, чому я помиляюся.

1. Чому приховування залежностей у вашому коді погано? Уже є десятки прихованих залежностей (виклики C виконання часу, виклики API OS, дзвінки глобальних функцій), а однотонні залежності легко знайти (пошук наприклад ()).

   "Зробити щось глобальне, щоб уникнути його передачі - кодовий запах." Чому б не пропустити щось навколо, щоб не перетворити його на запах коду?

   Якщо ви передаєте об'єкт через 10 функцій у стеку дзвінків, щоб уникнути синглтона, це так чудово?

2. Принцип єдиної відповідальності: Я думаю, це трохи розпливчасто і залежить від вашого визначення відповідальності. Відповідне питання було б, чому додавання цієї специфічної "відповідальності" до класу має значення?

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

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

Щодо одиничних тестів:

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

Вінс Хастон має такі критерії, які мені здаються розумними:

Синглтон слід розглядати лише в тому випадку, якщо всі три наступні критерії задоволені:

• Право власності на один екземпляр не може бути розумно присвоєний
• Бажана лінива ініціалізація
• Глобальний доступ не передбачений інакше

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

Синглтони погані з пуристської точки зору.

З пратичної точки зору, синглтон є компромісним часом, що розвивається, та складністю .

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

Одноразові інколи також ускладнюють тестування одиниць .

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

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

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

Синглтон є зразком і його можна використовувати або зловживати так само, як і будь-який інший інструмент.

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

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

Однотонам дуже важко переходити від них до звичайних об'єктів.

Крім того, написати занадто легко, що не є безпечним для потоків синглів.

Замість того, щоб використовувати одиночні кнопки, вам слід передати всі необхідні об'єкти утиліти від функції до функції. Це можна спростити, якщо ви загорнете їх у помічний об’єкт, як-от так:

void some_class::some_function(parameters, service_provider& srv)
{
    srv.get<error_logger>().log("Hi there!");
    this->another_function(some_other_parameters, srv);
}

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

Зараз я вважаю за краще конструювати навколо контейнера інверсії керування (IoC) і дозволяю контейнеру керувати життям. Це дає вам перевагу класам, які залежать від екземпляра, не знати про те, що існує один екземпляр. Тривалість життя сингла може бути змінена в майбутньому. Одного разу з таким прикладом, з яким я стикався нещодавно, було легке налаштування від однопотокової до багатопотокової.

FWIW, якщо це PIA, коли ви намагаєтеся перевірити його, тоді він переходить до PIA, коли ви намагаєтеся налагодити, виправити помилку або покращити його.

Недавня стаття з цього приводу Кріс Ріт у програмі Coding Without Comments .

Примітка: Кодування без коментарів більше не діє. Однак стаття, на яку посилається, була клонована іншим користувачем.

http://geekswithblogs.net/AngelEyes/archive/2013/09/08/singleton-i-love-you-but-youre-bring-me-down-re-uploaded.aspx

Синглтони НЕ погані. Це тільки погано, коли ти робиш щось глобально унікальне, що не є глобально унікальним.

Однак існують "служби прикладних програм" (подумайте про систему обміну повідомленнями, яка змушує взаємодіяти компоненти) - це CALLS для одиночного класу, "MessageQueue" - клас, який має метод "SendMessage (...)".

Потім ви можете зробити наступне з усього місця:

MessageQueue.Current.SendMessage (новий MailArrivedMessage (...));

І, звичайно, робіть:

MessageQueue.Current.RegisterReceiver (це);

в класах, які реалізують IMessageReceiver.

Занадто багато людей ставлять предмети, які не є безпечними для ниток у однотонному малюнку. Я бачив приклади DataContext ( LINQ to SQL ), виконані в однотонному шаблоні, незважаючи на те, що DataContext не є безпечним для потоків і є об'єктом одиничної роботи.

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

У більшості випадків "однотонність" - це деталізація реалізації для якогось класу, а не характеристика його інтерфейсу. Інверсія контейнера управління може приховувати цю характеристику від користувачів класу; вам просто потрібно позначити свій клас як одиночний (наприклад, з @Singletonанотацією на Java), і все; IoCC зробить все інше. Вам не потрібно надавати глобальний доступ до вашої одиночної інстанції, оскільки цим доступом вже керує IoCC. Таким чином, з IoC Singletons немає нічого поганого.

Голонг-синглтони, протилежні IoC Singletons, повинні викрити "однотонність" в інтерфейсі методом getInstance (), і вони страждають від усього сказаного вище.

Синглтони не є злими, якщо ви використовуєте їх правильно і мінімально . Існує безліч інших хороших моделей дизайну, які замінюють потреби сингтона в якийсь момент (& також дає найкращі результати). Але деякі програмісти не знають про ті добрі зразки, і він використовує сингл у всіх випадках, що робить для них одиночне зло.

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

Часто програмне забезпечення стає складнішим, є сенс мати кілька незалежних екземплярів класу Singleton з різним станом. Здійснення коду для простого захоплення сингтона в таких випадках неправильно. Singleton.getInstance()Для невеликих простих систем використання може бути нормальним, але воно не працює / масштабується, коли може знадобитися інший примірник того ж класу.

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

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

Оскільки вони в основному є об'єктно-орієнтованими глобальними змінними, зазвичай ви можете проектувати свої класи таким чином, щоб вони вам не потрібні.