Late Binding means compiler doesn't have any prior knowledge
about COM's methods and properties and it is delayed until
runtime. Actually program learns the addresses of methods
and properties at execution time only i.e. when those
methods and properties are invoked. Late bound code
typically refers client objects through generic data types
like 'object' and relies heavily on runtime to dynamically
locate method addresses. We do late binding in C# through
reflection. Reflection is a way to determine the type or
information about the classes or interfaces.

Polymorphism is the way of achieving late binding in csharp.
class A{}
class B:A{}
class Main
{
A a=new B();
}

Its using Virtual functions.
When compiler encounters virtual keyword in an function 
defination, instead of binding to the function directly, 
the compiler writes a bit of dispatch code that at runtime 
will look at calling objects realtype and calls the 
function accordingly.

EX.

class baseClass
{

  protected virtual void PrintMessage()
   {
     Console.WriteLine("Hi From Base Class");
   }
}

class derivedClass : baseClass
{
   protected override void PrintMessage()
   {
     Console.WriteLine("Hi From Derived Class");
   }

}

public static void Main()
{
  baseClass b = new baseClass();
  baseClass bd = new derivedClass();

  b.PrintMessage(); // prints "Hi From Base Class"
  bd.PrintMessage(); // prints "Hi From Derived Class"
}

Here the runtime detects the correct type of object stored 
in bd i.e. derivedClass and calls dericedClass 
implementation of PrintMessage().

We can achive late binding through operator loading and 
method ovealoading.