Comment initialiser KeyValuePair objet de la bonne façon?

J'ai vu (entre autres) cette question que les gens se demandent comment initialiser une instance de KeyValuePair, ce qui évidemment doit ressembler à cela.

KeyValuePair<int, int> keyValuePair = new KeyValuePair<int, int>
{ 
  Key = 1,
  Value = 2
};

Ça ne fonctionne pas, comme si les propriétés ne sont pas là. Intead, j'ai besoin d'utiliser le constructeur de ce genre.

KeyValuePair<int, int> keyValuePair = new KeyValuePair<int, int>(1, 2);

Certes syntaxe plus courte, mais ça me dérange que je ne peux pas utiliser l'initialiseur. Ce que je fais mal?

InformationsquelleAutor | 2013-03-19

c#initialization

47

Vous n'êtes pas mal, vous avez à l'initialisation d'un keyValuePair à l'aide de
```
KeyValuePair<int, int> keyValuePair = new KeyValuePair<int, int>(1, 2);
```
La raison pour laquelle vous ne pouvez pas utiliser l'objet de l'initialisation de la syntaxe ie { Touche = 1, Valeur = 2 } est parce que la Clé et la Valeur des propriétés ont pas de poseurs seulement les accesseurs (ils sont en lecture seule). Si vous ne pouvez même pas faire:
```
keyValuePair.Value = 1; //not allowed
```
InformationsquelleAutor Kevin Holditch
13

KeyValuePair<int, int> est un struct, et, heureusement, il est immuable struct. En particulier, cela signifie que ses propriétés sont en lecture seule. Donc, vous ne pouvez pas utiliser l'objet intializer pour eux.
- +1 'struct' est ce qu'explique tout. Comme vous le dites, des propriétés en lecture seulement sont qu'une conséquence de KVP être une struct
- une structure peut avoir des propriétés lecture-écriture
- il est immuable struct parce que ses propriétés sont en lecture seule, pas l'inverse.
- Je le sais, merci. Le point est que KVP est un struct, parce qu'il est immuable. Bien sûr, struct lui-même n'est pas égal à immutability.
- bien sûr, mais cela conduit souvent à des erreurs (comme essayer de mettre à jour une propriété dans une méthode juste en passant la valeur et pas la référence) d'Où la bonne pratique de la prise de propriétés en lecture seule
- Bien sûr, c'est exactement la même pour un immutbale de la classe, par exemple le code new Tuple<int, int> { Item1 = 1, Item2 = 2 } donne exactement la même erreur (avec une erreur qu'aucune surcharge du constructeur pour Tuple<,> prend 0 arguments).
- Quel est l'avantage de cette conception? Je suis en supposant que c'est un comportement intentionnel.
- cela pourrait être d'intérêt stackoverflow.com/q/441309/1236044
- Immuable objets sont en pour code des raisons de sécurité. Passage d'un objet par valeur est le passage de l'objet référence par valeur. En d'autres termes, vous pouvez modifier l'objet dans le thread d'origine après vous dépasser et affecter l'objet passé.
InformationsquelleAutor Dennis

Ok vous avez les réponses. Comme une alternative, je préfère usine modèle similaire à Tuple classe, pour l'inférence de type de magie 🙂

public static class KeyValuePair
{
    public static KeyValuePair<K, V> Create<K, V>(K key, V value)
    {
        return new KeyValuePair<K, V>(key, value);
    }
}

Si court devient plus courte:

var keyValuePair = KeyValuePair.Create(1, 2);

InformationsquelleAutor nawfal

Dictionnaires compact initialiseurs:

var imgFormats = new Dictionary<string, ChartImageFormat>()
{
    {".bmp", ChartImageFormat.Bmp}, 
    {".gif", ChartImageFormat.Gif}, 
    {".jpg", ChartImageFormat.Jpeg}, 
    {".jpeg", ChartImageFormat.Jpeg}, 
    {".png", ChartImageFormat.Png}, 
    {".tiff", ChartImageFormat.Tiff}, 
};

Dans ce cas, le dictionnaire que j'ai utilisé pour associer les extensions de fichiers avec format d'image constantes d'objets du diagramme.

Un seul keyvaluepair peuvent être retournés dans le dictionnaire, comme ceci:

var pair = imgFormats.First(p => p.Key == ".jpg");

InformationsquelleAutor flodis

5

La Clé et la Valeur des propriétés ont pas de poseurs. C'est pourquoi vous ne pouvez pas les utiliser dans l'initialiseur. Juste utiliser le constructeur 🙂 et vous serez amende.

InformationsquelleAutor Mihail Shishkov
3

Voici un exemple qui fait le travail
```
KeyValuePair<int, int> kvp = new KeyValuePair<int, int>(1, 1);
```
- De quoi cette réponse?
InformationsquelleAutor Paulo Carvalho
1

La Clé et Valeur propriétés sont en lecture seule, vous ne pouvez donc pas les utiliser dans un initialiseur d'objet.

Voir cette entrée dans le Guide de programmation C# .

InformationsquelleAutor Phil
1

Vous ne faites pas quelque chose de mal. Le KeyValuePairs propriétés sont en lecture seule. Vous ne pouvez pas définir. En outre, il n'y a pas de vide dans le constructeur par défaut. Vous devez utiliser le constructeur fourni.
- Il est exact qu'il n'y a pas de constructeur par défaut. Toutefois, le code var test = new KeyValuePair<int, int>(); sera toujours OK. La raison en est que KeyValuePair<,> est une struct. Et pour une struct, la valeur par défaut (également appelé default(KeyValuePair<int, int>)) sera créé si vous utilisez un new objet d'expression avec des arguments zéro. Dans ce cas, une paire d'où à la fois la clé et la valeur sont default(int) qui est à zéro.
- Je crois que c'est incorrect. Mon IntelliSense me dit que je peux créer des nouvelle KeyValuePair(), tout ce qui pourrait être bon pour. Ne sont pas toutes les classes censé avoir un défaut constructeur vide? Ou était-ce en Java...?
- non ce n'est pas une exigence pour les classes en C#, mais pour des structures.
InformationsquelleAutor nvoigt

Vous devez vous connecter pour publier un commentaire.