«Const correctness» en C #

Question

Le point de const-correct est de pouvoir fournir une vue d'une instance qui ne peut être ni modifiée ni supprimée par l'utilisateur. Le compilateur prend cela en charge en indiquant lorsque vous séparez la constness d'une fonction const ou essayez d'utiliser une fonction non-const d'un objet const. Donc, sans copier l'approche const, y a-t-il une méthodologie que je peux utiliser en C # qui a les mêmes fins?

Je suis conscient de l'immuabilité, mais cela ne concerne pas vraiment les objets conteneur pour ne citer qu'un exemple.

Answer 1

J'ai souvent rencontré ce problème et j'ai fini par utiliser des interfaces.

Je pense qu'il est important de laisser tomber l'idée que C # est une forme, voire une évolution du C ++. Ce sont deux langues différentes qui partagent presque la même syntaxe.

J'exprime généralement 'const correctness' en C # en définissant une vue en lecture seule d'une 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

Pour bénéficier de la const-folie (ou de la pureté en termes de programmation fonctionnelle), vous devez concevoir vos classes de manière à ce qu’elles soient immuables, tout comme la classe String de c #.

Cette approche est bien meilleure que de simplement marquer un objet en lecture seule, car avec des classes immuables, vous pouvez facilement transmettre des données dans des environnements multitâches.

Answer 3

Je voulais simplement noter pour vous que de nombreux conteneurs System.Collections.Generics ont une méthode AsReadOnly qui vous rendra une collection immuable.

Answer 4

C # n’a pas cette fonctionnalité. Vous pouvez passer argument par valeur ou par référence. La référence elle-même est immuable sauf si vous spécifiez ref . Mais les données référencées ne sont pas immuables. Vous devez donc faire attention si vous voulez éviter les effets secondaires.

MSDN:

Paramètres de transmission

Answer 5

Les interfaces sont la solution et sont en réalité plus puissantes que "const". en C ++. const est une solution unique au problème où & const; const " est défini comme "ne définit pas de membres ou n'appelle pas quelque chose qui définit les membres". C'est un bon raccourci pour const-ness dans de nombreux scénarios, mais pas tous. Par exemple, considérons une fonction qui calcule une valeur en fonction de certains membres mais met également en cache les résultats. En C ++, cela est considéré comme non-constant, même si du point de vue de l'utilisateur, il s'agit essentiellement de const.

Les interfaces vous offrent plus de flexibilité pour définir le sous-ensemble de fonctionnalités que vous souhaitez fournir à partir de votre classe. Voulez-vous const-ness? Fournissez simplement une interface sans méthode de mutation. Voulez-vous permettre de régler certaines choses mais pas d'autres? Fournissez une interface avec juste ces méthodes.

Answer 6

Acceptez, comme d’autres, d’utiliser des champs en lecture seule que vous initialisez dans le constructeur pour créer des objets immuables.

    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; }
    }
  }

Vous pouvez également ajouter une étendue d'accès aux propriétés, c'est-à-dire public get et protected set?

    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

• Le mot clé const peut être utilisé pour les constantes de temps de compilation telles que les types primitifs et les chaînes
• Le mot clé readonly peut être utilisé pour les constantes d'exécution telles que les types de référence

Le problème avec en lecture seule est qu’il permet uniquement à la référence (pointeur) d’être constante. La chose référencée peut toujours être modifiée. C'est la partie la plus délicate mais il n'y a pas moyen de la contourner. Implémenter des objets constants signifie qu’ils ne doivent exposer aucune méthode ou propriété mutable, mais que cela est difficile.

Voir aussi C # efficace: 50 façons d'améliorer votre C # (Élément 2 - Préférer en lecture seule à const.)