Declarar una matriz constante

¿Es posible escribir algo similar a lo siguiente?

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

Sí, pero debe declararlo en readonlylugar de const:

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

La razón es que const solo se puede aplicar a un campo cuyo valor se conoce en tiempo de compilación. El inicializador de matriz que ha mostrado no es una expresión constante en C #, por lo que produce un error de compilación.

Declarar que readonlyresuelve ese problema porque el valor no se inicializa hasta el tiempo de ejecución (aunque se garantiza que se ha inicializado antes de la primera vez que se usa la matriz).

Dependiendo de qué es lo que finalmente desea lograr, también puede considerar declarar una enumeración:

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

Puede declarar la matriz como readonly, pero tenga en cuenta que puede cambiar el elemento de la readonlymatriz.

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

Considere usar enum, como sugirió Cody, o IList.

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

No puede crear una matriz 'const' porque las matrices son objetos y solo se pueden crear en tiempo de ejecución y las entidades const se resuelven en tiempo de compilación.

Lo que puede hacer en su lugar es declarar su matriz como "solo lectura". Esto tiene el mismo efecto que const, excepto que el valor se puede establecer en tiempo de ejecución. Solo se puede configurar una vez y luego es un valor de solo lectura (es decir, constante).

Desde C # 6 puedes escribirlo como:

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

Ver también: C #: El nuevo y mejorado C # 6.0 (específicamente el capítulo "Funciones y propiedades con cuerpo de expresión")

Esto creará una propiedad estática de solo lectura, pero aún así le permitirá alterar el contenido de la matriz devuelta, pero cuando vuelva a llamar a la propiedad, volverá a obtener la matriz original sin alterar.

Para aclarar, este código es el mismo que (o en realidad es una abreviatura de):

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

Tenga en cuenta que este enfoque tiene un inconveniente: en realidad, se crea una nueva matriz en todas y cada una de las referencias, por lo que si está utilizando una matriz muy grande, esta podría no ser la solución más eficiente. Pero si reutiliza la misma matriz (poniéndola en un atributo privado, por ejemplo), volverá a abrir la posibilidad de cambiar el contenido de la matriz.

Si desea tener una matriz (o lista) inmutable, también puede usar:

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

Pero, esto todavía tiene el riesgo de cambios, ya que aún puede volver a convertirlo en una cadena [] y alterar el contenido, como tal:

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

Si declara una matriz detrás de una interfaz IReadOnlyList, obtiene una matriz constante con valores constantes que se declara en tiempo de ejecución:

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

Disponible en .NET 4.5 y superior.

Una solución .NET Framework v4.5 + que mejora la respuesta de tdbeckett :

using System.Collections.ObjectModel;

// ...

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

^{Nota: Dado que la colección es conceptualmente constante, puede tener sentido staticdeclararla a nivel de clase .}

Lo anterior:

• Inicializa el campo de respaldo implícito de la propiedad una vez con la matriz.

  • Tenga en cuenta que { get; }- es decir, declarar solamente una propiedad getter - es lo que hace que la propiedad en sí implícitamente sólo lectura (tratando de combinar readonlycon la { get; }realidad, es un error de sintaxis).

  • Alternativamente, puede omitir { get; }y agregar readonlypara crear un campo en lugar de una propiedad, como en la pregunta, pero exponer a los miembros de datos públicos como propiedades en lugar de campos es un buen hábito para formar.

• Crea una estructura de tipo matriz (que permite el acceso indexado ) que es verdadera y robustamente de solo lectura (conceptualmente constante, una vez creada), ambos con respecto a:

  • evitar la modificación de la colección en su conjunto (como eliminar o agregar elementos o asignar una nueva colección a la variable).
  • evitando la modificación de elementos individuales .
    (Incluso la modificación indirecta no es posible, a diferencia de una IReadOnlyList<T>solución, donde un (string[])reparto se puede utilizar para obtener acceso de escritura a los elementos , como se muestra en la útil respuesta de mjepsen .
    La misma vulnerabilidad se aplica a la IReadOnlyCollection<T> interfaz , que, a pesar de la similitud en el nombre a la clase ReadOnlyCollection , ni siquiera admite el acceso indexado , lo que lo hace fundamentalmente inadecuado para proporcionar acceso tipo matriz).

Para mis necesidades defino staticmatriz, en lugar de imposible consty funciona: public static string[] Titles = { "German", "Spanish", "Corrects", "Wrongs" };

Podría adoptar un enfoque diferente: defina una cadena constante para representar su matriz y luego divida la cadena en una matriz cuando la necesite, p. Ej.

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

Este enfoque le proporciona una constante que puede almacenarse en la configuración y convertirse en una matriz cuando sea necesario.

En aras de la exhaustividad, ahora también tenemos ImmutableArrays a nuestra disposición. Esto debería ser realmente inmutable:

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

Requiere System.Collections.Immutable NuGet reference

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

Esta es una manera de hacer lo que quieres:

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

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

Es muy similar a hacer una matriz de solo lectura.

Esta es la única respuesta correcta. Actualmente no puedes hacer esto.

Todas las otras respuestas sugieren usar variables estáticas de solo lectura que son similares , pero no iguales a una constante. Una constante está codificada en el ensamblaje. Una variable de solo lectura estática se puede configurar una vez, probablemente a medida que se inicializa un objeto.

Estos a veces son intercambiables, pero no siempre.

Creo que solo puedes hacer que sea de solo lectura.

Las matrices son probablemente una de esas cosas que solo se pueden evaluar en tiempo de ejecución. Las constantes deben evaluarse en tiempo de compilación. Intente usar "readonly" en lugar de "const".

Como alternativa, para solucionar el problema de elementos que se pueden modificar con una matriz de solo lectura, puede usar una propiedad estática en su lugar. (Los elementos individuales aún se pueden cambiar, pero estos cambios solo se realizarán en la copia local de la matriz).

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

Por supuesto, esto no será particularmente eficiente ya que cada vez se crea una nueva matriz de cadenas.

Mejor alternativa:

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