Упрощённая валидация аргументов в .Net

Для валидации аргументов методов в .Net присутствует набор исключений, которые бросаются при нарушении контракта метода:

• ArgumentException – обобщённое исключение предназначенное для наложения произвольных ограничений на аргументы метода,
• ArgumentNullException – исключение, указывающее что значение аргумента оказалось равным null,
• ArgumentOutOfRangeException – исключение, указывающее что значение аргумента выходит за пределы интервала разрешённых значений.

Одним из параметров конструктора этого типа исключений является имя аргумента, для которого проводится валидация:

void Foo(string fooArg)

{

    if (fooArg == null)

        throw new ArgumentNullException("fooArg");

 

    Console.WriteLine("Foo({0})", fooArg);

}

 

void Bar(int barArg)

{

    if (barArg < 0 || barArg > 10)

        throw new ArgumentOutOfRangeException("barArg");

 

    Console.WriteLine("Bar({0})", barArg);

}

Собственно, это всё довольно известно и часто используется.

Однако в таком коде присутствуют и свои, довольно очевидные, проблемы.

• Отсутствует декларативность (явно используемые проверки с помощью if),
• Использование строковых констант в качестве имён аргументов (мешает использованию автоматического рефакторинга Rename).

Попробуем избавится от этих проблем с помощью типизированного варианта получения имени аргумента. Для этого воспользуемся возможностями Linq Expressions. У меня получился следующий вариант:

Program.cs

using System;

 

namespace Home.Andir.Examples

{

    class Program

    {

        static void Main(string[] args)

        {

            var p = new Program();

 

            p.Foo(null);

            p.Bar(-1);

        }

 

        void Foo(string fooArg)

        {

            Argument.NotNull(() => fooArg);

 

            Console.WriteLine("Foo({0})", fooArg);

        }

 

        void Bar(int barArg)

        {

            Argument.InRange(() => barArg,

                new Range<int> { Begin = 0, End = 10 });

 

            Console.WriteLine("Bar({0})", barArg);

        }

    }

}

В коде явно прибавилось декларативности и исчезли проблемы со строковым именем проверяемого аргумента. А итоговая функциональность кода совсем не изменилась. Отлично.

Посмотрим на реализацию класса Argument.

Argument.cs

using System;

using System.Linq.Expressions;

 

namespace Home.Andir.Examples

{

    public static class Argument

    {

        private static string GetArgumentName<T>(Expression<Func<T>> argumentExpression)

        {

            var memberExpression = argumentExpression.Body as MemberExpression;

            if (memberExpression == null)

                throw new ArgumentException(

                    "Only MemberExpression allowed for expression body.",

                    "argumentExpression");

 

            return memberExpression.Member.Name;

        }

 

        private static T GetArgumentValue<T>(Expression<Func<T>> argumentExpression)

        {

            var compiledExpr = argumentExpression.Compile();

 

            return compiledExpr.Invoke();

        }

 

        public static void NotNull<T>(

            Expression<Func<T>> argumentExpression)

        {

            var argName = GetArgumentName(argumentExpression);

            var argValue = GetArgumentValue(argumentExpression);

 

            if (argValue == null)

                throw new ArgumentNullException(argName);

        }

 

        public static void InRange<T>(

            Expression<Func<T>> argumentExpression,

            Range<T> range)

            where T : IComparable<T>

        {

            var argName = GetArgumentName(argumentExpression);

            var argValue = GetArgumentValue(argumentExpression);

 

            if (argValue.CompareTo(range.Begin) < 0

                || argValue.CompareTo(range.End) > 0)

                throw new ArgumentOutOfRangeException(argName);

        }

    }

}

И небольшой класс для задания интервала Range.

Range.cs

using System;

 

namespace Home.Andir.Examples

{

    public class Range<T> where T : IComparable<T>

    {

        public T Begin { get; set; }

        public T End { get; set; }

    }

}

Реализация, конечно, получилась чисто игрушечная, но её вполне достаточно чтобы показать основную идею.

Такой вариант, конечно, не является идеальным, но позволяет используя только средства языка C# 3.0 упростить и улучшить механизм валидации аргументов.

А более красивый и практически идеальный вариант можно получить с помощью AOP. Для моего примера можно предположить такую реализацию:

void Foo([NotNull] string fooArg)

{

    Console.WriteLine("Foo({0})", fooArg);

}

 

void Bar([InRange(0, 10)] int barArg)

{

    Console.WriteLine("Bar({0})", barArg);

}

Здесь условия на значения аргументов накладываются с помощью атрибутов. Максимально декларативно и без потери читабельности.

На сегодняшний день подобный вариант можно организовать, например, с помощью PostSharp. В частности, стоит обратить внимание на проект ValidationAspects, который также использует PostSharp для реализации аспектов.

Похожий вариант валидации аргументов возможно будет организовывать и в будущей версии языка C# 4.0 (прочитать об этом можно здесь).