C#的扩充方法分析

   
在应用面向对象的言语实行项目支出的长河中,较多的会采纳到“继承”的特色,不过不用全体的气象都适合利用“继承”天性,在设计形式的一部分中坚规则中也有较多的关联。

   
继承的关于性格的行使所带来的难点:对象的持续关系实在编写翻译时就定义好了,所以不恐怕在运转时改变从父类继承的兑现。子类的贯彻与它父类有越发紧凑的依靠关系,以至于父类完成中的任何变化必然会导致子类发生变化。当你需求复用子类时,要是延续下来的兑现不相符化解新的题材,则父类必须重写它或被其余更符合的类替换,这种借助关系界定了灵活性并最后限制了复用性。替代继承性子的方法,较多的会选拔 合成/聚合复用原则,“合成/聚合复用原则”:尽量接纳合成/聚合,尽量不要选拔类继承。

   
借使在新类型的目的应当带领有关额外行为的细节,在运用持续个性时,有时或许不太符合,例如:处理指类型,密封类,只怕接口时。在面对那一个必要时,大家有时候会写一些静态类富含部分静态方法。可是过多的静态方法会导致额外的不要求的支出。

一.增添方法概述:

   
面对以上的关于“继承”的难点,以及在直面项指标某个需要时,大家须要解决那些题指标点子便是“扩充方法”。在C#3.0中引入了“扩展方法”,既有静态方法的独到之处,又使调用它们的代码的可读性获得了增长。在应用扩张方法时,能够像调用实例方法那样调用静态方法。

   1.扩展方法的骨干原则:

      (1).C#只帮助扩展方法,不补助扩张属性、扩充事件、扩大操作符等。

     
(2).扩大方法(第一个参数前面是this的方法)必须在非泛型的静态类中宣示,扩张方法必须有三个参数,而且唯有首先个参数使用this标记。

     
(3).C#编写翻译器查找静态类中的扩张方法时,供给这么些静态类本人必须有所文件功能域。

     
(4).C#编译供给“导入”扩张方法。(静态方法可以擅自命名,C#编写翻译器在搜寻办法时,须要花费时间开始展览检索,须求检查文件功效域中的全数的静态类,并扫描它们的有所静态方法来寻觅多个合营)

      (5).四个静态类能够定义相同的扩张方法。

      (6).用一个恢弘方法扩大2个门类时,同时也壮大了派生类型。 

   2.扩大方法证明:

     (1).必须在叁个非嵌套的、非泛型的静态类中(所以必须是3个静态方法)

     (2).至少有一个参数。

     (3).第三个参数必须附加this关键字做前缀。

     (4).第二个参数无法有任何任何修饰符(如ref或out)。

     (5).第2个参数的种类不能是指针类型。

 以上的八个分类表明中,对扩张方法的基本特色和注明方式做了2个简练的介绍,有关扩张方法的运用格局,会在末端的代码样例中举办展示,再度就不再多做验证。

二.恢弘方法原理分析:

   
“扩大方法”是C#独有的一种艺术,在扩充方法中会使用ExtensionAttribute这些attribute。

   
C#倘使接纳this关键字标记了有些静态方法的率先个参数,编写翻译器就会在内部向该方法运用二个定制的attribute,那么些attribute会在最终身成的文本的元数据中持久性的贮存下来,此属性在System.Core
dll程序集中。

   
任黄瀚态类只要包涵了最少一个恢宏方法,它的元数据中也会选择这几个attribute,任何二个主次集带有了足足一个契合上述特点的静态类,它的元数据也会接纳这么些attribute。如若代码用了二个不存在的实例方法,编写翻译器会快捷的扫描引用的兼具程序集,判断它们怎样包括了扩大方法,然后,在这几个程序集中,能够扫描包涵了扩张方法的静态类。

   
假如同八个命名空间中的多个类富含扩充项目相同的法子,就从未有过章程成功只用当中多少个类中的增添方法。为了通过品种的简短名称(没有命名空间前缀)来使用项目,能够导入该项目全体在的命名空间,但如此做的时候,你从未艺术堵住那些命名空间中的扩充方法也被导入进来。

三..NET3.5的恢宏方法Enumerable和Queryable:

 
 在框架中,扩张方法最大的用处正是为LINQ服务,框架提供了帮忙的恢弘方法,位于System.Linq命名空间下的Enumerable和Queryable类。Enumerable超越5/10增添是IEnumerable<T>,Queryable大部分扩充是IQueryable<T>。

   1.Enumerable类中的常用方法:

      (1).Range():贰个参数是开场数,八个是要转变的结果数。

public static IEnumerable<int> Range(int start, int count) { 
            long max = ((long)start) + count - 1;
            if (count < 0 || max > Int32.MaxValue) throw Error.ArgumentOutOfRange("count"); 
            return RangeIterator(start, count);
        }

        static IEnumerable<int> RangeIterator(int start, int count) { 
            for (int i = 0; i < count; i++) yield return start + i;
        } 

   
 (2).Where():对聚集举办过滤的二个办法,接受1个谓词,并将其利用于原来集合中的各种元素。

 public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
            if (source == null) throw Error.ArgumentNull("source"); 
            if (predicate == null) throw Error.ArgumentNull("predicate"); 
            if (source is Iterator<TSource>) return ((Iterator<TSource>)source).Where(predicate);
            if (source is TSource[]) return new WhereArrayIterator<TSource>((TSource[])source, predicate); 
            if (source is List<TSource>) return new WhereListIterator<TSource>((List<TSource>)source, predicate);
            return new WhereEnumerableIterator<TSource>(source, predicate);
        }

 public WhereEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate) { 
                this.source = source;
                this.predicate = predicate; 
            }

   
以上分别介绍了Range()和Where()七个法子,该类中还要害涵盖select()、orderby()等等情势。

  2.Queryable类中的常用方法:

    (1).IQueryable接口:

 /// <summary>
  /// 提供对未指定数据类型的特定数据源的查询进行计算的功能。
  /// </summary>
  /// <filterpriority>2</filterpriority>
  public interface IQueryable : IEnumerable
  {
    /// <summary>
    /// 获取与 <see cref="T:System.Linq.IQueryable"/> 的实例关联的表达式目录树。
    /// </summary>
    /// 
    /// <returns>
    /// 与 <see cref="T:System.Linq.IQueryable"/> 的此实例关联的 <see cref="T:System.Linq.Expressions.Expression"/>。
    /// </returns>
    Expression Expression { get; }
    /// <summary>
    /// 获取在执行与 <see cref="T:System.Linq.IQueryable"/> 的此实例关联的表达式目录树时返回的元素的类型。
    /// </summary>
    /// 
    /// <returns>
    /// 一个 <see cref="T:System.Type"/>,表示在执行与之关联的表达式目录树时返回的元素的类型。
    /// </returns>
    Type ElementType { get; }
    /// <summary>
    /// 获取与此数据源关联的查询提供程序。
    /// </summary>
    /// 
    /// <returns>
    /// 与此数据源关联的 <see cref="T:System.Linq.IQueryProvider"/>。
    /// </returns>
    IQueryProvider Provider { get; }
  }

   (2).Where():

  public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate) { 
            if (source == null)
                throw Error.ArgumentNull("source"); 
            if (predicate == null)
                throw Error.ArgumentNull("predicate");
            return source.Provider.CreateQuery<TSource>(
                Expression.Call( 
                    null,
                    ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)), 
                    new Expression[] { source.Expression, Expression.Quote(predicate) } 
                    ));
        } 

   (3).Select():

 public static IQueryable<TResult> Select<TSource,TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector) {
            if (source == null)
                throw Error.ArgumentNull("source");
            if (selector == null) 
                throw Error.ArgumentNull("selector");
            return source.Provider.CreateQuery<TResult>( 
                Expression.Call( 
                    null,
                    ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)), 
                    new Expression[] { source.Expression, Expression.Quote(selector) }
                    ));
        }

   以上是对扩张方法中八个类进行了三个不难的剖析。

四.扩展方法实例:

   
  由于扩张方法其实是对一个静态方法的调用,所以CL劲客不会变卦代码对调用方法的表达式的值举办null值检查

   1.相当处理代码:

    /// <summary>
    /// 为参数验证提供有用的方法
    /// </summary>
    public static class ArgumentValidator
    {
        /// <summary>
        /// 如果argumentToValidate为空,则抛出一个ArgumentNullException异常
        /// </summary>
        public static void ThrowIfNull(object argumentToValidate, string argumentName)
        {
            if (null == argumentName)
            {
                throw new ArgumentNullException("argumentName");
            }

            if (null == argumentToValidate)
            {
                throw new ArgumentNullException(argumentName);
            }
        }

        /// <summary>
        /// 如果argumentToValidate为空,则抛出一个ArgumentException异常
        /// </summary>
        public static void ThrowIfNullOrEmpty(string argumentToValidate, string argumentName)
        {
            ThrowIfNull(argumentToValidate, argumentName);

            if (argumentToValidate == string.Empty)
            {
                throw new ArgumentException(argumentName);
            }
        }

        /// <summary>
        /// 如果condition为真,则抛出ArgumentException异常
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="msg"></param>
        public static void ThrowIfTrue(bool condition, string msg)
        {
            ThrowIfNullOrEmpty(msg, "msg");

            if (condition)
            {
                throw new ArgumentException(msg);
            }
        }

        /// <summary>
        /// 如果指定目录存在该文件则抛出FileNotFoundException异常
        /// </summary>
        /// <param name="fileSytemObject"></param>
        /// <param name="argumentName"></param>
        public static void ThrowIfDoesNotExist(FileSystemInfo fileSytemObject, String argumentName)
        {
            ThrowIfNull(fileSytemObject, "fileSytemObject");
            ThrowIfNullOrEmpty(argumentName, "argumentName");

            if (!fileSytemObject.Exists)
            {
                throw new FileNotFoundException("'{0}' not found".Fi(fileSytemObject.FullName));
            }
        }

        public static string Fi(this string format, params object[] args)
        {
            return FormatInvariant(format, args);
        }

        /// <summary>
        /// 格式化字符串和使用<see cref="CultureInfo.InvariantCulture">不变的文化</see>.
        /// </summary>
        /// <remarks>
        /// <para>这应该是用于显示给用户的任何字符串时使用的“B”>“B”>“”。它意味着日志
        ///消息,异常消息,和其他类型的信息,不使其进入用户界面,或不会
        ///无论如何,对用户都有意义;).</para>
        /// </remarks>
        public static string FormatInvariant(this string format, params object[] args)
        {
            ThrowIfNull(format, "format");

            return 0 == args.Length ? format : string.Format(CultureInfo.InvariantCulture, format, args);
        }

        /// <summary>
        /// 如果时间不为DateTimeKind.Utc,则抛出ArgumentException异常
        /// </summary>
        /// <param name="argumentToValidate"></param>
        /// <param name="argumentName"></param>
        public static void ThrowIfNotUtc(DateTime argumentToValidate, String argumentName)
        {
            ThrowIfNullOrEmpty(argumentName, "argumentName");

            if (argumentToValidate.Kind != DateTimeKind.Utc)
            {
                throw new ArgumentException("You must pass an UTC DateTime value", argumentName);
            }
        }
    }

  2.枚举扩充方法:

 public static class EnumExtensions
    {
        /// <summary>
        /// 获取名字
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public static string GetName(this Enum e)
        {
            return Enum.GetName(e.GetType(), e);
        }

        /// <summary>
        /// 获取名字和值
        /// </summary>
        /// <param name="enumType">枚举</param>
        /// <param name="lowerFirstLetter">是否转化为小写</param>
        /// <returns></returns>
        public static Dictionary<string, int> GetNamesAndValues( this Type enumType, bool lowerFirstLetter)
        {
            //由于扩展方法实际是对一个静态方法的调用,所以CLR不会生成代码对调用方法的表达式的值进行null值检查
            ArgumentValidator.ThrowIfNull(enumType, "enumType");
            //获取枚举名称数组
            var names = Enum.GetNames(enumType);
            //获取枚举值数组
            var values = Enum.GetValues(enumType);

            var d = new Dictionary<string, int>(names.Length);

            for (var i = 0; i < names.Length; i++)
            {
                var name = lowerFirstLetter ? names[i].LowerFirstLetter() : names[i];
                d[name] = Convert.ToInt32(values.GetValue(i));
            }

            return d;
        }

        /// <summary>
        /// 转换为小写
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public static string LowerFirstLetter(this string s)
        {
            ArgumentValidator.ThrowIfNull(s, "s");

            return char.ToLowerInvariant(s[0]) + s.Substring(1);
        }
    }

五.总结:

   
在本文中,首要对扩张方法进行了某些平整表达、评释格局,使用办法,以及对增添方法的含义和扩张方法的原理进行了简单的解答。并在本文的结尾给了2个枚举的壮大方法代码。

相关文章