Объявить константный массив

Можно ли написать что-то похожее на следующее?

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

Да, но вы должны объявить это readonlyвместо const:

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

Причина в том, что это constможет быть применено только к полю, значение которого известно во время компиляции. Показанный инициализатор массива не является константным выражением в C #, поэтому он вызывает ошибку компилятора.

Объявление его readonlyрешает эту проблему, потому что значение не инициализируется до времени выполнения (хотя оно гарантированно инициализируется до первого использования массива).

В зависимости от того, чего вы в конечном итоге хотите достичь, вы можете также рассмотреть объявление enum:

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

Вы можете объявить массив как readonly, но имейте в виду, что вы можете изменить элемент readonlyмассива.

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

Подумайте об использовании enum, как предложил Коди, или IList.

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

Вы не можете создать массив const, потому что массивы являются объектами и могут быть созданы только во время выполнения, а объекты const разрешаются во время компиляции.

Вместо этого вы можете объявить массив как «только для чтения». Это имеет тот же эффект, что и const, за исключением того, что значение может быть установлено во время выполнения. Он может быть установлен только один раз, и после этого он будет иметь значение только для чтения (т.е. постоянное).

Начиная с C # 6 вы можете написать это так:

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

Смотрите также: C #: новый и улучшенный C # 6.0 (в частности, глава «Функции и свойства, связанные с выражением»)

Это создаст статическое свойство только для чтения, но все равно позволит вам изменять содержимое возвращаемого массива, но при повторном вызове свойства вы снова получите исходный неизмененный массив.

Для пояснения этот код аналогичен (или фактически сокращению):

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

Обратите внимание, что у этого подхода есть обратная сторона: новый массив фактически создается для каждой ссылки, поэтому, если вы используете очень большой массив, это может быть не самым эффективным решением. Но если вы повторно используете тот же массив (например, поместив его в закрытый атрибут), это снова откроет возможность изменить содержимое массива.

Если вы хотите иметь неизменяемый массив (или список), вы также можете использовать:

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

Но это по-прежнему сопряжено с риском для изменений, поскольку вы все равно можете привести его обратно к строке [] и изменить содержимое следующим образом:

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

Если вы объявляете массив за интерфейсом IReadOnlyList, вы получаете постоянный массив с постоянными значениями, который объявляется во время выполнения:

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

Доступно в .NET 4.5 и выше.

Решение .NET Framework v4.5 + , улучшающее ответ tdbeckett :

using System.Collections.ObjectModel;

// ...

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

^{Примечание. Учитывая, что коллекция концептуально постоянна, может иметь смысл staticобъявить ее на уровне класса .}

Вышеупомянутое:

• Инициализирует неявное поле поддержки свойства один раз с массивом.

  • Обратите внимание, что { get; }- то есть объявление только метода получения свойства - это то, что делает само свойство неявно доступным только для чтения (попытка объединиться readonlyс { get; }ним на самом деле является синтаксической ошибкой).

  • В качестве альтернативы вы можете просто опустить { get; }и добавить, readonlyчтобы создать поле вместо свойства, как в вопросе, но использование открытых элементов данных в качестве свойств, а не полей - хорошая привычка для формирования.

• Создает array- как структуры ( с учетом индексированного доступа ) , что по- настоящему и решительно только для чтения (концептуально постоянная, после создания), как в отношении:

  • предотвращение изменения коллекции в целом (например, путем удаления или добавления элементов или назначения новой коллекции переменной).
  • предотвращение модификации отдельных элементов .
    (Даже непрямая модификация не возможно - в отличии с IReadOnlyList<T>раствором, в котором литой может быть использован , чтобы получить доступ на запись к элементам , как показан на полезном ответ mjepsen игровых . То же уязвимость относится к(string[])
IReadOnlyCollection<T> интерфейсу , который, несмотря на сходство в названии к классу ReadOnlyCollection , даже не поддерживает индексированный доступ , что делает его принципиально непригодным для предоставления доступа, подобного массиву.)

Для моих нужд я определяю staticмассив, а не невозможный, constи он работает: public static string[] Titles = { "German", "Spanish", "Corrects", "Wrongs" };

Вы можете использовать другой подход: определить постоянную строку для представления вашего массива, а затем разбить строку на массив, когда вам это нужно, например,

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

Этот подход дает вам константу, которая может быть сохранена в конфигурации и преобразована в массив при необходимости.

Для полноты картины теперь у нас есть ImmutableArrays. Это должно быть действительно неизменным:

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

Требуется ссылка System.Collections.Immutable NuGet

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

Это способ сделать то, что вы хотите:

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

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

Это очень похоже на создание массива только для чтения.

Это единственный правильный ответ. Вы не можете сделать это в настоящее время.

Все остальные ответы предлагают использовать статические переменные только для чтения, которые похожи , но не совпадают с константами. Константа жестко запрограммирована в сборке. Статическая переменная только для чтения устанавливается один раз, вероятно, когда объект инициализируется.

Они иногда взаимозаменяемы, но не всегда.

Я верю, что вы можете сделать это только для чтения.

Массивы, вероятно, являются одной из тех вещей, которые могут быть оценены только во время выполнения. Константы должны быть оценены во время компиляции. Попробуйте использовать «только для чтения» вместо «const».

В качестве альтернативы, чтобы обойти проблему «элементы могут быть изменены» с массивом только для чтения, вы можете использовать вместо этого статическое свойство. (Отдельные элементы все еще могут быть изменены, но эти изменения будут сделаны только в локальной копии массива.)

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

Конечно, это не будет особенно эффективно, поскольку каждый раз создается новый массив строк.

Лучшая альтернатива:

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