Чи є гарною практикою мати реєстратора як синглтона?

Я мав звичку передавати реєстратор конструктору, наприклад:

public class OrderService : IOrderService {
     public OrderService(ILogger logger) {
     }
}

Але це досить дратує, тому я деякий час використовував це властивість:

private ILogger logger = NullLogger.Instance;
public ILogger Logger
{
    get { return logger; }
    set { logger = value; }
}

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

    Infrastructure.Logger.Info("blabla");

ОНОВЛЕННЯ: Як правильно зауважив Мерлін, я повинен зазначити, що в першому та другому прикладах я використовую DI.

Це теж дратує - це не СУХО

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

Тож давайте подивимося, що ми можемо з цим зробити.

Сінглтон

Одинокі страшні <flame-suit-on>.

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

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

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

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

Фрагменти коду Visual Studio

Ви можете використовувати фрагменти коду Visual Studio, щоб пришвидшити введення цього повторюваного коду. Ви зможете набрати щось на зразок loggertab, і код чарівно з’явиться для вас.

Використання AOP для СУШЕННЯ

Ви можете усунути трохи цього коду введення властивостей, використовуючи структуру Aspect Oriented Programming (AOP), таку як PostSharp, для автоматичного генерування частини з нього.

Коли ви закінчите, це може виглядати приблизно так:

[InjectedLogger]
public ILogger Logger { get; set; }

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

[Trace]
public class MyClass
{
    // ...
}

// or

#if DEBUG
[assembly: Trace( AttributeTargetTypes = "MyNamespace.*",
    AttributeTargetTypeAttributes = MulticastAttributes.Public,
    AttributeTargetMemberAttributes = MulticastAttributes.Public )]
#endif

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

Гарне питання. Я вважаю, що в більшості проектів реєстратор є одностороннім.

Деякі ідеї мені просто спадають на думку:

• Використовуйте ServiceLocator (або інший контейнер інжекції залежностей, якщо ви вже використовуєте такий), який дозволяє вам ділитися реєстратором між службами / класами, таким чином, ви можете створити екземпляр реєстратора або навіть декількох різних реєстраторів та надавати спільний доступ через ServiceLocator, що, очевидно, було б єдиним , якась інверсія контролю . Цей підхід надає вам велику гнучкість у процесі створення та створення ініціалізації реєстратора.
• Якщо вам потрібно Logger майже всюди - реалізувати методи розширення для Objectтипу , так що кожен клас буде мати можливість викликати методи лісоруба як LogInfo(), LogDebug(),LogError()

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

Сам реєстр може бути статичним класом для надання простого синтаксису доступу до журналу:

Registry.Logger.Info("blabla");

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

Я використовую одиночний шаблон у поєднанні з шаблоном проксі для фабрики реєстратора:

public class LogFactory
{
    private static LogFactory _instance;

    public static void Assign(LogFactory instance)
    {
        _instance = instance;
    }

    public static LogFactory Instance
    {
        get { _instance ?? (_instance = new LogFactory()); }
    }

    public virtual ILogger GetLogger<T>()
    {
        return new SystemDebugLogger();
    }
}

Це дозволяє мені створити FilteringLogFactoryабо просто a, SimpleFileLogFactoryне змінюючи жодного коду (і, відповідно, дотримуючись принципу Open / Closed).

Зразок розширення

public class FilteredLogFactory : LogFactory
{
    public override ILogger GetLogger<T>()
    {
        if (typeof(ITextParser).IsAssignableFrom(typeof(T)))
            return new FilteredLogger(typeof(T));

        return new FileLogger(@"C:\Logs\MyApp.log");
    }
}

І використовувати нову фабрику

// and to use the new log factory (somewhere early in the application):
LogFactory.Assign(new FilteredLogFactory());

У вашому класі, який повинен реєструватися:

public class MyUserService : IUserService
{
    ILogger _logger = LogFactory.Instance.GetLogger<MyUserService>();

    public void SomeMethod()
    {
        _logger.Debug("Welcome world!");
    }
}

У .NET є книга Ін’єкція залежності. Виходячи з того, що вам потрібно, вам слід використовувати перехоплення.

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

Ось одні з причин використання цієї діаграми:

1. У вас є залежність чи вона вам потрібна? - Потрібно це
2. Це наскрізна стурбованість? - Так
3. Вам потрібна відповідь із нього? - Ні

Використовуйте перехоплення

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

Logger::initialize ("filename.log", Logger::LEVEL_ERROR); // only need to be called once in your application

Logger::log ("my error message", Logger::LEVEL_ERROR); // to be used in every method where needed

Якщо ви хочете переглянути гарне рішення для ведення журналу, я пропоную вам поглянути на механізм додатків Google з python, де ведення журналу є таким простим, як import loggingі тоді ви можетеlogging.debug("my message") абоlogging.info("my message") яке насправді робить його настільки простим, як слід.

У Java не було хорошого рішення для ведення журналу, тобто слід уникати log4j, оскільки він практично змушує вас використовувати однотонні файли, що, як відповіли тут, є "жахливим", і я мав жахливий досвід, намагаючись зробити вихід журналу одним і тим же оператором ведення журналу лише один раз коли я підозрюю, що причиною подвійного ведення журналу було те, що я маю один синглтон об'єкта реєстрації в двох завантажувачах класів в одній віртуальній машині (!)

Прошу вибачення за те, що він не настільки специфічний для C #, але з того, що я бачив, рішення з C # виглядають схожими на Java, де у нас був log4j, і нам також слід зробити його однотоннім.

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

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