Waarom zijn de trefwoorden ref en out geïntroduceerd voor referentietypen in C#?

Hoewel referentietypen worden doorgegeven via referentie (een kopie van de referentie wordt doorgegeven), maakt het gebruik van ref of out het mogelijk om de referentie zelf naar het object door te geven via referentie.

Dit kan nuttig zijn in de volgende gevallen:

• Wijzigen van de instantie van het object: stelt de methode in staat om te wijzigen naar welke instantie van het object de variabele-argument verwijst, door een nieuwe instantie toe te wijzen.
• Implementatie van TryParse-methoden: de methode retourneert een bool die aangeeft of de parsing succesvol was, en het resultaat wordt geschreven in het out-argument. Zonder out zou je een uitzondering moeten werpen bij mislukking (wat niet altijd wenselijk is), of een tuple retourneren.
• Efficiëntie (zelden, maar mogelijk): in sommige extreme gevallen, als het object erg groot is en vaak moet worden vervangen binnen de methode, kan het doorgeven via referentie (ref) iets efficiënter zijn dan het retourneren van een nieuw object (hoewel dit een zeldzaam scenario is).

Voorbeeld van het gebruik van ref om de instantie te vervangen:

public class MyClass
{
    public int Value { get; set; }
}

public void ReplaceObject(ref MyClass obj)
{
    obj = new MyClass { Value = 10 }; // Verandert de referentie waar `obj` naar verwijst
}

// ... elders in de code
MyClass instance = new MyClass { Value = 5 };
ReplaceObject(ref instance);
// Nu verwijst `instance` naar een nieuw object met Value = 10

Voorbeeld van het gebruik van out:

public bool TryParseInt(string s, out int result)
{
    // Parsing-logica
    if (int.TryParse(s, out result))
    {
        return true;
    }
    result = 0; // Standaardwaarde bij mislukking
    return false;
}

// ... elders in de code
int parsedValue;
if (TryParseInt("123", out parsedValue))
{
    // Succesvolle parsing
}