Shallow Copy: The value type objects/variables do not reflect the changes done to either of the objects, as they are stored in Stack.The core difference here is the reference type variables/objects will reflect the changes done to both the objects copied.

Deep Copy: The reference object/variables do not reflect the changes if any of the object is changed.  This is basically a seprate entity of the same object which can only be possible when a copy of internal semantics of done of an object but it is made to point to a separate memory location.  This is to be implemented by the application user and can be done only by implmeneting ICloneable.  So ICloneable can be used to implement both shallow as well as deep copy.  It is on the discretion of what your application is requiring. 

Array.Clone/List.Clone/MemberwiseClone all create a shallow copy.  Do not get confused with this.

Sample Code:

/// <summary>
    /// For Deep copying of the reference type variable/objects we will create a new instance and then copy over the data into it.
    /// </summary>
        [Serializable]
        public class MyBaseClass:ICloneable
        {
            public static string CompanyName = “My Company”;
            public int age;
            public string name;
           
            //Reference variables/Objects
            //List<string> lst = new List<string>(){“a”,”b”};
            public string[] arr = new string[]{“Test1″,”Test2″};
           
            #region Implementation of ICloneable: Using Serialization

            public object  Clone()
            {
                //——————————————————–(1) Using Serialization—————————————–
                //var ms = new MemoryStream();
                //var bf = new BinaryFormatter();
                //bf.Serialize(ms, this);
                //ms.Position = 0;
                //object obj = bf.Deserialize(ms);
                //ms.Close();
                //return obj;
                //——————————————————————-(2) Without using Serialization———————
                MyBaseClass obj = this.MemberwiseClone() as MyBaseClass;
                obj.arr = new string[arr.Length];                      
                obj.arr = (string[])this.arr.Clone();
                return obj;
                             
            }

» Read more: Shallow Copy Vs Deep Copy

A way of casting in C# language is to use the IS operator. The is operator checks
whether an object is compatible with a given type, and the result of the evaluation is a
Boolean: true or false. The is operator will never throw an exception. The following code
demonstrates:
Object o = new Object();
Boolean b1 = (o is Object); // b1 is true.
Boolean b2 = (o is Employee); // b2 is false.

If the object reference is null, the is operator always returns false because there is no object
available to check its type.

The is operator is typically used as follows:
if (o is Employee) {
Employee e = (Employee) o;
// use e within the remainder of the ‘if ‘ statement.
}
In this code, the CLR is actually checking the object’s type twice. The is operator first checks
to see if o is compatible with the Employee type. If it is, inside the if statement, the CLR again
verifies that o refers to an Employee when performing the cast. The CLR’s type checking
improves security, but it certainly comes at a performance cost, because the CLR must determine
the actual type of the object referred to by the variable (o), and then the CLR must walk the
inheritance hierarchy, checking each base type against the specified type (Employee).

 C# offers a way to simplify this code and improve
its performance by providing an AS operator:

Employee e = o as Employee;
if (e != null) {
// Use e within the ‘if’ statement.
}
In this code, the CLR checks if o is compatible with the Employee type, and if it is, as returns
a non-null reference to the same object. If o is not compatible with the Employee type, the as
operator returns null. Notice that the as operator causes the CLR to verify an object’s type
just once. The if statement simply checks whether e is null; this check can be performed
faster than verifying an object’s type.
The as operator works just as casting does except that the as operator will never throw
an exception. Instead, if the object can’t be cast, the result is null. You’ll want to check to
see whether the resulting reference is null, or attempting to use the resulting reference will
cause a System.NullReferenceException to be thrown. The following code demonstrates:

Object o = new Object(); // Creates a new Object object
Employee e = o as Employee; // Casts o to an Employee
// The cast above fails: no exception is thrown, but e is set to null.
e.ToString(); // Accessing e throws a NullReferenceException