2014
Pluralsight
Simon Robinson
4h 51m
English
This course teaches you how equality and comparisons function in .NET and the correct way to implement equality and comparisons for your own types.
In this course, you'll learn how to use equality and comparisons correctly in your C# code: both how they work out of the box, and how to implement equality and comparisons for your own types. The course also covers working with inheritance, string comparisons, writing custom comparers and equality comparers, hash codes, and structural comparisons.
01. Why Is Equality So Hard? 00:28:10
01. Welcome and Course Overview 03:58
02. Aims of This Course 01:53
03. So Why Is Equality Hard? 01:49
04. Reference vs. Value Equality 03:38
05. Equality, Value Types, and Boxing 03:13
06. Multiple Ways to Compare Values 03:38
07. 'Natural' vs. 'Plugged-In' Equality 02:49
08. Equality for Floating Points 02:57
09. The Equality/OOP/Type-Safety Conflict 02:56
10. Summary 01:16
02. Equality in .NET 00:27:22
11. Overview 01:28
12. The Virtual Object.Equals() Method 05:00
13. Equals() for Strings 02:31
14. Equals() for Value Types 03:36
15. Object.Equals() - Review 01:31
16. The Static Equals() Method 03:28
17. The ReferenceEquals() Method 01:29
18. Introducing IEquatable
03:06
19. IEquatable Demo 01:50
20. IEquatable, Strings and Reference Types 01:44
21. Summary 01:33
03. The C# Equality Operator 00:31:01
22. Overview 02:16
23. The == Operator for Integers 01:56
24. == Under the Hood 03:39
25. The == Operator for Buttons 03:08
26. The == Operator for Strings 04:36
27. The == Operator for Value Types 01:39
28. Equality for Tuples 03:00
29. Comparing == and Object.Equals() 01:52
30. == Doesn't Always Work With Inheritance 03:27
31. == Never Works With Generics 04:06
32. Summary 01:17
04. Implementing Equality for Value Types 00:16:53
33. Overview 01:35
34. Why Would You Implement Equality for a Value Type? 02:20
35. How to Implement Equality for a Value Type 02:54
36. Implementing IEquality 01:00
37. Overriding Object.Equals() 01:40
38. Implementing == and != 01:28
39. Implementing GetHashCode() 02:38
40. Testing the Code 00:55
41. Implementing Equality: Review 01:07
42. Summary 01:13
05. Implementing Equality for Reference Types 00:34:39
43. Overview 01:16
44. Setting Up the Demo 03:57
45. Why Implement Equality for Reference Types? 03:22
46. Implementing Equality in the Base Type 04:52
47. Implementing Equality in the Derived Type 04:00
48. How NOT to Overload == 05:08
49. Making == Work With Inheritance 02:27
50. == and System.Object 01:41
51. Understanding the Equality/OOP/Type-Safety Conflict 01:40
52. The Dangers of Implementing IEquatable 02:10
53. The Importance of Being Sealed 02:33
54. Summary 01:26
06. Comparisons in .NET 00:31:36
55. Overview 01:31
56. What Is a Comparison? 02:46
57. Introducing IComparable and CompareTo() 04:51
58. IComparable With Integers 01:26
59. Comparisons vs. Equality in .NET 02:53
60. Comparisons Are Value Only 01:33
61. When Should You Implement IComparable? 03:04
62. Implementing IComparable Demo 02:54
63. Implementing the Comparison Operators 03:06
64. Implementing the Non-Generic IComparable Interface 02:33
65. IComparable for Reference Types 01:30
66. IComparable in Generic Code 02:12
67. Summary 01:08
07. Equality and Comparisons for Strings 00:37:13
68. Overview 01:28
69. Chars and Unicode Code Points 02:39
70. Character Expansions 02:11
71. Surrogates 02:20
72. Combining Characters 01:45
73. The Static String.Compare() Method 02:28
74. Ordinal Comparisons 02:30
75. Culture-Sensitive Comparisons 01:00
76. Current Culture vs. Invariant Culture 01:10
77. Setting Up the String.Compare() Demos 01:33
78. Uppercase/Lowercase Demo 03:15
79. Character Expansion Demo 01:32
80. Combining Character Demo 01:18
81. Choosing a StringComparison Value 01:39
82. Choosing a Compare Method 02:18
83. Equality Comparisons for Strings 01:48
84. String Pooling and Interning 04:32
85. Summary 01:39
08. Comparers and Equality Comparers 00:42:19
86. Overview 01:27
87. Why Do We Need Comparers? 04:06
88. Comparers and IComparer 01:04
89. Writing a Comparer 02:53
90. The Comparer Base Class 02:51
91. Comparers as Singletons 01:12
92. The Inconsistent Sort Order Problem 03:40
93. The Problem of Inheritance (Again) 03:02
94. IComparer vs. IComparable 02:09
95. Equality Comparers and IEqualityComparer 00:50
96. How Collections Leverage Equality Comparers 03:59
97. Implementing an Equality Comparer 03:37
98. Implementing IEqualityComparer.Equals() 01:08
99. Implementing IEqualityComparer.GetHashCode() 00:36
100. Plugging the Equality Comparer Into a Collection 01:21
101. Default Comparers and Equality Comparers 03:46
102. The StringComparer Type 02:59
103. Summary 01:30
09. Hash Codes and Hashtables 00:25:46
104. Overview 01:10
105. What Is a Hashtable? 02:42
106. How Hashtables Use GetHashCode() 03:39
107. Equal Objects Must Return the Same Hash Code 03:29
108. Other GetHashCode() Requirements 01:25
109. A Basic Hash Code Algorithm 02:00
110. Exclusive OR for Hash Codes 03:00
111. When Fields Are Not Used in Equality 03:05
112. Mapping Strings for Hash Codes 02:38
113. Putting the Hash Code Algorithm Together 01:21
114. Summary 01:12
10. Structural Equality and Comparisons 00:16:27
115. Overview 01:11
116. Structural Equality and IStructuralEquatable 05:26
117. IStructuralComparable 02:47
118. Module Summary 01:01
119. Equality and Comparisons Interfaces - Review 02:41
120. Equality and Comparisons Methods - Review 01:27
121. Course Summary 01:53
http://pluralsight.com/
Download File Size:1.15 GB
|
