编写高质量代码改善C#程序的157个建议[为类型输出格式化字符串、实现浅拷贝和深拷贝、用dynamic来优化反射]

前言

  本文已更新至http://www.cnblogs.com/aehyok/p/3624579.html 。本文主要学习记录以下内容:

  建议13、为类型输出格式化字符串

  建议14、正确实现浅拷贝和深拷贝

  建议15、使用dynamic来简化反射实现

建议13、为类型输出格式化字符串

   有两种方法可以为类型提供格式化的字符串输出。

  一种是意识到类型会产生格式化字符串输出,于是让类型继承接口IFormattable。这对类型来说,是一种主动实现的方式,要求开发者可以预见类型在格式化方面的要求。

  更多的时候,类型的使用者需为类型自定义格式化器,这就是第二种方法,也是最灵活多变的方法,可以根据需求的变化为类型提供多个格式化器。

  下面我们就来看一下这两种方式的实现。

  最简单的字符串输出是为类型重写ToString()方法,如果没有为类型重写该方法,默认会调用Ojbect的ToString方法,它会返回当前类型的类型名称。但即使是重写了ToString()方法,提供的字符串输出也是非常单一的,而通过实现IFormattable接口的ToString()方法,可以让类型根据用户的输入而格式化输出。

下面我们来看一个简单的小例子:

    public class Person:IFormattable
    {
        public string IDCode { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        /// <summary>
        /// 实现接口Iformattable的方法ToString
        /// </summary>
        /// <param name="format"></param>
        /// <param name="formatProvider"></param>
        /// <returns></returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            switch (format)
            { 
                case"Ch":
                    return this.ToString();
                case"Eg":
                    return string.Format("{0}{1}", this.FirstName, this.LastName);
                default:
                    return
                        this.ToString();
            }
        }
        ///重写Object的方法ToString()
        public override string ToString()
        {
            return string.Format("{0}{1}",this.LastName,this.FirstName);
        }
    }

调用代码如下所示:

        static void Main(string[] args)
        {
            Person person = new Person() { FirstName="Kris",LastName="aehyok"};
            Console.WriteLine(person);
            Console.WriteLine(person.ToString("Ch",null));
            Console.WriteLine(person.ToString("Eg", null));
            Console.ReadLine();
        }

调用执行结果如下:

  下面我们来继续介绍第二实现方式——格式化器。如果类型本身没有提供格式化的功能,那么格式化器就可以派上用场了。格式化器的好处就是可以根据需求的变化,随时增加或者修改它。

  接下来我们继续来看另外的一个小例子:

首先定义一个实体类Person:

    public class Person
    {
        public string IDCode { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }

一个典型的格式化器应该继承IFormatProvider和ICustomerFormatter,看代码:

    public class PersonFomatter:IFormatProvider,ICustomFormatter
    {
        #region IFormatProvider成员
        public object GetFormat(Type formatType)
        {
            if (formatType == typeof(ICustomFormatter))
            {
                return this;
            }
            else
            {
                return null;
            }
        }
        #endregion

        #region ICustomFormatter成员
        public string Format(string format, object arg, IFormatProvider formatProvider)
        {
            Person person = arg as Person;
            if (person == null)
            {
                return string.Empty;
            }
            switch (format)
            { 
                case"Ch":
                    return string.Format("{0} {1}",person.LastName,person.FirstName);
                case"":
                    return string.Format("{0} {1}",person.FirstName,person.LastName);
                case"CHM":
                    return string.Format("{0} {1}:{2}", person.LastName, person.FirstName, person.IDCode);
                default:
                    return string.Format("{0} {1}", person.LastName, person.FirstName);
            }
        }
        #endregion
    }

调用代码如下:

    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person() { FirstName="Kris", LastName="aehyok", IDCode="ID000001"};
            Console.WriteLine(person.ToString());
            PersonFomatter pFomatter = new PersonFomatter();
            Console.WriteLine(pFomatter.Format("Ch", person, null));
            Console.WriteLine(pFomatter.Format("Eg", person, null));
            Console.WriteLine(pFomatter.Format("CHM", person, null));
            Console.ReadLine();
        }
    }

调用执行结果如下:

其实还有另外一种变通的形式,就是将这两种方式合并一起使用的过程,下面来看一下具体的实现代码:

public class Person:IFormattable
    {
        public string IDCode { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
                /// <summary>
        /// 实现接口Iformattable的方法ToString
        /// </summary>
        /// <param name="format"></param>
        /// <param name="formatProvider"></param>
        /// <returns></returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            switch (format)
            { 
                case"Ch":
                    return this.ToString();
                case"Eg":
                    return string.Format("{0}{1}", this.FirstName, this.LastName);
                default:
                    //return this.ToString();
                    ICustomFormatter customerFormatter = formatProvider as ICustomFormatter;
                    if (formatProvider == null)
                    {
                        return this.ToString();
                    }
                    return customerFormatter.Format(format, this, null);
            }
        }
        ///重写Object的方法ToString()
        public override string ToString()
        {
            return string.Format("{0}{1}",this.LastName,this.FirstName);
        }
    }

PersonFomatter自定义格式化器的代码并没有发生任何的改变。 调用代码如下:

        static void Main(string[] args)
        {
            Person person = new Person() { FirstName="Kris", LastName="aehyok", IDCode="ID000001"};
            Console.WriteLine(person.ToString());
            PersonFomatter pFomatter = new PersonFomatter();
            Console.WriteLine(pFomatter.Format("Ch", person, null));
            Console.WriteLine(pFomatter.Format("Eg", person, null));
            Console.WriteLine(pFomatter.Format("CHM", person, null));

            Console.WriteLine(person.ToString("Ch",pFomatter));
            Console.WriteLine(person.ToString("Eg", pFomatter));
            Console.WriteLine(person.ToString("CHM", pFomatter));
            Console.ReadLine();
        }

调用执行结果如下所示:

建议14、正确实现浅拷贝和深拷贝

为对象创建副本的技术成为拷贝(也叫克隆)。我们将拷贝分为浅拷贝和深拷贝。

浅拷贝 将对象中的所有字段复制到新的对象(副本)中。其中,值类型字段的值被复制到副本中后,在副本中的修改不会影响到源对象对应的值。 而引用类型的字段被复制到副本中的是引用类型的引用,而不是引用的对象,在副本中对引用类型的字段值做修改会影响到源对象本身。

深拷贝 同样,将对象中的所有字段复制到新的对象中。不过无论是对象的值类型字段,还是引用类型字段,都会被重新创建并赋值,对于副本的修改,不会影响到源对象本身。

无论是浅拷贝还是深拷贝,微软都建议用类型继承ICloneable接口的方式明确告诉调用者:该类型可以被拷贝。当然,ICloneable接口只提供了一个声明为Clone的方法,我们可根据需求在Clone方法内实现浅拷贝或深拷贝。一个简答的浅拷贝的实现代码如下所示:

首先定义实体类:

    public class Employee:ICloneable
    {
        public string IDCode { get; set; }
        public int Age { get; set; }
        public Department Department { get; set; }

        #region OCloneable成员
        public object Clone()
        {
            return this.MemberwiseClone();
        }
        #endregion
    }

    public class Department
    {
        public string Name{get;set;}
        public override string  ToString()
        {
              return this.Name;
        }
    }

然后进行调用代码如下:

        static void Main(string[] args)
        {
            Employee Niki = new Employee()
            {
                IDCode = "IDaehyok",
                Age = 25,
                Department = new Department() { Name="Depart1" }
            };
            Employee Kris = Niki.Clone() as Employee;
            Console.WriteLine(string.Format("IDCode:{0}\tAge:{1}\tDepartment:{2}", Kris.IDCode, Kris.Age, Kris.Department));
            ///开始改变Niki的值
            Niki.IDCode = "IDNiki";
            Niki.Age = 23;
            Niki.Department.Name = "Depart2";
            Console.WriteLine(string.Format("IDCode:{0}\tAge:{1}\tDepartment:{2}", Kris.IDCode, Kris.Age, Kris.Department));
            Console.ReadLine();
        }

调用执行结果如下

注意到Employee的IDCode属string类型。理论上string类型是引用类型,但是由于该引用类型的特殊性(无论是实际还是语义),Object.MemberwiseClone方法仍旧为其创建了副本。也就是说,在浅拷贝过程,我们应该将字符串看成是值类型。Employee的Department属性是一个引用类型,所以,如果改变了源对象Niki中的值,那么副本Kris中的值也会随之一起变动。

 Employee的深拷贝有多种实现方法,最简单的方式是手动的对字段进行逐个的赋值。但是这种方法容易出错,也就是说,如果类型的字段发生变化或有增减,那么该拷贝方法也要发生相应的变化,所以,建议使用序列化的形式来进行深拷贝。Employee深拷贝的一种实现方式如下:

    [Serializable]
    public class Employee:ICloneable
    {
        public string IDCode { get; set; }
        public int Age { get; set; }
        public Department Department { get; set; }

        #region OCloneable成员
        public object Clone()
        {
            using (Stream objectstream = new MemoryStream())
            {
                IFormatter formatter = new BinaryFormatter();
                formatter.Serialize(objectstream, this);
                objectstream.Seek(0, SeekOrigin.Begin);
                return formatter.Deserialize(objectstream) as Employee;
            }
        }
        #endregion
    }

    [Serializable]
    public class Department
    {
        public string Name{get;set;}
        public override string ToString()
        {
              return this.Name;
        }
    }

调用方法如下所示:

            Employee Niki = new Employee()
            {
                IDCode = "IDaehyok",
                Age = 25,
                Department = new Department() { Name="Depart1" }
            };
            Employee Kris = Niki.Clone() as Employee;
            Console.WriteLine(string.Format("IDCode:{0}\tAge:{1}\tDepartment:{2}", Kris.IDCode, Kris.Age, Kris.Department));
            ///开始改变Niki的值
            Niki.IDCode = "IDNiki";
            Niki.Age = 23;
            Niki.Department.Name = "Depart2";
            Console.WriteLine(string.Format("IDCode:{0}\tAge:{1}\tDepartment:{2}", Kris.IDCode, Kris.Age, Kris.Department));
            Console.ReadLine();

最终代码调用结果如下

可以发现再次改变Niki的值,不会对副本Kris产生影响。

由于接口ICloneable,只有一个模棱两可的方法,所以,如果要在一个类中进行浅拷贝和深拷贝,只能由我们额外的实现两个方法。声明为DeepClone和Shallow。那么最终代码如下所示:

    [Serializable]
    public class Employee:ICloneable
    {
        public string IDCode { get; set; }
        public int Age { get; set; }
        public Department Department { get; set; }

        #region OCloneable成员
        public object Clone()
        {
            return this.MemberwiseClone();
        }
        #endregion

        public Employee DeeptClone()
        {
            using (Stream objectstream = new MemoryStream())
            {
                IFormatter formatter = new BinaryFormatter();
                formatter.Serialize(objectstream, this);
                objectstream.Seek(0, SeekOrigin.Begin);
                return formatter.Deserialize(objectstream) as Employee;
            }
        }

        public Employee Shallow()
        {
            return Clone() as Employee;
        }
    }

建议15、使用dynamic来简化反射实现

  Dynamic是Framework4.0的新特性。dynamic的出现让C#具有了弱类型的特性。编译器在编译的时候不再对类型进行检查,编译器默认dynamic对象支持开发者想要的任何类型。如果运行时不包含指定的特性,运行时程序会抛出一个RuntimeBinderException异常。

下面我们先来看一个简单的例子

    public class DynamicSample
    {
        public string Name { get; set; }
        public int Add(int a, int b)
        {
            return a + b;
        }
    }

现在我们想调用上面实体类的Add方法,实现方式可以是这样的:

            DynamicSample dynamicSample = new DynamicSample();
            var addMethod = typeof(DynamicSample).GetMethod("Add");
            int re = (int)addMethod.Invoke(dynamicSample, new object[] { 1, 2 });
            Console.WriteLine(re);

下面我们再通过使用dynamic来实现一下:

            dynamic dynamic = new DynamicSample();
            int re2 = dynamic.Add(1, 2);
            Console.WriteLine(re2);

可以发现dynamic的实现方式很简洁,而且性能也有所提升,当然上面一次的调用我们是看不出什么效果的,假如上面的代码我们进行调用了10000000次。

            int times = 10000000;
            ////第一种调用方式
            DynamicSample reflectSample = new DynamicSample();
            var addMethod = typeof(DynamicSample).GetMethod("Add");
            Stopwatch watch1 = Stopwatch.StartNew();///用于测试运行时间
            for (var i = 0; i < times; i++)
            {
                addMethod.Invoke(reflectSample, new object[] { 1, 2 });
            }
            Console.WriteLine(string.Format("普通方法反射耗时:{0} 毫秒", watch1.ElapsedMilliseconds));

            ////第二种调用方式
            dynamic dynamicSample = new DynamicSample();
            Stopwatch watch2 = Stopwatch.StartNew();
            for (int i = 0; i < times; i++)
            {
                dynamicSample.Add(1, 2);
            }
            Console.WriteLine(string.Format("dynamic方式耗时:{0} 毫秒", watch2.ElapsedMilliseconds));

            ////第三种调用方式
            DynamicSample reflectSampleBetter = new DynamicSample();
            var addMethod2 = typeof(DynamicSample).GetMethod("Add");
            var delg = (Func<DynamicSample, int, int, int>)Delegate.CreateDelegate(typeof(Func<DynamicSample, int, int, int>), addMethod2);
            Stopwatch watch3 = Stopwatch.StartNew();
            for (var i = 0; i < times; i++)
            {
                delg(reflectSampleBetter, 1, 2);
            }
            Console.WriteLine(string.Format("优化的反射耗时:{0} 毫秒", watch3.ElapsedMilliseconds));
            Console.ReadLine();

调用执行后的结果为

现在可以看出很明显的区别,普通方法调用发射执行效率远远的低于使用dynamic。第三种方式是我们优化了发射之后的执行时间,比使用dynamic也有所提升,但是并不是特别明显,虽然带来了性能的提升,不过却牺牲了代码的整洁性。这种实现方式在我看来是得不偿失的。所以建议大家使用dynamic来优化发射。

到这里为止,第一章的内容暂时已经整理完毕,感觉自己学了不少知识,继续加油,接下来继续进行第二章集合和LINQ的学习。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏二进制文集

JSON Java 解析

要使程序可以运行必须引入JSON-lib包——org.json.jar包。综合来看,这个JAR包比较好用。

1612
来自专栏菩提树下的杨过

java学习:调用 java web service

先写一个java的class:AwbModel(相当于要在web service中传输的实体对象) package webservicesample; pub...

2696
来自专栏Java后端技术

22中编程语言的HelloWorld

791
来自专栏GreenLeaves

C# 字符串操作基本过程(Equals、Compare、EndsWith等处理方法)

4022
来自专栏技术博客

Asp.net MVC后台 XML、DataTable、DataSet之间的数据转换

  上面的方法只是将XMl字符串读入到DataSet中,然后再冲DataSet中查找先前定义过的DataTable即可。

1392
来自专栏跟着阿笨一起玩NET

在C#中ParameterizedThreadStart和ThreadStart区别

901
来自专栏码农阿宇

关于C#委托的一些学习笔记

1.什么是委托就是把方法作为参数传给另一个方法。委托说指向的函数,必须和函数具有相同的签名(返回值和参数类型) Public delegate void D...

2747
来自专栏技术博客

编写高质量代码改善C#程序的157个建议[勿选List<T>做基类、迭代器是只读的、慎用集合可写属性]

  本文已更新至http://www.cnblogs.com/aehyok/p/3624579.html 。本文主要学习记录以下内容:

1393
来自专栏技术博客

一步一步学Linq to sql(一):预备知识

  Linq to sql(或者叫DLINQ)是LINQ(.NET语言集成查询)的一部分,全称基于关系数据的 .NET 语言集成查询,用于以对象形式管理关系数据...

951
来自专栏跟着阿笨一起玩NET

DataGridView绑定BindingList<T>带数据排序的类

本文章转载:http://yuyingying1986.blog.hexun.com/30905610_d.html

771

扫码关注云+社区

领取腾讯云代金券