"Const correttezza" in C #

Question

Il punto di correttezza const è quello di essere in grado di fornire una vista di un'istanza che non può essere modificata o cancellata dall'utente. Il compilatore supporta ciò sottolineando quando si interrompe la costanza all'interno di una funzione const o si tenta di utilizzare una funzione non const di un oggetto const. Quindi, senza copiare l'approccio const, esiste una metodologia che posso usare in C # che ha gli stessi fini?

Sono consapevole dell'immutabilità, ma ciò non porta realmente agli oggetti contenitore per citarne solo un esempio.

Answer 1

Ho riscontrato questo problema anche molte volte e ho finito per usare le interfacce.

Penso che sia importante abbandonare l'idea che C # sia qualsiasi forma, o persino un'evoluzione di C ++. Sono due lingue diverse che condividono quasi la stessa sintassi.

Di solito esprimo "const correttezza" in C # definendo una vista di sola lettura di una classe:

public interface IReadOnlyCustomer
{
    String Name { get; }
    int Age { get; }
}

public class Customer : IReadOnlyCustomer
{
    private string m_name;
    private int m_age;

    public string Name
    {
        get { return m_name; }
        set { m_name = value; }
    }

    public int Age
    {
        get { return m_age; }
        set { m_age = value; }
    }
}

Answer 2

Per ottenere il vantaggio della costanza (o purezza in termini di programmazione funzionale), dovrai progettare le tue classi in modo che siano immutabili, proprio come la classe String di c #.

Questo approccio è molto meglio del semplice contrassegno di un oggetto come di sola lettura, poiché con le classi immutabili è possibile passare facilmente i dati in ambienti multi-tasking.

Answer 3

Volevo solo notare che molti dei contenitori System.Collections.Generics hanno un metodo AsReadOnly che ti restituirà una collezione immutabile.

Answer 4

C # non ha questa funzionalità. Puoi passare argomento per valore o per riferimento. Il riferimento stesso è immutabile se non si specifica ref . Ma i dati di riferimento non sono immutabili. Quindi devi stare attento se vuoi evitare effetti collaterali.

MSDN:

Parametri di passaggio

Answer 5

Le interfacce sono la risposta e in realtà sono più potenti di " const " in C ++. const è una soluzione unica per tutti i problemi in cui "const" è definito come "non imposta membri o chiama qualcosa che imposta membri". Questa è una buona scorciatoia per la costanza in molti scenari, ma non tutti. Ad esempio, si consideri una funzione che calcola un valore basato su alcuni membri ma memorizza anche nella cache i risultati. In C ++ è considerato non const, sebbene dal punto di vista dell'utente sia essenzialmente const.

Le interfacce ti offrono maggiore flessibilità nella definizione del sottoinsieme specifico di funzionalità che desideri fornire dalla tua classe. Vuoi costanza? Basta fornire un'interfaccia senza metodi di mutazione. Vuoi consentire l'impostazione di alcune cose ma non di altre? Fornisci un'interfaccia con questi metodi.

Answer 6

D'accordo con alcuni degli altri guardare all'uso dei campi di sola lettura che si inizializza nel costruttore, per creare oggetti immutabili.

    public class Customer
    {
    private readonly string m_name;
    private readonly int m_age;

    public Customer(string name, int age)
    {
        m_name = name;
        m_age = age;
    }

    public string Name
    {
        get { return m_name; }
    }

    public int Age
    {
        get { return m_age; }
    }
  }

In alternativa puoi anche aggiungere un ambito di accesso alle proprietà, ad esempio set pubblico e protetto?

    public class Customer
    {
    private string m_name;
    private int m_age;

    protected Customer() 
    {}

    public Customer(string name, int age)
    {
        m_name = name;
        m_age = age;
    }

    public string Name
    {
        get { return m_name; }
        protected set { m_name = value; }
    }

    public int Age
    {
        get { return m_age; }
        protected set { m_age = value; }
    }
  }

Answer 7

• La parola chiave const può essere utilizzata per compilare costanti di tempo come tipi e stringhe primitivi
• La parola chiave di sola lettura può essere utilizzata per costanti di runtime come tipi di riferimento

Il problema con di sola lettura è che consente solo al riferimento (puntatore) di essere costante. La cosa a cui si fa riferimento (indicato) può ancora essere modificata. Questa è la parte difficile ma non c'è modo di aggirarla. Implementare oggetti costanti significa renderli non esposti a metodi o proprietà mutabili, ma questo è imbarazzante.

Vedi anche C # efficace: 50 modi specifici per migliorare il tuo C # (Articolo 2 - Preferisci solo lettura a cost.)