C#学习笔记7

2018-06-22 04:38:30来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

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#本质论 第三版》进行整理

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:基本的SQL语句

下一篇:[C#] C# 知识回顾 - Lambda