在构建自己的类型时，始终应该考虑是否可以使用运算符重载
如果需要排序，有两种比较器实现
class FirstType : IComparable<FirstType>
{
public string name;
public int age;
public FirstType(int age)
{
name = "aa";
this.age = age;
}
public int CompareTo(FirstType other)
{
return other.age.CompareTo(age);
}
}
static void Main(string[] args)
{
FirstType f1 = new FirstType(3);
FirstType f2 = new FirstType(5);
FirstType f3 = new FirstType(2);
FirstType f4 = new FirstType(1);
List<FirstType> list = new List<FirstType>
{
f1,f2,f3,f4
};
list.Sort();
foreach (var item in list)
{
Console.WriteLine(item);
}
}
或者第二种
class Program : IComparer<FirstType>
{
static void Main(string[] args)
{
FirstType f1 = new FirstType(3);
FirstType f2 = new FirstType(5);
FirstType f3 = new FirstType(2);
FirstType f4 = new FirstType(1);
List<FirstType> list = new List<FirstType>
{
f1,f2,f3,f4
};
list.Sort(new Program());
foreach (var item in list)
{
Console.WriteLine(item);
}
}
int IComparer<FirstType>.Compare(FirstType x, FirstType y)
{
return x.age.CompareTo(y.age);
}
}它调用的是Program的Compare方法
无论是== 还是Equals：
对于值类型，如果类型的值相等，则返回True
对于引用类型，如果类型指向同一个对象，则返回True
且他们都可以被重载
对于string这样一个特殊的引用类，微软可能认为它的现实意义更倾向于一个值类型，所以在FCL（Framework Class Library）中string的比较被重载为值比较，而不是针对引用本身
从设计上来说，很多引用类型会存在类似于string类型比较相近的情况，如人，他的身份证号相同，则我们就认为是一个人，这个时候就需要重载Equals方法，
一般来说，对于引用类型，我们要定义值相等的特性，应该仅仅重写Equals方法，同时让==表示引用相等，这样我们想比较哪个都是可以的
由于操作符“==”和“Equals”都可以被重载为“值相等”和“引用相等”，所以为了明确，FCL提供了object.ReferenceEquals(); 来比较两个实例是否为同一个引用
字典中判断ContainsKey的时候使用的是key类型的HashCode,所以我们想都使用类型中的某个值来作为判断条件，就需要重新GetHashCode，当然还有其他使用HashCode来作为判断是否相等的，如果我们不重写，可以会产生其他的效果
public override int GetHashCode()
{
//这样写是为了减少HashCode重复的概率，至于为什么这样写我也不清楚。。 记着就行
return (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName +
"#" + age).GetHashCode();
}重写Equals方法的同时，也应该事先一个类型安全的接口IEquatable<T> ，所以重写Equals的最终版本应该是
class FirstType : IEquatable<FirstType>
{
public string name;
public int age;
public FirstType(int age)
{
name = "aa";
this.age = age;
}
public override bool Equals(object obj)
{
return age.Equals(((FirstType)obj).age);
}
public bool Equals(FirstType other)
{
return age.Equals(other.age);
}
public override int GetHashCode()
{
return (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName +
"#" + age).GetHashCode();
}
}class Person : IFormattable
{
public override string ToString()
{
return "Default Hello";
}
public string ToString(string format, IFormatProvider formatProvider)
{
switch (format)
{
case "Chinese":
return "你好";
case "English":
return "Hello";
}
return "helo";
}
}static void Main(string[] args)
{
Person p1 = new Person();
Console.WriteLine(p1);
Console.WriteLine(p1.ToString("Chinese",null));
Console.WriteLine(p1.ToString("English", null));
}
当继承了IFormattable接口后，可以在ToString里面穿参数来调用不同的ToString，上面的默认ToString就不会调用到了
具体还有一个IFormatProvider接口，我还没研究
无论是深拷贝还是浅拷贝，微软都见识用类型继承ICloneable接口的方式来明确告诉调用者：该类型可以被拷贝
//记得在类前添加[Serializable]的标志
[Serializable]
class Person : ICloneable
{
public string name;
public Child child;
public object Clone()
{
//浅拷贝
return this.MemberwiseClone();
}
/// <summary>
/// 深拷贝
/// 我也不清楚为什么这样写
/// </summary>
/// <returns></returns>
public Person DeepClone()
{
using (Stream objectStream = new MemoryStream())
{
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(objectStream, this);
objectStream.Seek(0, SeekOrigin.Begin);
return formatter.Deserialize(objectStream) as Person;
}
}
}
[Serializable]
class Child
{
public string name;
public Child(string name)
{
this.name = name;
}
public override string ToString()
{
return name;
}
}浅拷贝：
输出的p1.child.name 是更改过的p2的child.name
深拷贝：
输出的是原来的
深拷贝是对于引用类型来说，理论上string类型是引用类型，但是由于该引用类型的特殊性，Object.MemberwiseClone仍然为其创建了副本，也就是说在浅拷贝过程中，我们应该将字符串看成是值类型
static void Main(string[] args)
{
//使用反射
Stopwatch watch = Stopwatch.StartNew();
Person p1 = new Person();
var add = typeof(Person).GetMethod("Add");
for (int i = 0; i < 1000000; i++)
{
add.Invoke(p1, new object[] { 1, 2 });
}
Console.WriteLine(watch.ElapsedTicks);
//使用dynamic
watch.Reset();
watch.Start();
dynamic d1 = new Person();
for (int i = 0; i < 1000000; i++)
{
d1.Add(1, 2);
}
Console.WriteLine(watch.ElapsedTicks);
}可以看出使用dynamic会比使用反射写出来的代码美观且简洁，而且多次运行的效率也会更高，因为dynamic第一次运行后会缓存起来
几乎相差了10倍
但是反射如果次数较少效率会更高
这个是运行了100次的结果
但是很多时候效率不是必要的，始终
