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

其他 2019-12-09 17:01:15 阅读次数: 0

前言

　　本文已更新至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来优化发射。

猜你喜欢

转载自www.cnblogs.com/ljdong7/p/12011931.html
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022