Incapsulando una classe in un'altra classe per nascondere le sue proprietà e dettagli esposti

Ho essenzialmente una classe del modello di dati che rappresenta una struttura dati XML che usiamo per modellare il nostro sistema. La classe del modello si trova in un progetto condiviso che viene utilizzato da numerose soluzioni diverse per generare una struttura di dati XML comune da utilizzare con qualsiasi numero di applicazioni.

In una delle applicazioni in cui sono coinvolto, abbiamo fornito una classe wrapper per una di queste classi di modelli XML poiché desideriamo eseguire un numero di operazioni sui dati del modello. Tuttavia, anche altre parti del mio programma devono accedere a questi dati per i calcoli che devono eseguire.

Al momento ho questa configurazione (nota che questo è solo un esempio ma rappresenta la mia struttura di codice)

1)

public class ModelWrapper
{
    private readonly ModelClass _model;

    public int PropertyX 
    { 
      get 
      { 
         return _model.PropertyX;
      }
    }

    public ModelWrapper(ModelClass model)
    {
       _model = model;  
    }

    // and other methods we need that uses the properties we have exposed e.g
    public void PerformOperation()
    {
        if(this.PropertyX > 10)
           // do something
        else
           // do something else
    }
}

Questo sembra ok, ma ho incontrato il problema in cui io o un altro programmatore abbiamo usato in modo non strettamente la variabile _model privata. Mi sembra che potremmo finire con problemi nascosti in questo metodo nel fatto che ci sono due modi per ottenere gli stessi dati e se mettiamo un po 'di logica nel pubblico esposto otteniamo le proprietà, allora potremmo perdere che se facciamo riferimento direttamente la variabile privata.

L'altra alternativa a cui pensavo era

2)

public class ModelWrapper
{
    public readonly int PropertyX;

    public ModelWrapper(ModelClass model)
    {
       PropertyX = model.PropertyX;  
       // set other properties here we wish to expose on the ModelClass ...
    }

    // and other methods we need that uses the properties we have exposed e.g
    public void PerformOperation()
    {
        if(this.PropertyX > 10)
           // do something
        else
           // do something else
    }
}

O un'altra opzione dopo aver letto alcuni post su questo è:

3)

public class ModelWrapper
{
    private readonly int _propertyX;
    public int PropertyX 
    { 
      get { return _propertyX; }
    }

    public ModelWrapper(ModelClass model)
    {
       _propertyX = model.PropertyX;  
    }

    // and other methods we need that uses the properties we have exposed e.g
    public void PerformOperation()
    {
        if(this.PropertyX > 10)
           // do something
        else
           // do something else
    }
}

Perché farlo? Ho pensato che sarebbe una buona idea nascondere il modello dal nostro codice in quanto volevamo comunque una classe wrapper per fare i metodi, quindi perché esporre il modello? Ho pensato che potrebbe essere eccessivo, ma salva in altre parti del codice qualcosa di simile a ModelWrapper.Model.PropertyX etc

Quindi alla domanda. Quale metodo se nessuno sarebbe una soluzione migliore. È eccessivo o ci sono migliori pratiche là fuori per questo?

EDIT: Ho aggiunto un'altra opzione (3) in quanto non è necessario impostare le proprietà che sto esponendo, quindi non volevo necessariamente avere un set privato poiché è stato impostato solo nel costruttore. Quindi la variabile privata readonly utilizzata nella parte get della proprietà esposta?

Ho anche trovato una domanda di overflow dello stack su questo link ma non è necessario dire quale sia la soluzione migliore / preferita con le attuali limitazioni di c #.

Qualche idea sulle 3 implementazioni sulla pratica migliore?