ValueObject.cs

//From Pluralsight Domain-Driven Design Fundamentals Course (bit.ly/PS-DDD)

using System;
using System.Collections.Generic;
using System.Reflection;

//this base class comes from Jimmy Bogard
//http://grabbagoft.blogspot.com/2007/06/generic-value-object-equality.html

namespace Shared {
  public abstract class ValueObject<T> : IEquatable<T>
    where T : ValueObject<T> {
    public virtual bool Equals(T other) {
      if (other == null)
        return false;

      Type t = GetType();
      Type otherType = other.GetType();

      if (t != otherType)
        return false;

      FieldInfo[] fields = t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);

      foreach (FieldInfo field in fields) {
        object value1 = field.GetValue(other);
        object value2 = field.GetValue(this);

        if (value1 == null) {
          if (value2 != null)
            return false;
        }
        else if (!value1.Equals(value2))
          return false;
      }

      return true;
    }

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

      var other = obj as T;

      return Equals(other);
    }

    public override int GetHashCode() {
      IEnumerable<FieldInfo> fields = GetFields();

      int startValue = 17;
      int multiplier = 59;

      int hashCode = startValue;

      foreach (FieldInfo field in fields) {
        object value = field.GetValue(this);

        if (value != null)
          hashCode = hashCode*multiplier + value.GetHashCode();
      }

      return hashCode;
    }

    private IEnumerable<FieldInfo> GetFields() {
      Type t = GetType();

      var fields = new List<FieldInfo>();

      while (t != typeof (object)) {
        fields.AddRange(t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));

        t = t.BaseType;
      }

      return fields;
    }

    public static bool operator ==(ValueObject<T> x, ValueObject<T> y) {
      return x.Equals(y);
    }

    public static bool operator !=(ValueObject<T> x, ValueObject<T> y) {
      return !(x == y);
    }
  }
}