前言
本文已更新至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來優化發射，
轉載請註明出處，本文鏈接：https://www.uj5u.com/net/93237.html
標籤：C#
上一篇：C#程式撰寫高質量代碼改善的157個建議【10-12】[創建物件時需要考慮是否實作比較器、區別對待==和Equals]
下一篇：簡單介紹托管執行和 CLI