Wednesday, January 8, 2014

Обработка ошибок в C#

Статья посвящена нестандартным способам обработки ошибок, а также превентировании некоторых видов ошибок при программировании на языке C#. Первой ошибкой рассмотрим пример, приведённый в одной из прошлых статей "Тонкости при использовании событий и делегатов" при генерации ошибки в цепочке событий. Если Вы не знакомы с принципом работы событий и делегатов, для понимания продемонстрированного решения рекомендую ознакомиться со статьями "Использование делегатов в C#" и "Использование событий с C#". Рассмотрим пример подписки нескольких обработчиков событий, один из которых генерирует исключение.
class Program
{
    static void Main(string[] args)
    {
        var p = new Program();
        p.CreatePublisher();
        Console.ReadLine();
    }
    public void CreatePublisher()
    {
        try
        {
            var publisher = new Publisher();
            publisher.OnPublish += (sender, args) => Console.WriteLine("Publisher 1");
            publisher.OnPublish += (sender, args) => Console.WriteLine("Publisher 2");
            publisher.OnPublish += (sender, args) =>
                {
                    throw new Exception("Throw publisher exception");
                };
            publisher.OnPublish += (sender, args) => Console.WriteLine("Publisher 3");
            publisher.Raise();
        }
        catch (Exception exception)
        {
            Console.WriteLine(exception);
        }
    }
}
public class Publisher
{
    public event EventHandler OnPublish = delegate { };
    public void Raise()
    {
        OnPublish(this, new EventArgs());
    }
}
Выше приведен пример кода, в котором в одном из цепочки событий генерируется exception. Возникает вопрос: будет ли продолжено выполнение кода после того, как мы перехватим это исключение? Если Вы предполагали, что будет вызвано три подписчика событий, один из которых перехвачен и вызывает исключение, то у меня для вас плохая новость. Если вызванный метод выбрасывает исключение, выполнение этого метода прекращается, исключение передается обратно коду, вызвавшему делегат, – и оставшиеся в списке вызовов методы не вызываются. Перехват исключения в вызывающем коде не меняет этого поведения. Чтобы как-то изменить это поведение, есть несколько вариантов: поискать готовое решение, которое может основываться на замене событий, например, использование паттерна "Publisher->Subscriber", либо использование классического паттерна "Наблюдатель" (Observer). 
К счастью, решение без использования паттернов, позволяющее решить данную проблему (правда, не столь элегантное), существует. Решение данной проблемы основано на использовании метода Delegate.GetInvocationList, который возвращает массив делегатов, представляющих список вызовов текущего делегата. Поскольку событие (event) – это обертка над MulticastDelegate, благодаря ключевому слову event, у события имеются некоторые дополнительные возможности (о них можно ознакомиться в статьях, названия которых приведены выше). Рассмотрим, как будет выглядеть наше решение.
class Program
{
    static void Main(string[] args)
    {
        var p = new Program();
        p.CreatePublisher();
        Console.ReadLine();
    }
    public void CreatePublisher()
    {
        try
        {
            var publisher = new Publisher();
            publisher.OnPublish += (sender, args) => Console.WriteLine("Publisher 1");
            publisher.OnPublish += (sender, args) => Console.WriteLine("Publisher 2");
            publisher.OnPublish += (sender, args) =>
                {
                    throw new Exception("Throw publisher exception");
                };
            publisher.OnPublish += (sender, args) => Console.WriteLine("Publisher 3");
            publisher.Raise();
        }
        catch (Exception exception)
        {
            Console.WriteLine(exception);
        }
    }
}
public class Publisher
{
    public event EventHandler OnPublish = delegate { };
    public void Raise()
    {
        var exceptions = new List<Exception>();
        foreach (var handler in OnPublish.GetInvocationList())
        {
            try
            {
                handler.DynamicInvoke(this, new EventArgs());
            }
            catch (Exception ex)
            {
                exceptions.Add(ex);
            }
        }
        if (exceptions.Any())
        {
            throw new AggregateException(exceptions);
        }
    }
}
Это способ обработки всех событий без прерывания цепочки событий.

Try/finally block
Наверное, все знают об использовании блока try/catch для перехвата ошибок при выполнении программы. Еще одной важной особенностью обработки исключений является возможность указать, что определенный код всегда должен быть запущен в случае исключения. Это может быть сделано с помощью блока finally вместе с блоками try или try/catch. Можем ли мы быть уверены в том, что блок finally выполнится всегда? Рассмотрим пример использования данного блока.
private static void Main(string[] args)
{
    try
    {
        var zero = 0;
        var a = 2/zero;
    }
    catch (DivideByZeroException exception)
    {
        Console.WriteLine(exception);
    }
    finally
    {
        Console.WriteLine("Finally block");
    }
    Console.ReadLine();
}
Это слишком надуманный пример. Обычно блок finally используют, чтобы освободить ресурсы, используемые программой, сделать отписку от событий и т.д. Рассмотрим пример, который Вы, вероятно, встречали не раз или видели похожий способ очистки ресурсов.
private static void Main(string[] args)
{
    FileStream fs = null;
    try
    {
        fs = new FileStream(Path.Combine(Directory.GetCurrentDirectory(), "test.txt"), FileMode.OpenOrCreate);
        fs.Write(new byte[] {1, 2, 3, 4}, 0, 4);
    }
    catch (IOException exception)
    {
        Console.WriteLine(exception);
    }
    finally
    {
        if(fs != null)
            fs.Close();
    }
    Console.ReadLine();
}
Вы могли видеть подобный код для выгрузки отдельного домена, отписки от событий, обнуления ссылок и т.д. Если Ваш класс реализует интерфейс IDisposable, то вызов метода try/finally можно переписать, заменив конструкцией using. Рассмотрим, как изменится код, приведенный выше.
private static void Main(string[] args)
{
    try
    {
        var file = Path.Combine(Directory.GetCurrentDirectory(), "test.txt");
                                           
        using (var fs = new FileStream(file, FileMode.OpenOrCreate))
        {
            fs.Write(new byte[] {1, 2, 3, 4}, 0, 4);
        }
    }
    catch (IOException exception)
    {
        Console.WriteLine(exception);
    }
    Console.ReadLine();
}
В оригинале конструкция приобрела такой вид:
try
    try
    finally
catch
Как видим, блок finally позволяет почистить мусор и освободить ресурсы.  Но всё ещё остается открытым вопрос, всегда ли будет гарантирован вызов блока finally. К сожалению, вызов блока finally не всегда гарантирован. Одной из таких ситуаций является та, в которой в блоке try происходит вызов бесконечного цикла. Иногда нужно иметь возможность корректно завершить приложение самому, записав при этом информацию в event log. В .NET 4.0 появился метод Environment.FailFast, который позволяет завершить процесс сразу после записи сообщения в журнал событий Windows, после чего включает сообщение в отчет об ошибках, отправляемый в корпорацию Майкрософт. Этот метод завершает процесс, минуя активные блоки try/finally и методы-финализаторы. Метод FailFast записывает строку message в журнале событий Windows-приложения, создает дамп приложения и затем завершает текущий процесс. Строка message также включена в отчет об ошибках для корпорации Майкрософт. Метод FailFast используется для завершения работы приложения вместо метода Exit, если повреждение состояния приложения не подлежит восстановлению, а выполнение блоков try/finally и методов завершения для этого приложения приведет повреждению ресурсов программы.
Примечание: довольно интересный метод для записи информации в event log добавила компания Microsoft в .NET 4.0. Сама компания рекомендует использовать этот метод для отладки приложения. К сожалению, я так и не смог представить, где может понадобиться такое чудо и чем эта новая фишка лучше старого доброго метода Exit, в который можно передать код выхода и при необходимости его обработать.
ApplicationException vs Exception
Если в своих приложениях Вы используете для ошибок класс ApplicationException, задумайтесь о том, чтобы от него отказаться. Использование создания  такого типа ошибок в приложении бессмысленно и не несет никакой смысловой нагрузки. Вот что говорится об этом в Framework Design Guidelines:
Do not throw or derive from System.ApplicationException.
JEFFREY RICHTER: System.ApplicationException is a class that should not be part of the .NET Framework. The original idea was that classes derived from SystemException would indicate exceptions thrown from the CLR (or system) itself, whereas non-CLR exceptions would be derived from ApplicationException. However, a lot of exception classes didn’t follow this pattern. For example, TargetInvocationException (which is thrown by the CLR) is derived from ApplicationException. So, the ApplicationException class lost all meaning. The reason to derive from this base class is to allow some code higher up the call stack to catch the base class. It was no longer possible to catch all application exceptions.
Джефри Рихтер рекомендует исключить этот класс с .NET, так как он не выполняет своей основной роли: разделить ошибки, которые бросаются исполняющей средой CLR, от ошибок несистемных (non-clr). Ошибки, которые генерируются средой CLR, должны наследоваться от SystemException; все остальные – от ApplicationException. Но поскольку в самом .NET Framework такого принципа не поддерживается, например, класс TargetInvocationException, то попытка словить ApplicationException потеряла всякий смысл. Вот что об этом пишет компания Microsoft:
"При разработке приложения, которому требуется создать свои собственные исключения, необходимо создать пользовательские исключения из класса Exception. Изначально предполагалось, что пользовательские исключения должны наследовать от класса ApplicationException, однако на практике это не имеет особого значения. Для получения дополнительной информации см. Лучшие методики обработки исключений".

NullReferenceException vs ArgumentNullException
Избегайте использования в коде явного вызова NullReferenceException. Если аргумент пустой и контракт метода запрещает пустые аргументы, бросайте исключение ArgumentNullException. Так Вы сможете отделить те ошибки, которые бросаете от системных ошибок. Например, если в какой-то метод Вы передали null, сами того не подозревая, и пытались его использовать. Понять, кто бросил такой тип ошибки – Вы или система – порой бывает очень трудно. Но при использовании ArgumentNullException такой проблемы не возникнет.
Примечание: этот пункт был добавлен по той причине, что автор данной статьи сам совершал такую ошибку. Очень сложно потом понять такую ошибку: система ее бросила или ты сам "наследил" в коде. Если можно в этом случае упростить себе жизнь, то почему бы этим не воспользоваться.

Обработка ошибок при использовании тасков
Если Вы знакомы с классом Task и моделью TPL (Task Parallel Library) при проектировании и разработке приложений, то Вы, наверное, уже сталкивались с обработкой ошибок в ней. Если Вам не приходилось обрабатывать возникшие ошибки при некорректном завершении задания или если оно не выполнилось по какой-то причине, то Вам очень повезло. Но для готовности к разным неожиданностям рекомендую посмотреть, как обрабатывать такие ошибки.
Если таск бросил ошибку, то его выполнение прекращено. Ошибка таска сохраняется как часть AggregateException (AE) и хранится в объекте таска Exception (E) проперти. AE пробрасывается на функции.Wait, .Result или .WaitAll. Рассмотрим пример обработки ошибок.
internal class Program
{
    private static void Main(string[] args)
    {
        try
        {
            var task1 = Task.Factory.StartNew<int>(Method1);
            var result = task1.Result;
        }
        catch (AggregateException ae)
        {
            Console.WriteLine(ae.InnerException.Message);
        }
        Console.ReadLine();
    }

    private static int Method1()
    {
        throw new NotImplementedException();
    }
}
Чтобы отобразить все ошибки, которые привели к выбросу ошибки, нужно вызвать метод Flatten().

try
{
    var task1 = Task.Factory.StartNew<int>(Method1);
    var result = task1.Result;
}
catch (AggregateException ae)
{
    var exceptions = ae.Flatten();
    foreach (var exception in exceptions.InnerExceptions)
    {
        Console.WriteLine(exception.Message);
    }
}
Правила работы с ошибками при использовании тасков (Exception handling design):
  • при использовании методов .Wait, .Result или .WaitAll нужно обрамлять в блок try/catch;
  • чтобы отловить необработанные критические ошибки при вызове тасков, выполнить подписку на TaskScheduler.UnobservedTaskException.
Но при работе с тасками существует еще один подход к обработке ошибок. Если нужно выполнить какую-то логику именно для тасков, которые прокинули ошибки, можно воспользоваться другим подходом на основе метода .ContinueWith. Рассмотрим, как можно использовать такой подход.
var task1 = Task.Factory.StartNew<int>(Method1);
var failedTask = task1.ContinueWith(task =>
    {
        Console.WriteLine("Call failed task");
        //TODO Write some logic
    }, TaskContinuationOptions.OnlyOnFaulted);
var successTask = task1.ContinueWith(task =>
    {
        var result = task.Result;
        Console.WriteLine(result);
    }, TaskContinuationOptions.NotOnFaulted);
В данном подходе наблюдается явное разделение тех функций, выполненных успешно, от тех, которые бросили ошибку. Но есть один тип ошибок, который, по сути, ошибкой не является. Это exception OperationCanceledException. Этот тип ошибки вызывается в том случае, если пользователь отменил выполнение таска. Более детально с этим можно ознакомиться в статье "Отмена задач (Taskcancellation)", в которой речь идет об использовании класса Task и об отмене операций пользователем. Рассмотрим небольшой пример с обработкой OperationCanceledException.
var tokenSource = new CancellationTokenSource();
CancellationToken ct = tokenSource.Token;
var task = Task.Factory.StartNew(() =>
{
    //TODO write some code in loop
    if (ct.IsCancellationRequested)
    {
        ct.ThrowIfCancellationRequested();
    }

}, tokenSource.Token); // Pass same token to StartNew.
       
//Cancel method
tokenSource.Cancel();

// Just continue on this thread, or Wait/WaitAll with try-catch:
try
{
    task.Wait();
}
catch (AggregateException ae)
{
    var exceptions = ae.Flatten();
    foreach (var exception in exceptions.InnerExceptions)
    {
        if (exception is OperationCanceledException)
        {
            //ignore cancel
        }
        else
            Console.WriteLine(exception.Message);
    }
}
CancellationTokenSource создаёт маркёры отмены (свойство Token) и обрабатывает запросы на отмену операции.
CancellationToken - маркёр отмены, позволяющий несколькими способами отслеживать запросы на отмену операции: опросом свойства IsCancellationRequested, регистрацией callback-функции (через перегруженный метод Register), ожиданием на объекте синхронизации (свойство WaitHandle).

OperationCanceledException - исключение, выброс которого по соглашению означает, что запрос на отмену операции был обработан и операция должна считаться отменённой. Предпочтительный способ генерации исключения - вызов метода ThrowIfCancellationRequested.

Итоги
В данной статье рассмотрена обработка ошибок при использовании подписки на события; обработка ошибок с использованием блоков try/catch/finally; также упомянуто best practice при использовании и обработки ошибок и описаны способы обработки ошибок в модели TPL.

Friday, January 3, 2014

Расширяем возможности .NET 2.0

Здравствуйте, уважаемые читали моего блога. В первой за 2014 год статье речь пойдет о возможностях языка C# для написания программ под .NET Framework 2.0. Если Вам не приходится писать код хоть изредка для .NET Framework 2.0, для Вас этот материал, возможно, будет интересным для ознакомления. У современного C# программиста, который программирует на .NET Framework 4.0/4.5, начинается нервная дрожь, когда ему приходится что-то писать под второй фреймворк, и такую реакцию разработчиков можно понять. Вам нужно отказаться от extension methods, лямбда-выражений, linq и других возможностей, которые появились в C# 3.0. Для меня ситуация в этом плане была такой же. Поэтому я предвзято отношусь ко второму фреймворку после использования более поздних версий. Было бы здорово в .NET Framework 2.0 иметь возможность использовать хотя бы часть возможностей C# 3.0 с поддержкой лямбда-выражений и других возможностей, которые появились в нем. Об этих возможностях можно посмотреть в статье "Тенденции разработки прикладных программ на языке C#". Пожалуй, пришло время Вас обрадовать. Вы можете использовать часть возможностей, доступных с C# 3.0, во втором фреймворке. Для этого придётся использовать небольшой "хак", который позволит использовать возможности C# 3.0, вместо C# 2.0. И самое интересное заключается в том, что Ваше приложение будет работать под вторым фреймворком без проблем. Extension methods и query expression требуют специальный атрибут, который определен в .NET 3.5. Но это не составляет проблему для того, чтобы переопределить этот атрибут самому. Вот как это выглядит:
namespace System.Runtime.CompilerServices
{
    [AttributeUsageAttribute(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]
    public class ExtensionAttribute : Attribute
    {
    }
}
Теперь у Вас доступна возможность использовать расширяемые методы (extension methods), потому что доступно использование ключевого слова this для данных методов. Пример использования:
class Program
{
    static void Main(string[] args)
    {
        string test = null;
        Console.WriteLine(test.CheckNullString());
        Console.ReadLine();
    }
}

public static class StringExtension
{
    public static bool CheckNullString(this string value)
    {
        return value == null;
    }
}
Этот прогресс не может не радовать. Правда, этого маловато для того, чтобы использовать возможности LINQ. Мы можем открыть MSDN и перенести с последней версии фреймворка реализацию делегатов Action и Func к себе.
public delegate void Action();
public delegate void Action<T1, T2>(T1 arg1, T2 arg2);
public delegate void Action<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3);
public delegate void Action<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
public delegate TResult Func<TResult>();
public delegate TResult Func<T, TResult>(T arg);
public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);
public delegate TResult Func<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3);
public delegate TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

По желанию можно также перенести делегат Predicate. Дальше если Вы хотите использовать возможности методов LINQ, нужно их реализовать самим. К счастью, автор известной книги Joseph Albahari, C# 5.0 in a Nutshell написал библиотеку LINQBridge, которая позволяет использовать часть возможностей из LINQ to Objects. Для этого нам нужно загрузить либо библиотеку по приведенной ссылке, либо исходный код, который позволяет это все использовать. Посмотрите, как это будет выглядеть.
private static void Main(string[] args)
{
    var mass = new [] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    var result = mass.Where(number => number%2 == 0).Select(number => number + "$");
    foreach (var number in result)
    {
        Console.WriteLine(number);
    }

    var query =
        from n in mass
        where n > 5
        orderby n
        select n * 10;

    foreach (var number in query)
    {
        Console.WriteLine(number);
    }
    Console.ReadLine();
}
Нам доступна как точечная нотация, так и нотация на основе выражений.
К сожалению, нам остались недоступны деревья выражений. Поскольку деревья выражений (expression trees) являются частью .NET 3.5, и эту часть нельзя просто так перенести как  LINQBridge, который, по сути, заново реализует LINQ to Objects.  

Итоги
Благодаря таким гуру, как Джон Скит и Джозеф Албахари, я узнал о возможности использования в .NET 2.0 тех возможностей языка C#, которые успел полюбить, начиная с C# 3.0. Для тех, кто знаком с работой Джона Скита через прочтение его книг или отслеживание его "творчества" на stackoverflow, эта статья не расскажет ничего нового. Если Вы не знакомы с книгами данного автора, рекомендую посмотреть одну из его книг "C# in Depth", которой, уверен, будете приятно удивлены. Надеюсь, что Вы ее прочтёте и она, как и для меня, также станет одной из любимых книг по языку C#.

Источники