Quando e perché utilizzare le classi annidate?

La caratteristica principale delle classi nidificate è che possono accedere ai membri privati della classe esterna pur avendo la piena potenza di una classe stessa. Inoltre possono essere private, il che consente di incapsulare in modo piuttosto potente in determinate circostanze:

Qui blocchiamo completamente il setter alla fabbrica poiché la classe è privata, nessun consumatore può abbatterlo e accedere al setter e possiamo controllare completamente ciò che è permesso.

public interface IFoo 
{
    int Foo{get;}      
}
public class Factory
{
    private class MyFoo : IFoo
    {
        public int Foo{get;set;}
    }
    public IFoo CreateFoo(int value) => new MyFoo{Foo = value};
}

Oltre a ciò è utile per l'implementazione di interfacce di terze parti in un ambiente controllato in cui possiamo ancora accedere ai membri privati.

Se per esempio fornissimo un'istanza di qualche interfaccia ad un altro oggetto, ma non vogliamo che la nostra classe principale la implementasse, potremmo farla implementare da una classe interna.

public class Outer
{
    private int _example;
    private class Inner : ISomeInterface
    {
        Outer _outer;
        public Inner(Outer outer){_outer = outer;}
        public int DoStuff() => _outer._example;
    }
    public void DoStuff(){_someDependency.DoBar(new Inner(this)); }
}

Tipicamente, una classe nidificata N viene creata all'interno di una classe C ogni volta che C ha bisogno di usare qualcosa internamente che non dovrebbe mai essere (direttamente) usato al di fuori di C, e per qualsiasi ragione che qualcosa debba essere un nuovo tipo di oggetto piuttosto di un tipo esistente.

Credo che questo spesso avvenga implementando un metodo che restituisce un oggetto che implementa un'interfaccia, e vogliamo mantenere il tipo concreto di quell'oggetto nascosto perché non sarà utile da nessun'altra parte.

L'implementazione di IEnumerable è un buon esempio di questo:

class BlobOfBusinessData: IEnumerable<BusinessDatum>
{
    public IEnumerator<BusinessDatum> GetEnumerator()
    {
         return new BusinessDatumEnumerator(...);
    }

    class BusinessDatumEnumerator: IEnumerator<BusinessDatum>
    {
        ...
    }
}

Semplicemente non c'è motivo per nessuno al di fuori di BlobOfBusinessData di conoscere o preoccuparsi del concreto tipo BusinessDatumEnumerator , quindi dovremmo tenerlo dentro BlobOfBusinessData .

_{Questo non voleva essere un esempio di "best-practice" su come implementare correttamente IEnumerable , solo il minimo indispensabile per ottenere l'idea, quindi ho omesso cose come un metodo IEnumerable.GetEnumerator() esplicito .}