C#学习笔记7

1.重写GetHashCode方法注意点：

（1）重写GetHashCode方法，也应重写Equals方法，否者编译器会警告。

（2）相等的对象必须有相等的散列码（若a.Equals(b)，则a.GetHashCode()==b.GetHashCode()）。

（3）GetHashCode()不应引发任何异常，GetHashCode()必须总是成功的返回一个值。

（4）散列码应该尽可能的保持唯一。

（5）GetHashCode()的性能应该优化，GetHashCode()通常在Equals()实现中用于“短路”一次完整的相等性比较（假如散列码不同，当然就没有必要进行完整的相等性比较了），所以当类型作为字典集合中的键类型使用时，会频繁地调用这个方法。

（6）针对一个特定的对象，在这个对象的生存期内，GetHashCode()始终应该返回相同的值，即使对象的数据发生了改变。在许多时候，应该缓存方法的返回值，从而确保这一点。

　　Other:我们通常采取的做法是为来自相应类型的散列码应用XOR（异或）运算符，并确保XOR的操作数不相近或相等，否则结果会全是零。在操作数相近或相等的情况下，考虑使用移位和加法操作。其他的备选运算符--AND和OR--具有类似的限制，这些限制会发生的更加频繁，多次使用AND会逐渐变成全为0；而多次应用OR会逐渐变成全为1。为了进行更细致的控制，应该使用移位运算符来分解一个比int大的类型。例如，假定有一个名为value的long类型，它的GetHashCode()方法可以像下面这样实现：int GetHashCode(){return (int)value ^ (int)(value >> 32)}。

2.在object中，Equals()这个virtual方法的实现是用ReferenceEquals()来评判相等性。因为这个实现往往都是不充分，所以一般都有必要重写Equals()方法。

3.重写Equals()方法注意点，：

（1）检查是否为null；

（2）如果是引用类型，就检查引用是否相等；

（3）可能要检查散列码是否相等，如果散列码不相等，就没有必要继续执行一次全面的、逐字段的比较。（相等的两个对象不可能散列码不同）

（4）比较每一个标识字段，判断是否相等。

4.相等性实现的指导原则：

（1）Equals()、==运算符和!=运算符应该一起实现；

（2）一个类型在Equals()、==和!=实现中应该使用相同的算法；

（3）实现Equals()、==和!=时，也应实现一个类型的GetHashCode()方法；

（4）GetHashCode()、Equals()、==和!=永远不能引发异常；

（5）实现IComparable时，与相等性有关的方法也应实现；

可以查看Coordinate类的定义便于直观了解。

5.其他二元运算符（如“+、-、&”）的定义：就像“==”定义一样，其中至少有一个参数的类型是本类型（当前重载运算符的类型）。在重定义了这些二元运算符后，就可以像操作基本的数值类型一样进行运算。可查看Coordinate类。

6.其他的一元运算符（如“+正、-负、!、true、false”）的重载与重载二元运算符类似，只是重载“true、false”要成对出现，重载的参数变成了一个。其中的“true、false”运算符主要应用与if、do...while、for这些控制表达式使用。

7.转型运算符：转型运算符分为显式(explicit)与隐式(implicit)，隐式转型总是成功，显式转型提醒用户这是不希望的行为，显式存在2个问题“①转换可能会有异常，②转换可能会存在部分数据丢失”。可查看Angle结构的代码示例。

8.命名空间：命名空间可以嵌套，就是类一样可以嵌套，命名空间的嵌套有2种，分别为声明层次的嵌套；声明时“.”符号隔开。如 System.IO。

9.生成类文件的注释的xml文档：可以在VS的命令工具中使用“csc /doc:文档名.xml 类文件”。其实也可以在VS-IDE的项目属性=>生成=>设置xml文档输出，即可生成项目文档说明，当然可以使用一些免费工具进行文档生成（如GhostDoc、NDoc）。在把程序集提供给他人使用时（程序集是不含文档说明，编译器会把源代码中注释忽略），若要使VS IntelliSense提示程序集中的成员说明信息，需让XML文件的文件名与您要支持的程序集相同，确保XML文件与程序集位于同一个目录中，从而在Visual Studio项目中引用程序集时，也可以找到.xml文件。

10.终结器：终结器是用来清理一个类的占用的昂贵的资源（如数据库连接、文件句柄），其不能显式调用，是由垃圾回收器负责调用，因此我们不能在编译时确定终结器执行的时机，唯一确定的是终结器会在上一次使用对象之后，并在应用程序关闭之前的某个时间运行。其声明的方式是“~类名(){}”,不允许传递参数与添加如public修饰符，因为其本身是不能显式调用。基类中的终结器会作为对象终结调用的一部分而自动调用。可查看TemporaryFileStream类的处理代码。

11.使用using语句进行确定性的终结：终结器本身的问题在于，它们不支持一个确定性终结（也就是预知一个终结器的运行时间的能力），相反，终结器是作为对资源清理的一个备用机制来使用。假如开发者忘记显式调用必要的清理代码，就可以依赖终结器来清理资源。要进行确定的终结需要类本身实现IDisposable接口，该接口内包含Dispose()方法，需要自己实现具体的细节来清理资源。使用using语句终结和使用try-finally处理是一个效果，因为此处的using语句在最终生成的CIL代码上就是try-finally，using语句只是提供了try-fianlly块的一个语法快捷方式。在using中可以实例化多个类型一致的变量，来一起处理释放。可查看TemporaryFileStream类的处理代码。

12.资源利用与终结的指导原则：

（1）只有在对象使用了稀缺或昂贵资源的前提下，才为对象实现finalize，终结会推迟垃圾回收。

（2）有终结器的对象应该实现IDisposable接口来支持确定性的终结。

（3）终结方法通常调用与IDisposable调用相同的代码。

（4）终结器应避免造成任何未处理的异常。

（5）像Dispose()和Close()这样的确定性终结方法应该调用GC.SuppressFinalize()，使垃圾回收更快的发生。

（6）资源清理方法应该足够简单，而且只应着重于清理由终结实例引用的资源。

（7）若基类实现了Dispose()，则派生实现应调用基类的实现。

13.延迟初始化Lazy<T>:在.net4.0中提供了Lazy<T>可对对象进行延迟初始化（即需要该对象时才被创建），可查看DataCache类的实现。

public class Coordinate
{
/// <summary>
/// 经度
/// </summary>
public Angle Longitude { get; set; }
/// <summary>
/// 维度
/// </summary>
public Angle Latitude { get; set; }

public override int GetHashCode()
{
int hashCode = Longitude.GetHashCode();
if (hashCode != Latitude.GetHashCode())
{
hashCode ^= Latitude.GetHashCode();
}
return hashCode;
}

public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
return Equals((Coordinate)obj);
}

public bool Equals(Coordinate obj)
{
if (obj == null)
{
return false;
}
if (GetHashCode() != obj.GetHashCode())
{
return false;
}
return Longitude.Equals(obj.Longitude) && Latitude.Equals(obj.Latitude);
}

public static bool operator ==(Coordinate one, Coordinate two)
{
if (ReferenceEquals(one, null))//此处不用==判断null，是因为我们重定义了本类的“==”操作符，否则会进入递归造成死循环。
{
return ReferenceEquals(two, null);
}
return one.Equals(two);
}

public static bool operator !=(Coordinate one, Coordinate two)
{
return !(one == two);
}

public static Coordinate operator +(Coordinate one, Coordinate two)
{
return new Coordinate()
{
Longitude = one.Longitude + two.Longitude,
Latitude = one.Latitude + two.Latitude
};
}

public static bool operator !(Coordinate one)
{
return false;
}

public static bool operator true(Coordinate one)
{
return one.Latitude.Hours > 0 && one.Latitude.Minutes > 0 && one.Latitude.Seconds > 0;
}

public static bool operator false(Coordinate one)
{
if (one)
{
return false;
}
return true;
}
}

public struct Angle
{
public Angle(int hours, int minutes, int seconds)
{
Hours = hours;
Minutes = minutes;
Seconds = seconds;
}
public int Hours { get; set; }
public int Minutes { get; set; }
public int Seconds { get; set; }

public Angle Move(int hours, int minutes, int seconds)
{
return new Angle(Hours + hours, Minutes + minutes, Seconds + seconds);
}

public override int GetHashCode()
{
return base.GetHashCode();
}

public override bool Equals(object obj)
{
return Equals((Angle)obj);
}

public bool Equals(Angle obj)
{
return Hours == obj.Hours && Minutes == obj.Minutes && Seconds == obj.Seconds;
}

public static Angle operator +(Angle one, Angle two)
{
return one.Move(two.Hours, two.Minutes, two.Seconds);
}

public static implicit operator string(Angle one)
{
return string.Format("{0},{1},{2}", one.Hours, one.Minutes, one.Seconds);
}

public static explicit operator Angle(string text)
{
try
{
var result = text.Split(',').Cast<int>();
return new Angle(result.ElementAt(0), result.ElementAt(1), result.ElementAt(2));
}
catch (Exception ex)
{
throw ex;
}
}
}

public class TemporaryFileStream : IDisposable
{
public TemporaryFileStream(string fileName)
{
//todo
}

~TemporaryFileStream()
{
Dispose();
}

private readonly FileStream _stream;
public FileStream Stream
{
get { return _stream; }
}

private readonly FileInfo _file;
public FileInfo File
{
get { return _file; }
}

public void Dispose()
{
Stream?.Close();
File?.Delete();
/*该语句的作用是从终结列队中移除TemporaryFileStream类实例，一个对象在终结列队中就是不会进行垃圾回收，必须终结后才能垃圾回收，执行此语句就不会推迟该对象的
垃圾回收。*/
GC.SuppressFinalize(this);
}
}

public class DataCache
{
public DataCache()
{
_fileStream = new Lazy<TemporaryFileStream>(() => new TemporaryFileStream(FileStreamName));
}
public string FileStreamName { get; set; }

private Lazy<TemporaryFileStream> _fileStream;
public TemporaryFileStream FileStream
{
//只有在返回“value”时，才会执行“() => new TemporaryFileStream(FileStreamName)”代码，
get { return _fileStream.Value; }
}

/* .net4.0以前模拟的延迟初始化对象
private TemporaryFileStream _fileStream;
public TemporaryFileStream FileStream
{
get
{
if (_fileStream == null)
{
_fileStream = new TemporaryFileStream(FileStreamName);
}
return _fileStream;
}
}*/
}

------------------------以上内容根据《C#本质论 第三版》进行整理