레코드와 유사한 타입 및 값 기반 동등성 패턴

레코드와 유사한 형식 개요

참조 동일성 문제

using System;

public class PersonRef
{
  public string First;
  public string Last;
}

public class Program
{
  public static void Main(string[] args)
  {
    PersonRef a = new PersonRef { First = "Ada", Last = "Lovelace" };
    PersonRef b = new PersonRef { First = "Ada", Last = "Lovelace" };

    Console.WriteLine("Reference Equals? " + object.ReferenceEquals(a, b)); // false
    Console.WriteLine("== (default)? " + (a == b)); // false (same as ReferenceEquals for classes)
  }
}

레코드와 유사한 클래스 패턴

using System;

// Immutable, value-based equality
public sealed class Person : IEquatable<Person>
{
  public string First { get; private set; }
  public string Last  { get; private set; }

  public Person(string first, string last)
  {
    if (string.IsNullOrEmpty(first)) throw new ArgumentException("first");
    if (string.IsNullOrEmpty(last))  throw new ArgumentException("last");
    First = first; Last = last;
  }

  // "With" helper for copy-on-change
  public Person WithFirst(string first) { return new Person(first, Last); }
  public Person WithLast(string last)   { return new Person(First, last); }

  public bool Equals(Person other)
  {
    if (object.ReferenceEquals(other, null)) return false;
    if (object.ReferenceEquals(this, other)) return true;
    return string.Equals(First, other.First) && string.Equals(Last, other.Last);
  }

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

  public override int GetHashCode()
  {
    unchecked
    {
      int h = 17;
      h = h * 31 + (First == null ? 0 : First.GetHashCode());
      h = h * 31 + (Last  == null ? 0 : Last.GetHashCode());
      return h;
    }
  }

  public static bool operator ==(Person a, Person b)
  {
    if (object.ReferenceEquals(a, b)) return true;
    if ((object)a == null || (object)b == null) return false;
    return a.Equals(b);
  }

  public static bool operator !=(Person a, Person b) { return !(a == b); }
}

public class Program
{
  public static void Main(string[] args)
  {
    Person p1 = new Person("Ada", "Lovelace");
    Person p2 = new Person("Ada", "Lovelace");
    Console.WriteLine("Value Equals? " + (p1 == p2)); // true
    Person p3 = p1.WithLast("King");
    Console.WriteLine("After With: " + (p1 == p3));   // false
  }
}

구조체 동등성 패턴

using System;

public struct Point2 : IEquatable<Point2>
{
  public int X;
  public int Y;

  public Point2(int x, int y) { X = x; Y = y; }

  public bool Equals(Point2 other)
  {
    return X == other.X && Y == other.Y;
  }

  public override bool Equals(object obj)
  {
    if (!(obj is Point2)) return false;
    return Equals((Point2)obj);
  }

  public override int GetHashCode()
  {
    unchecked { return (X * 397) ^ Y; }
  }

  public static bool operator ==(Point2 a, Point2 b) { return a.Equals(b); }
  public static bool operator !=(Point2 a, Point2 b) { return !a.Equals(b); }
}

public class Program
{
  public static void Main(string[] args)
  {
    Point2 a = new Point2(1, 2);
    Point2 b = new Point2(1, 2);
    Console.WriteLine("Struct value equality: " + (a == b)); // true
  }
}

값 객체를 키로 사용하기

using System;
using System.Collections.Generic;

public sealed class Email : IEquatable<Email>
{
  public string Address { get; private set; }
  public Email(string address)
  {
    if (string.IsNullOrEmpty(address)) throw new ArgumentException("address");
    Address = address.Trim().ToLowerInvariant();
  }

  public bool Equals(Email other)
  {
    if (object.ReferenceEquals(other, null)) return false;
    return Address == other.Address;
  }

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

  public override int GetHashCode()
  {
    return Address == null ? 0 : Address.GetHashCode();
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Dictionary<Email, string> owners = new Dictionary<Email, string>();
    owners[new Email("User@Mail.com")] = "Ada";
    Console.WriteLine(owners.ContainsKey(new Email("user@mail.com"))); // true
  }
}

동등성 체크리스트

레코드와 유사한 동등성 요구 사항

복습