The difference it terms of functionality is shown in the following examples:

object a = "45"; // a is of type String
int b = (int)a; // InvalidCastException is thrown
int c= Convert.ToInt32(a); // c will contain 45

string d = "45";
int e = (int)d; // compiler error
int f = Convert.ToInt32(d); // f will contain 45

string g = "test";
int h = Convert.ToInt32(g); // FormatException is thrown because
Convert.ToInt32 will attempt to call Int32.Parse

long i = long.MaxValue;
unchecked
{
int j = (int)i; // OverflowException is thrown;
int k = Convert.ToInt32(i); // OverflowException is thrown
}
checked
{
int l = (int)d; // f will contain -1
int m = Convert.ToInt32(i); // OverflowException is thrown
(checked/unchecked doesn't affect Convet.ToXXX methods)
}

Depending on which overload of Convert.ToXXX you are calling, the
performance can be a bit slower than type casting (in case of the overload
that takes an object as a parameter) and functionality can be different, but
in many cases performance should be the same assuming that the JIT compiler
will inline the Convert.ToXXX calls.

Regards,
Sherif

Well, casting is done by the compiler itself whereas Convert.To.... is a
method call. Performance-wise, the cast is generally preferred.

Convert.To, I find, is generally more handy for converting strings to
numbers. I rarely use it for anything else. I don't know that I've ever used
it to cast from one number to another. I don't really see that there's any
advantage and the casting looks cleaner and easier to read, in my opinion.

(int) <double> is a LOT faster than Convert.ToInt32 (<double>)

YMMV with other types of parameters.

Hilton