C# Equality and Comparisons

—Overview 2m 16s
—The == Operator for Integers 1m 56s
—== Under the Hood 3m 39s
—The == Operator for Buttons 3m 8s
—The == Operator for Strings 4m 36s
—The == Operator for Value Types 1m 39s
—Equality for Tuples 3m 0s
—Comparing == and Object.Equals() 1m 52s
—== Doesn't Always Work With Inheritance 3m 27s
—== Never Works With Generics 4m 6s
—Summary 1m 17s

—Overview 1m 35s
—Why Would You Implement Equality for a Value Type? 2m 20s
—How to Implement Equality for a Value Type 2m 54s
—Implementing IEquality<T> 1m 0s
—Overriding Object.Equals() 1m 40s
—Implementing == and != 1m 28s
—Implementing GetHashCode() 2m 38s
—Testing the Code 0m 55s
—Implementing Equality: Review 1m 7s
—Summary 1m 13s

—Overview 1m 16s
—Setting Up the Demo 3m 57s
—Why Implement Equality for Reference Types? 3m 22s
—Implementing Equality in the Base Type 4m 52s
—Implementing Equality in the Derived Type 4m 0s
—How NOT to Overload == 5m 8s
—Making == Work With Inheritance 2m 27s
—== and System.Object 1m 41s
—Understanding the Equality/OOP/Type-Safety Conflict 1m 40s
—The Dangers of Implementing IEquatable<T> 2m 10s
—The Importance of Being Sealed 2m 33s
—Summary 1m 26s

—Overview 1m 31s
—What Is a Comparison? 2m 46s
—Introducing IComparable<T> and CompareTo() 4m 51s
—IComparable<T> With Integers 1m 26s
—Comparisons vs. Equality in .NET 2m 53s
—Comparisons Are Value Only 1m 33s
—When Should You Implement IComparable<T>? 3m 4s
—Implementing IComparable<T> Demo 2m 54s
—Implementing the Comparison Operators 3m 6s
—Implementing the Non-Generic IComparable Interface 2m 33s
—IComparable<T> for Reference Types 1m 30s
—IComparable<T> in Generic Code 2m 12s
—Summary 1m 8s

—Overview 1m 28s
—Chars and Unicode Code Points 2m 39s
—Character Expansions 2m 10s
—Surrogates 2m 19s
—Combining Characters 1m 45s
—The Static String.Compare() Method 2m 28s
—Ordinal Comparisons 2m 29s
—Culture-Sensitive Comparisons 1m 0s
—Current Culture vs. Invariant Culture 1m 9s
—Setting Up the String.Compare() Demos 1m 33s
—Uppercase/Lowercase Demo 3m 14s
—Character Expansion Demo 1m 31s
—Combining Character Demo 1m 18s
—Choosing a StringComparison Value 1m 39s
—Choosing a Compare Method 2m 17s
—Equality Comparisons for Strings 1m 48s
—String Pooling and Interning 4m 31s
—Summary 1m 38s

—Overview 1m 26s
—Why Do We Need Comparers? 4m 5s
—Comparers and IComparer<T> 1m 4s
—Writing a Comparer 2m 53s
—The Comparer<T> Base Class 2m 51s
—Comparers as Singletons 1m 11s
—The Inconsistent Sort Order Problem 3m 40s
—The Problem of Inheritance (Again) 3m 2s
—IComparer<T> vs. IComparable<T> 2m 9s
—Equality Comparers and IEqualityComparer<T> 0m 49s
—How Collections Leverage Equality Comparers 3m 59s
—Implementing an Equality Comparer 3m 36s
—Implementing IEqualityComparer<T>.Equals() 1m 8s
—Implementing IEqualityComparer<T>.GetHashCode() 0m 35s
—Plugging the Equality Comparer Into a Collection 1m 21s
—Default Comparers and Equality Comparers 3m 46s
—The StringComparer Type 2m 58s
—Summary 1m 30s

—Overview 1m 10s
—What Is a Hashtable? 2m 42s
—How Hashtables Use GetHashCode() 3m 39s
—Equal Objects Must Return the Same Hash Code 3m 29s
—Other GetHashCode() Requirements 1m 25s
—A Basic Hash Code Algorithm 2m 0s
—Exclusive OR for Hash Codes 3m 0s
—When Fields Are Not Used in Equality 3m 5s
—Mapping Strings for Hash Codes 2m 38s
—Putting the Hash Code Algorithm Together 1m 21s
—Summary 1m 12s

—Overview 1m 11s
—Structural Equality and IStructuralEquatable 5m 26s
—IStructuralComparable 2m 47s
—Module Summary 1m 1s
—Equality and Comparisons Interfaces - Review 2m 41s
—Equality and Comparisons Methods - Review 1m 27s
—Course Summary 1m 53s