Déclarer un tableau const

Est-il possible d'écrire quelque chose de semblable au suivant?

public const string[] Titles = { "German", "Spanish", "Corrects", "Wrongs" };

Oui, mais vous devez le déclarer readonlyau lieu de const:

public static readonly string[] Titles = { "German", "Spanish", "Corrects", "Wrongs" };

La raison en est qu'elle constne peut être appliquée qu'à un champ dont la valeur est connue au moment de la compilation. L'initialiseur de tableau que vous avez montré n'est pas une expression constante en C #, il génère donc une erreur de compilation.

La déclarer readonlyrésout ce problème car la valeur n'est initialisée qu'au moment de l'exécution (bien qu'elle soit garantie d'avoir été initialisée avant la première utilisation du tableau).

Selon ce que vous voulez finalement réaliser, vous pouvez également envisager de déclarer une énumération:

public enum Titles { German, Spanish, Corrects, Wrongs };

Vous pouvez déclarer un tableau en tant que readonly, mais gardez à l'esprit que vous pouvez modifier l'élément du readonlytableau.

public readonly string[] Titles = { "German", "Spanish", "Corrects", "Wrongs" };
...
Titles[0] = "bla";

Envisagez d'utiliser enum, comme l'a suggéré Cody, ou IList.

public readonly IList<string> ITitles = new List<string> {"German", "Spanish", "Corrects", "Wrongs" }.AsReadOnly();

Vous ne pouvez pas créer un tableau «const» car les tableaux sont des objets et ne peuvent être créés qu'au moment de l'exécution et les entités const sont résolues au moment de la compilation.

Ce que vous pouvez faire à la place est de déclarer votre tableau comme "en lecture seule". Cela a le même effet que const, sauf que la valeur peut être définie au moment de l'exécution. Il ne peut être défini qu'une seule fois et est ensuite une valeur en lecture seule (c'est-à-dire const).

Depuis C # 6, vous pouvez l'écrire comme:

public static string[] Titles => new string[] { "German", "Spanish", "Corrects", "Wrongs" };

Voir aussi: C #: le nouveau et amélioré C # 6.0 (en particulier le chapitre "Fonctions et propriétés du corps d'expression")

Cela créera une propriété statique en lecture seule, mais vous permettra toujours de modifier le contenu du tableau renvoyé, mais lorsque vous appellerez à nouveau la propriété, vous obtiendrez à nouveau le tableau d'origine non modifié.

Pour plus de précision, ce code est le même que (ou en fait un raccourci pour):

public static string[] Titles
{
    get { return new string[] { "German", "Spanish", "Corrects", "Wrongs" }; }
}

Veuillez noter qu'il y a un inconvénient à cette approche: un nouveau tableau est en fait instancié sur chaque référence, donc si vous utilisez un très grand tableau, ce n'est peut-être pas la solution la plus efficace. Mais si vous réutilisez le même tableau (en le plaçant dans un attribut privé par exemple), cela ouvrira à nouveau la possibilité de modifier le contenu du tableau.

Si vous souhaitez avoir un tableau (ou une liste) immuable, vous pouvez également utiliser:

public static IReadOnlyList<string> Titles { get; } = new string[] { "German", "Spanish", "Corrects", "Wrongs" };

Mais, cela présente toujours un risque de modifications, car vous pouvez toujours le restituer dans une chaîne [] et modifier le contenu, en tant que tel:

((string[]) Titles)[1] = "French";

Si vous déclarez un tableau derrière une interface IReadOnlyList, vous obtenez un tableau constant avec des valeurs constantes qui est déclaré lors de l'exécution:

public readonly IReadOnlyList<string> Titles = new [] {"German", "Spanish", "Corrects", "Wrongs" };

Disponible dans .NET 4.5 et supérieur.

Une solution .NET Framework v4.5 + qui améliore la réponse de tdbeckett :

using System.Collections.ObjectModel;

// ...

public ReadOnlyCollection<string> Titles { get; } = new ReadOnlyCollection<string>(
  new string[] { "German", "Spanish", "Corrects", "Wrongs" }
);

^{Remarque: Étant donné que la collection est conceptuellement constante, il peut être judicieux staticde la déclarer au niveau de la classe .}

Ce qui précède:

• Initialise une fois le champ de support implicite de la propriété avec le tableau.

  • Notez que { get; }- c'est-à-dire, déclarer uniquement un getter de propriété - est ce qui rend la propriété elle-même implicitement en lecture seule (essayer de combiner readonlyavec { get; }est en fait une erreur de syntaxe).

  • Alternativement, vous pouvez simplement omettre le { get; }et ajouter readonlypour créer un champ au lieu d'une propriété, comme dans la question, mais exposer les membres de données publiques en tant que propriétés plutôt que champs est une bonne habitude à former.

• Crée une structure de type tableau (permettant un accès indexé ) qui est vraiment et robuste en lecture seule (conceptuellement constante, une fois créée), à ​​la fois en ce qui concerne:

  • empêcher la modification de la collection dans son ensemble (par exemple en supprimant ou en ajoutant des éléments, ou en affectant une nouvelle collection à la variable).
  • empêcher la modification d' éléments individuels .
    (Même une modification indirecte n'est pas possible - contrairement à une IReadOnlyList<T>solution, où une (string[])distribution peut être utilisée pour accéder en écriture aux éléments , comme le montre la réponse utile de mjepsen .
    La même vulnérabilité s'applique à l' IReadOnlyCollection<T> interface , qui, malgré la similitude de nom à la classe ReadOnlyCollection , ne prend même pas en charge l' accès indexé , ce qui le rend fondamentalement inapproprié pour fournir un accès de type tableau.)

Pour mes besoins, je définis un statictableau, au lieu d'impossible constet cela fonctionne: public static string[] Titles = { "German", "Spanish", "Corrects", "Wrongs" };

Vous pouvez adopter une approche différente: définir une chaîne constante pour représenter votre tableau, puis diviser la chaîne en un tableau lorsque vous en avez besoin, par exemple

const string DefaultDistances = "5,10,15,20,25,30,40,50";
public static readonly string[] distances = DefaultDistances.Split(',');

Cette approche vous donne une constante qui peut être stockée dans la configuration et convertie en tableau si nécessaire.

Dans un souci d'exhaustivité, nous avons également à notre disposition des tableaux immuables. Cela devrait être vraiment immuable:

public readonly static ImmutableArray<string> Tiles = ImmutableArray.Create(new[] { "German", "Spanish", "Corrects", "Wrongs" });

Nécessite une référence NuGet System.Collections.Immutable

https://msdn.microsoft.com/en-us/library/mt452182(v=vs.111).aspx

C'est une façon de faire ce que vous voulez:

using System;
using System.Collections.ObjectModel;
using System.Collections.Generic;

public ReadOnlyCollection<string> Titles { get { return new List<string> { "German", "Spanish", "Corrects", "Wrongs" }.AsReadOnly();}}

C'est très similaire à faire un tableau en lecture seule.

Ceci est la seule bonne réponse. Vous ne pouvez pas actuellement faire cela.

Toutes les autres réponses suggèrent d'utiliser des variables statiques en lecture seule qui sont similaires , mais pas identiques, à une constante. Une constante est codée en dur dans l'assemblage. Une variable statique en lecture seule peut être définie une fois, probablement lors de l'initialisation d'un objet.

Ceux-ci sont parfois interchangeables, mais pas toujours.

Je crois que vous ne pouvez le faire qu'en lecture seule.

Les tableaux sont probablement l'une de ces choses qui ne peuvent être évaluées qu'au moment de l'exécution. Les constantes doivent être évaluées au moment de la compilation. Essayez d'utiliser "en lecture seule" au lieu de "const".

Comme alternative, pour contourner le problème des éléments pouvant être modifiés avec un tableau en lecture seule, vous pouvez utiliser une propriété statique à la place. (Les éléments individuels peuvent toujours être modifiés, mais ces modifications ne seront effectuées que sur la copie locale du tableau.)

public static string[] Titles 
{
    get
    {
        return new string[] { "German", "Spanish", "Corrects", "Wrongs"};
    }
}

Bien sûr, cela ne sera pas particulièrement efficace car un nouveau tableau de chaînes est créé à chaque fois.

Meilleure alternative:

public static readonly byte[] ZeroHash = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };