L'overload degli operatori è un tecnica per dare un significato ad una espressione matematico/logica, quando gli operandi siano tipi custom creati dallo sviluppatore. Supponiamo quindi di avere una classe Alfa contenente un numero X e che l'operazione:

Alfa a, b;
a = new Alfa() { X = 10 };
b = new Alfa() { X = 20 };
Console.WriteLine((a + b).X);

debba stampare 30, ovvero la somma dei contenuti delle property X. Per come stanno le cose ora, c'è sicuramente un errore di compilazione, poichè non ha senso "sommare" due oggetti Alfa. Ma se noi in qualche modo dicessimo che la somma tra due oggetti di tipo Alfa è un terzo oggetto Alfa con valore corrispondente alla somma dei valori dei due operandi, allora avrebbe senso. E come si fa?
class Alfa
{
    public int X { get; set; }
    public static Alfa operator +(Alfa a, Alfa b)
    {
        return new Alfa() { X = a.X + b.X };
    }
}

E tuttavia sconsigliato procedere in questo modo (lasciato in "onore" degli sviluppatori C++), poichè non fa parte del CLS. Infatti si consiglia di implementare un metodo della classe che abbia la semantica desiderata.

Operatori di conversione
Sarebbe bello avere due classi e definire il casting da una istanza di una classe ad un'altra, senza provocare un errore di compilazione ed anzi, ottenendo la semantica voluta? Si può, ma partiamo dalle definzioni:

//Casting implicito
int a=20;
long b=a;
//Casting esplicito
long a=30;
int b=(int)a;

Allo stesso modo, se definiamo una classe Alfa e vogliamo che sia "castabile" ad un intero, potremmo fare così, partendo dall'esempio di prima:
class Alfa
{
    public int X { get; set; }
    public static Alfa operator +(Alfa a, Alfa b)
    {
        return new Alfa() { X = a.X + b.X };
    }
    public static implicit operator int(Alfa a)
    {
        return a.X;
    }
}

e dove ci interessa:
Alfa a, b;
a = new Alfa() { X = 10 };
b = new Alfa() { X = 20 };
int res = a + b;

senza provocare alcun errore di compilazione. Possiamo anche fare in modo che lo sviluppatore sia obbligato a fare il casting esplicito in questo modo:
int res = ((int)(a + b));

avendo l'accortezza di modificare il metodo di conversione così:
public static explicit operator int(Alfa a)
{
    return a.X;
}