The System.Object class is the root of the class hierarchy and serves as the base class for every other class. The C# object type aliases System.Object. System.Object provides a handful of useful methods that are present on all objects, and whose signatures are listed in the following fragment of the System.Object class definition:

public class Object {
   public Object( ) {...}
   public virtual bool Equals(object o) {...}
   public virtual int GetHashCode( ){...}
   public Type GetType( ){...}
   public virtual string ToString( ) {...}
   protected virtual void Finalize( ) {...}
   protected object MemberwiseClone( ) {...}
}

public class Point3D {
  public int x, y, z;
  public Point3D(int x, int y, int z) {
    this.x=x; this.y=y; this.z=z; // Initialize data
  }
  public override bool Equals(object o) {
    if (!(o is Point3D)) // Check for type equivalence
      return false;
    return (this==(Point3D)o); // Implemented by operator==
  }
  public static bool operator !=(Point3D lhs, Point3D rhs) {
    return (!(lhs==rhs)); // Implemented by operator==
  }
  public static bool operator ==(Point3D lhs, Point3D rhs) {
    return ((rhs.x==lhs.x) && (rhs.y==lhs.y) && (rhs.z==lhs.z));
  }
  public override int GetHashCode( ){
    return x^y^z;
  }
  public override string ToString( ) {
    return String.Format("[{0},{1},{2}]", x, y, z);
  }
}

using System;
using System.Collections;
public class Point3D {...}
class TestPoint3D {
  static void Main( ) {
    // Uses ToString, prints "p1=[1,1,1] p2=[2,2,2] p3=[2,2,2]"
    Point3D p1 = new Point3D(1,1,1);
    Point3D p2 = new Point3D(2,2,2);
    Point3D p3 = new Point3D(2,2,2);
    Console.WriteLine("p1={0} p2={1} p3={2}", p1, p2, p3);

    // Tests for equality to demonstrate Equals, == & !=
    int i = 100;
    Console.WriteLine(p1.Equals(i)); // Prints "False"
    Console.WriteLine(p1==p2); // Prints "False"
    Console.WriteLine(p2==p3); // Prints "True"

    // Use a hashtable to store points (uses GetHashCode)
    Hashtable ht = new Hashtable( );
    ht["p1"] = p1; 
    ht["p2"] = p2;
    ht["p3"] = p3;

    // Prints "p2=[2,2,2] p3=[2,2,2] p1=[1,1,1]"
    foreach (DictionaryEntry de in ht)
      Console.Write("{0}={1} ", de.Key, de.Value);  
  }
}

public interface ICloneable {
  object Clone( );
}

ICloneable allows classes or structs instances to be cloned. It contains a single method named Clone that returns a copy of the instance. When implementing this interface your Clone method can either simply return this.MemberwiseClone( ), which performs a shallow copy (the fields are copied directly), or you can perform a custom deep copy, where you clone individual fields in the class or struct. The following example is the simplest implementation ICloneable:

public class Foo : ICloneable {
      public object Clone( ) {
       return this.MemberwiseClone( );
   }
}

interface IComparable {
  int CompareTo(object o);
}

IComparable is implemented by types that have instances that can be ordered (see Section 3.4). It contains a single method named CompareTo that:

This interface is implemented by all numeric types, string, DateTime, etc. It may also be implemented by custom classes or structs to provide comparison semantics. For example:

using System;
using System.Collections;
class MyType : IComparable {
  public int x;
  public MyType(int x) {
    this.x = x;
  }
  public int CompareTo(object o) {
    return x -((MyType)o).x;
  }
}
class Test {
  static void Main( ) {
    ArrayList a = new ArrayList( );
    a.Add(new MyType(42));
    a.Add(new MyType(17));
    a.Sort( );
    foreach(MyType t in a)
      Console.WriteLine(((MyType)t).x);
   }
}

public interface IFormattable {
  string Format(string format, IServiceObjectProvider sop);
}

The IFormattable interface is implemented by types that have formatting options for converting their value to a string representation. For instance, a decimal may be converted to a string representing currency, or a string which uses a comma for a decimal point. The formatting options are specified by the format string (see Section 3.3.4). If an IServiceObjectProvider interface is supplied, it specifies the specific culture to be used for the conversion.

IFormattable is commonly used when calling one of the String class Format methods (see Section 3.3).

All the common types (int, string, DateTime, etc.) implement this interface, and you should implement it on your own types if you want them to be fully supported by the String class when formatting.