“const correctness” en C#

Le point de const-correct est d'être en mesure de fournir une vue d'une instance qui ne peuvent pas être modifiés ou supprimés par l'utilisateur. Le compilateur prend en charge ce en pointant du doigt lorsque vous cassez constness de l'intérieur d'une const fonction, ou essayez d'utiliser un non-const fonction de const objet. Donc, sans la copie de la const approche, est-il une méthodologie que je peux utiliser en C# qui a les mêmes objectifs?

Je suis conscient de l'immuabilité, mais qui n'a pas vraiment pour le conteneur d'objets pour n'en citer qu'un exemple.

Il y a une belle discussion sur les conceptions possibles pour readonly http://blogs.msdn.com/brada/archive/2004/02/04/67859.aspx
Alors que penser de la mise en œuvre de const_cast en C#?

InformationsquelleAutor tenpn | 2008-09-22

c#const-correctness theory

62

J'ai été confronté à ce problème, un grand nombre de fois trop et finit par l'utilisation d'interfaces.

Je pense qu'il est important d'abandonner l'idée que le C# est une forme, ou même d'une évolution du C++. Ils sont deux langues différentes qui partagent quasiment la même syntaxe.

J'ai l'habitude d'exprimer 'const correctness' en C# par la définition d'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; }
    }
}
```
- Ce n'est pas l'une de ces questions qui a une "réponse" en tant que tels, mais j'aime vraiment cette solution. Elle est élégante, peut s'adapter à beaucoup de situations, et il est rapide à écrire.
- Bien sûr, mais que faire si l'un de vos champs d'une Liste, ou un riche type. Votre solution se complique très vite.
- De retour interne d'une collection est considérée comme une mauvaise pratique. Vous pouvez soit revenir en lecture seule interface pour gérer cette liste en lecture seule ou d'une copie de la liste d'origine donc pas de mal peut être fait.
- c'est tout l'intérêt de la question. De retour interne d'une collection est une mauvaise pratique, car le monde extérieur pourrait modifier vos internes, en C++, qui est résolu avec l'utilisation de const: vous fournir une vue constante de la collection (impossible d'ajouter/retirer des éléments, n'offre qu'une vue constante de ses éléments) et en tant que tel, il est sûr (et un idiome commun). Pas besoin de travailler sur les interfaces ou autres astuces pour éviter extérieur code de changer votre intérieur.
- D'accord, la partie agréable de const exactitude, c'est qu'il est "transitive" dans un sens. Vous fournir une référence constante à un conteneur qui lui-même prend soin de seulement d'offrir constamment des points de vue de ses éléments, chacun de qui n'offre que de la constante de vues de ses éléments internes...
- N'oubliez pas que ce n'est qu'un jeté de la suppression de la lecture onli-ness - à savoir, (Customer) myCustomer. Encore, sans doute la meilleure solution, si vous vous comportez et ne jette pas comme ça 🙂
- Langues fournir ce genre de mécanismes comme une aide au développement, et non comme un moyen d'éviter inexpérimentés/mauvais programmeurs à faire les choses de la mauvaise façon. En C# vous parvenir d'une manière naturelle en utilisant des interfaces, alors qu'en C++ vous avez besoin d'un 'extra' fonctionnalité appelée 'const'. Elle regardait toujours, pour moi, que C++ est le seul à l'aide d'un "truc", et non pas l'inverse.
- Aussi, en utilisant un en lecture seule interface vous êtes déclarant explicitement vos intentions, c'est une décision de conception. Je ne me souviens pas combien de fois j'ai vissé les choses dû à oublier d'ajouter le "const" mot.
- Je suis d'accord que le mécanisme est une aide pour le développement, qui inclut la détection d'erreurs des développeurs expérimentés ou non. Je suis en désaccord que d'avoir à écrire en lecture seule interfaces est une meilleure solution en plusieurs motifs. Le premier point est que chaque fois que vous êtes d'écrire une classe en C++ vous sont implicitement la définition de la constante de l'interface: le sous-ensemble de membres déclarés const, sans le coût supplémentaire de la définition d'une interface séparée et nécessitant l'exécution de l'expédition. Qui est, la langue fournit un moyen simple de mettre en œuvre au moment de la compilation const-interfaces.
- Il est important de noter que le const-ness est une partie de la conception et il déclare l'intention tout aussi clairement que l'écriture externe const-interface. Aussi, const-interfaces peut être une tâche complexe s'il doit être traité manuellement, et peut nécessiter l'écriture presque autant d'interfaces que les classes sont présentes dans le composé de type. Qui nous emmène à votre dernière sentece: 'vis les choses à cause de l'oubli d'ajouter la const'. Il est plus facile d'obtenir utilisé pour ajouter de la const partout (coût de développement est faible) que de l'écrire en lecture seule interfaces pour chaque classe.
- Je ne suis pas contre le C++ 'const' mot-clé 🙂 j'aime la façon dont const-correct est réalisé en C# plus. Je pense que la quantité de mots que vous devez taper pour faire des choses ne peut jamais être un facteur important. Comme une note, dans chaque langue moderne/IDE que je sais que vous pouvez extraire une lecture seule interface avec quelques clics de souris.
- Si vous détenez un assez grand mutable objet à l'intérieur de votre propre objet, comment allez-vous fournir une lecture seule interface de l'objet contenant? Allez-vous créer une copie de l'objet contenu? C'est quelque chose que vous ne manquez quand vous apprenez comment puissant ayant const-références est.
- Comme je l'ai mentionné dans le commentaire #3, et si la taille importe vraiment, le conteneur peut fournir une spéciale en lecture seule interface pour gérer ce particulier et incroyablement gros objet.
- L'une des raisons pour lesquelles j'ai vraiment aimé C# quand il est sorti c'est qu'elle ne jetez toutes les pragmatiques fonctionnalités de C++ comme Java n'. Java essayé de faire tout avec des interfaces, et c'était une catastrophe. La preuve est dans le pudding. Au fil du temps beaucoup de fonctionnalités ont été ajoutées au "retour" en Java qui ont été à l'origine dénoncé comme une hérésie. Basé sur l'Interface de conception a sa place, mais lorsqu'il est pris à l'extrême peut compliquer inutilement une architecture de ce programme. Vous finissez par passer plus de temps à écrire du code réutilisable et moins de temps à apprendre des choses intéressantes à faire.
- Je serais favorable à "IReadableCustomer" en tant que nom de l'interface, plutôt que de "IReadOnlyCustomer", parce que celui-ci impliquerait une contradiction quand hérité, par exemple "IReadWriteCustomer" [Si le premier caractère de l'interface noms étaient minuscules, j'utiliserais "iMutableCustomer", mais "IMutableCustomer" ressemble trop à "ImmutableCustomer"]
- Pourquoi ne pas tout simplement ICustomer pour le nom de la mutable interface? Je crois que cela découle de Microsoft modèle de nommage, par exemple, ICollection<T> et IReadOnlyCollection<T>.
- Un IList<T> ne promet pas que les implémentations seront mutable, ni qu'ils ne sont pas; il perd généralement de covariance pour la capacité de permettre aux clients de se muter implémentations qui se trouvent être mutable sans avoir besoin d'un cast (si IList<T> prend en charge une forme de rupture de la covariance avec les tableaux: compte tenu des références à IList<Animal> et Animal, la seule façon de dire si l'on peut stocker ces derniers dans un élément de l'ex-est de l'essayer; si par exemple la IList<Animal> est en fait un Cat et la Animal est en fait un Dog, le stockage dans le IList<Animal> serait un échec.
InformationsquelleAutor Trap
28

Pour obtenir le bénéfice de la const-folie (ou de la pureté dans la programmation fonctionnelle termes), vous aurez besoin pour concevoir vos cours de façon à ce qu'ils sont immuables, tout comme la Chaîne de classe de c# est.

Cette approche est beaucoup mieux que de simplement le marquage d'un objet en readonly, depuis avec immuables de classes, vous pouvez transmettre les données autour d'facilement dans l'environnement multitâche.
- mais l'immutabilité n'est pas vraiment à l'échelle d'objets complexes, ou est-il?
- Je dirais que si votre objet a été tellement complexe que l'immutabilité était impossible, vous auriez un bon candidat pour le refactoring.
- Je pense que c'est le meilleur du groupe. Des objets immuables sont utilisés trop fréquemment.
- Non seulement cela, mais il ya des cas où vous voulez avoir une évolution des objets (les objets faire changer!) mais encore offrir un accès en lecture seule dans la plupart des cas. Des objets immuables implique que chaque fois que vous avez besoin de faire un changement (le changement se), vous aurez besoin pour créer un nouvel objet avec les mêmes données en plus de la modification. Envisager une école qui a pour salles de classe, les élèves... voulez-vous créer une nouvelle école chaque fois qu'un élève date de naissance et son âge changements? Ou pouvez-vous changer l'âge au niveau des élèves, l'élève au niveau de la salle, peut-être la pièce au niveau de l'école?
- L'immutabilité fait échelles incroyablement bien, lorsqu'il est fait droit. Une chose qui aide vraiment dans l'utilisation de l' Builder classes pour les grandes immuable types (Java et .NET définir la StringBuilder classe qui n'est qu'un exemple).
- disons que vous avez 4 GO de RAM, vous avez de la matrice 1Kx1K de chars. Veuillez calculer la fonction transpose (avec immuables de la matrice). La classe est trivial, la fonction, et en quelque sorte vous avez le problème-comment venir?
- Ce genre de choses sont en fait un tout à fait spécial cas – pure langues manipuler par des corps de ces immuable fonctions (ce qui, je pourrais ajouter, fonctionne souvent très bien). Mais oui, c'est un des cas où vous avez généralement à recourir à la mutabilité. Non pas parce que l'objet est complexe, vous l'esprit – tout simplement parce que d'une limitation de la mémoire.
- Effectivement, désolé, permettez-moi de backpedal. J'ai eu une pinte de trop. Il n'y a aucun besoin pour les particuliers-boîtier sur le niveau de langue. Vous pouvez avoir un immuable de l'interface pour une matrix classe et toujours conception de son API, de sorte que la transposition peut être fait efficacement en place lors de l'auto-affectation se fait en C++, le code m = t(m); peuvent fonctionner en place, même si auto o = t(m); serait pas fonctionner en place et plutôt de générer une nouvelle instance. Si je devais concevoir une bibliothèque de matrice, c'est comment je pourrais le concevoir.
- bien sûr, vous pouvez optimiser l'affectation, pas de problème ici, mais immuable fonction transpose travaille dans l'usine, ainsi, la (pas de l'appelant) a une autre matrice, conduisant à 8 go d'espace utilisé. Et n'avoir que des objets immuables (et fonctions) à portée de main, l'appelant, n'a même pas de choix à sacrifier la pureté, afin de gagner en performance. Mon point est -- immutabilité n'est pas une solution miracle, ou remplacement pour la mutabilité.
- Pour répéter, vous pouvez facilement mettre en œuvre l'opération m = t(m); de sorte que aucun de l'espace supplémentaire est nécessaire – ni à l'extérieur de t ou à l'intérieur; il fonctionne place. Bien sûr, alors m n'est pas immuable, mais le interface de t, c'est que d'une immuable de la fonction. Et de plus, cela peut être généralisé, afin que les appels comme matrix f() { matrix big_mat = /* some code */; return t(big_mat); } pouvez aussi travail sans exiger de la mémoire supplémentaire, même si le code est entièrement immuable.
- cours m n'est pas immuable" -- bien sûr, mais nous parlions des objets immuables.
- Je n'ai jamais été de dire que l'immutabilité doit être exclusive, vous êtes en train de plaider une paille homme-là. Mais comme je l'ai dit plus tard, vous peut toujours faire ce purement immuable ainsi que sur place, voir mon exemple de fonction. Vous avez juste besoin de s'assurer que l'objet précédent est hors de portée en même temps. C'est de cette façon purement fonctionnelle langues résoudre l'énigme.
InformationsquelleAutor Sam
23

Je voulais juste vous que beaucoup de Système.Les Collections.Les génériques des conteneurs ont une AsReadOnly méthode qui va vous redonner un immuable collection.
- Cela a encore le problème que les Ts sont mutables, même si le ReadOnlyCollection<T> n'est pas.
InformationsquelleAutor Rick Minerich
4

C# n'ont pas cette fonctionnalité. Vous pouvez passer d'argument par valeur ou par référence. Référence elle-même est immuable, sauf si vous spécifiez ref modificateur. Mais fait référence à des données n'est pas immuable. Donc, vous devez être prudent si vous voulez éviter les effets secondaires.

MSDN:

Passage De Paramètres
- eh bien, je suppose que c'est ce que la question vient alors: quelle est la meilleure façon d'éviter les effets secondaires de ne pas avoir de const structure?
- Malheureusement, seulement immuable types peuvent l'aider. Vous pouvez avoir un regard sur Spec# - il est intéressant de compiler le temps de vérifier.
InformationsquelleAutor aku
3

Interfaces sont la réponse, et sont en fait plus puissant que "const en C++. const est un one-size-fits-all solution pour le problème où "const" est défini comme "ne définit pas les membres ou appeler quelque chose qui définit les membres". C'est un bon raccourci pour const-ness dans de nombreux scénarios, mais pas tous d'entre eux. Par exemple, considérons une fonction qui calcule une valeur en fonction de certains membres, mais aussi met en cache les résultats. En C++, c'est considéré comme un non-const, bien que, dans la perspective de l'utilisateur, il est essentiellement const.

Interfaces de vous donner plus de flexibilité dans la définition du sous-ensemble spécifique de capacités que vous voulez pour fournir à partir de votre classe. Voulez const-ness? Il suffit de fournir une interface avec aucune mutation des méthodes. Souhaitez autoriser la définition de certaines choses, mais pas d'autres? Fournir une interface avec juste ces méthodes.
- Pas 100% correct. C++ const méthodes sont autorisés à muter membres marqué comme mutable.
- Juste assez. Et const-casting vous permet de vous débarrasser de const-ness. Les deux impliquent que même le C++ concepteurs réalisé one-size-fits-all est vraiment one-size-fits-plus.
- L'avantage du C++, c'est que vous avez const pour la plupart des cas, et vous pouvez implémenter des interfaces pour les autres. Maintenant, en plus de const, C++ a le mot-clé mutable appliquer aux attributs comme des caches de données, ou des mécanismes de verrouillage (mutex ou similaire). Const n'est pas " pas de changement de l'intérieur de l'attribut), mais plutôt de ne pas modifier l'état de l'objet, telle que perçue de l'extérieur. C'est, de toutes utilisations de l'objet avant et après l'appel d'une méthode const donnera le même résultat.
- jetant const muter comething en C++ est undefiend comportement (nasale démons). const_cast est pour l'interfaçage avec le code existant qui, tout en étant logiquement const n'est pas marquée const.
InformationsquelleAutor munificent

D'accord avec certaines d'autres regardent en lecture seule à l'aide de champs que vous initialiser 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; }
    }
  }

Sinon vous pouvez aussi ajouter d'accès portée sur les propriétés, par exemple la population d'obtenir et protégés définir?

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

Ces différentes approches qui ne sont pas vraiment adaptés à l'ensemble du problème. Avec le contrôle d'accès de niveau d'autoriser uniquement dérivant des classes de changements, dans de nombreux cas, ce ne sera pas le modèle le monde réel appropriatedly. Un enseignant ne découlent pas d'un enregistrement de l'étudiant, mais pouvez modifier les notes des étudiants, même si l'étudiant ne peut pas modifier les notes, mais ne peut les lire... juste pour en citer un exemple simple.

InformationsquelleAutor Stuart McConnell

2
- La const mot-clé peut être utilisé pour compiler les constantes de temps tels que les types primitifs et les chaînes de
- La readonly mot-clé peut être utilisé pour exécuter des constantes telles que les types de référence
Le problème avec readonly est qu'elle permet uniquement la référence (pointeur) à être constante. La chose référencé (souligné) peut toujours être modifié. C'est la partie la plus délicate, mais il n'y a pas moyen de contourner cela. Pour mettre en œuvre des objets constants en faire pas exposer les mutable méthodes ou des propriétés, mais c'est gênant.

Voir aussi Efficace C#: 50 Moyens Spécifiques pour Améliorer Votre C# (Item 2 - Préférez readonly const.)

InformationsquelleAutor Thomas Bratt

Vous devez vous connecter pour publier un commentaire.