CSHARP-4432: POC of standard implementations of Equals.

src/MongoDB.Bson/EqualsPoc/EqualsOnlyBaseClass.cs

@@ -0,0 +1,31 @@
+namespace MongoDB.Bson.EqualsPoc
+{
+    internal class EqualsOnlyBaseClass
+    {
+        public object _ref1;
+        public int _value1;
+
+        public EqualsOnlyBaseClass(object ref1, int value1)
+        {
+            _ref1 = ref1;
+            _value1 = value1;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (object.ReferenceEquals(obj, null)) { return false; }
+            if (object.ReferenceEquals(this, obj)) { return true; }
+            return
+                GetType().Equals(obj.GetType()) &&
+                obj is EqualsOnlyBaseClass other &&
+                object.Equals(_ref1, other._ref1) &&
+                _value1.Equals(other._value1);
+        }
+
+        public override int GetHashCode() => 0; // implement as appropriate
+
+        // optionally implement == and !=
+        public static bool operator ==(EqualsOnlyBaseClass lhs, EqualsOnlyBaseClass rhs) => object.Equals(lhs, rhs);
+        public static bool operator !=(EqualsOnlyBaseClass lhs, EqualsOnlyBaseClass rhs) => !(lhs == rhs);
+    }
+}

src/MongoDB.Bson/EqualsPoc/EqualsOnlyDerivedClass.cs

@@ -0,0 +1,28 @@
+namespace MongoDB.Bson.EqualsPoc
+{
+    internal class EqualsOnlyDerivedClass : EquatableBaseClass
+    {
+        private object _ref2;
+        private int _value2;
+
+        public EqualsOnlyDerivedClass(object ref1, int value1, object ref2, int value2)
+            : base(ref1, value1)
+        {
+            _ref2 = ref2;
+            _value2 = value2;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (object.ReferenceEquals(obj, null)) { return false; }
+            if (object.ReferenceEquals(this, obj)) { return true; }
+            return
+                base.Equals(obj) &&
+                obj is EqualsOnlyDerivedClass other &&
+                object.Equals(_ref2, other._ref2) &&
+                _value2.Equals(other._value2);
+        }
+
+        public override int GetHashCode() => 0; // implement as appropriate
+    }
+}

src/MongoDB.Bson/EqualsPoc/EqualsOnlyNonPolymorphicClass.cs

@@ -0,0 +1,30 @@
+namespace MongoDB.Bson.EqualsPoc
+{
+    internal sealed class EqualsOnlyNonPolymorphicClass
+    {
+        private object _ref;
+        private int _value;
+
+        public EqualsOnlyNonPolymorphicClass(object @ref, int value)
+        {
+            _ref = @ref;
+            _value = value;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (object.ReferenceEquals(obj, null)) { return false; }
+            if (object.ReferenceEquals(this, obj)) { return true; }
+            return
+                obj is EqualsOnlyNonPolymorphicClass other &&
+                object.Equals(_ref, other._ref) &&
+                _value.Equals(other._value);
+        }
+
+        public override int GetHashCode() => 0; // implement as appropriate
+
+        // optionally implement == and !=
+        public static bool operator ==(EqualsOnlyNonPolymorphicClass lhs, EqualsOnlyNonPolymorphicClass rhs) => object.Equals(lhs, rhs);
+        public static bool operator !=(EqualsOnlyNonPolymorphicClass lhs, EqualsOnlyNonPolymorphicClass rhs) => !(lhs == rhs);
+    }
+}

src/MongoDB.Bson/EqualsPoc/EquatableBaseClass.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace MongoDB.Bson.EqualsPoc
+{
+    internal class EquatableBaseClass : IEquatable<EquatableBaseClass>
+    {
+        public object _ref1;
+        public int _value1;
+
+        public EquatableBaseClass(object ref1, int value1)
+        {
+            _ref1 = ref1;
+            _value1 = value1;
+        }
+
+        public override bool Equals(object obj) =>
+            Equals(obj as EquatableBaseClass);
+
+        public bool Equals(EquatableBaseClass other)
+        {
+            if (object.ReferenceEquals(other, null)) { return false; }
+            if (object.ReferenceEquals(this, other)) { return true; }
+            return
+                GetType().Equals(other.GetType()) &&
+                object.Equals(_ref1, other._ref1) &&
+                _value1.Equals(other._value1);
+        }
+
+        public override int GetHashCode() => 0; // implement as appropriate
+
+        // optionally implement == and !=
+        public static bool operator ==(EquatableBaseClass lhs, EquatableBaseClass rhs) => object.Equals(lhs, rhs);
+        public static bool operator !=(EquatableBaseClass lhs, EquatableBaseClass rhs) => !(lhs == rhs);
+    }
+}

src/MongoDB.Bson/EqualsPoc/EquatableDerivedClass.cs

@@ -0,0 +1,32 @@
+using System;
+
+namespace MongoDB.Bson.EqualsPoc
+{
+    internal class EquatableDerivedClass : EquatableBaseClass, IEquatable<EquatableDerivedClass>
+    {
+        private object _ref2;
+        private int _value2;
+
+        public EquatableDerivedClass(object ref1, int value1, object ref2, int value2)
+            : base(ref1, value1)
+        {
+            _ref2 = ref2;
+            _value2 = value2;
+        }
+
+        public override bool Equals(object obj) =>
+            Equals(obj as EquatableDerivedClass);
+
+        public bool Equals(EquatableDerivedClass other)
+        {
+            if (object.ReferenceEquals(other, null)) { return false; }
+            if (object.ReferenceEquals(this, other)) { return true; }
+            return
+                 base.Equals(other) &&
+                object.Equals(_ref2, other._ref2) &&
+                _value2.Equals(other._value2);
+        }
+
+        public override int GetHashCode() => 0; // implement as appropriate
+    }
+}

src/MongoDB.Bson/EqualsPoc/EquatableNonPolymorphicClass.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace MongoDB.Bson.EqualsPoc
+{
+    internal sealed class EquatableNonPolymorphicClass : IEquatable<EquatableNonPolymorphicClass>
+    {
+        private object _ref;
+        private int _value;
+
+        public EquatableNonPolymorphicClass(object @ref, int value)
+        {
+            _ref = @ref;
+            _value = value;
+        }
+
+        public override bool Equals(object obj) =>
+            Equals(obj as EquatableNonPolymorphicClass);
+
+        public bool Equals(EquatableNonPolymorphicClass other)
+        {
+            if (object.ReferenceEquals(other, null)) { return false; }
+            if (object.ReferenceEquals(this, other)) { return true; }
+            return
+                object.Equals(_ref, other._ref) &&
+                _value.Equals(other._value);
+        }
+
+        public override int GetHashCode() => 0; // implement as appropriate
+
+        // optionally implement == and !=
+        public static bool operator ==(EquatableNonPolymorphicClass lhs, EquatableNonPolymorphicClass rhs) => object.Equals(lhs, rhs);
+        public static bool operator !=(EquatableNonPolymorphicClass lhs, EquatableNonPolymorphicClass rhs) => !(lhs == rhs);
+    }
+}

src/MongoDB.Bson/EqualsPoc/EquatableStruct.cs

@@ -0,0 +1,32 @@
+using System;
+
+namespace MongoDB.Bson.EqualsPoc
+{
+    internal struct EquatableStruct : IEquatable<EquatableStruct>
+    {
+        private object _ref;
+        private int _value;
+
+        public EquatableStruct(object @ref, int value)
+        {
+            _ref = @ref;
+            _value = value;
+        }
+
+        public override bool Equals(object obj) =>
+            obj is EquatableStruct other && Equals(other);
+
+        public bool Equals(EquatableStruct other)
+        {
+            return
+                object.Equals(_ref, other._ref) &&
+                _value.Equals(other._value);
+        }
+
+        public override int GetHashCode() => 0; // implement as appropriate
+
+        // optionally implement == and !=
+        public static bool operator ==(EquatableStruct lhs, EquatableStruct rhs) => lhs.Equals(rhs);
+        public static bool operator !=(EquatableStruct lhs, EquatableStruct rhs) => !(lhs == rhs);
+    }
+}