Deklaracja stałej tablicy

Czy można napisać coś podobnego do poniższego?

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

Tak, ale musisz to zadeklarować readonlyzamiast const:

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

Powodem jest to, że constmożna go zastosować tylko do pola, którego wartość jest znana w czasie kompilacji. Inicjalizator tablicy, który pokazałeś, nie jest stałym wyrażeniem w języku C #, więc powoduje błąd kompilatora.

Zadeklarowanie go readonlyrozwiązuje ten problem, ponieważ wartość nie jest inicjowana do czasu wykonania (chociaż gwarantuje się, że zainicjowała się przed pierwszym użyciem tablicy).

W zależności od tego, co ostatecznie chcesz osiągnąć, możesz również rozważyć deklarację wyliczenia:

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

Możesz zadeklarować tablicę jako readonly, ale pamiętaj, że możesz zmienić element readonlytablicy.

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

Rozważ użycie enum, jak sugerował Cody, lub IList.

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

Nie można utworzyć tablicy „const”, ponieważ tablice są obiektami i można je tworzyć tylko w czasie wykonywania, a stałe encje są rozwiązywane w czasie kompilacji.

Zamiast tego możesz zadeklarować tablicę jako „tylko do odczytu”. Ma to taki sam efekt jak const, z tą różnicą, że wartość można ustawić w czasie wykonywania. Można go ustawić tylko raz, a następnie jest to wartość tylko do odczytu (tj. Stała).

Od wersji C # 6 możesz pisać w następujący sposób:

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

Zobacz także: C #: Nowy i ulepszony C # 6.0 (konkretnie rozdział „Funkcje i właściwości wyrażania”)

Spowoduje to utworzenie właściwości statycznej tylko do odczytu, ale nadal pozwoli ci zmienić zawartość zwracanej tablicy, ale gdy ponownie wywołasz właściwość, otrzymasz ponownie oryginalną, niezmienioną tablicę.

Dla wyjaśnienia, ten kod jest taki sam jak (lub w rzeczywistości skrót):

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

Należy pamiętać, że takie podejście ma wadę: nowa tablica jest tworzona przy każdym odwołaniu, więc jeśli używasz bardzo dużej tablicy, może to nie być najbardziej wydajne rozwiązanie. Ale jeśli ponownie użyjesz tej samej tablicy (na przykład umieszczając ją w prywatnym atrybucie), ponownie otworzy ona możliwość zmiany zawartości tablicy.

Jeśli chcesz mieć niezmienną tablicę (lub listę), możesz również użyć:

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

Ale nadal wiąże się to z ryzykiem zmian, ponieważ nadal możesz rzutować go z powrotem na ciąg [] i modyfikować zawartość jako taką:

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

Jeśli zadeklarujesz tablicę za interfejsem IReadOnlyList, otrzymasz stałą tablicę o stałych wartościach deklarowanych w czasie wykonywania:

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

Dostępne w .NET 4.5 i wyższych.

Rozwiązanie .NET Framework v4.5 +, które poprawia odpowiedź tdbeckett :

using System.Collections.ObjectModel;

// ...

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

^{Uwaga: Biorąc pod uwagę, że kolekcja jest stała koncepcyjnie, sensowne może staticbyć zadeklarowanie jej na poziomie klasy .}

Powyższe:

• Inicjuje niejawne pole zaplecza właściwości jeden raz z tablicą.

  • Zauważ, że { get; }- tj. Deklarowanie tylko modułu pobierania właściwości - powoduje, że sama właściwość jest domyślnie tylko do odczytu (próba połączenia readonlyz nią { get; }jest w rzeczywistości błędem składni).

  • Alternatywnie, możesz po prostu pominąć { get; }i dodać, readonlyaby utworzyć pole zamiast właściwości, jak w pytaniu, ale ujawnianie publicznych elementów danych jako właściwości zamiast pól jest dobrym nawykiem do tworzenia.

• Tworzy array- jak struktury (pozwalając indeksowanego dostępu ), który jest naprawdę solidnie i tylko do odczytu (koncepcyjnie stały, raz utworzone), zarówno w odniesieniu do:

  • zapobieganie modyfikacji kolekcji jako całości (na przykład poprzez usunięcie lub dodanie elementów lub przypisanie nowej kolekcji do zmiennej).
  • zapobieganie modyfikacji poszczególnych elementów .
    (Nawet pośrednia zmiana nie jest to możliwe - w przeciwieństwie z IReadOnlyList<T>roztworu, gdzie obsada może być wykorzystywane w celu uzyskania dostępu do zapisu elementów , jak pokazano na pomocne odpowiedzi mjepsen męska . Ta sama luka dotyczy w interfejsie , który, mimo podobieństwa w nazwie do klasy , nie obsługuje nawet dostępu indeksowanego , przez co zasadniczo nie nadaje się do zapewniania dostępu podobnego do tablicy).(string[])
IReadOnlyCollection<T> ReadOnlyCollection

Na moje potrzeby określam statictablicę zamiast niemożliwej consti działa ona: public static string[] Titles = { "German", "Spanish", "Corrects", "Wrongs" };

Możesz zastosować inne podejście: zdefiniuj stały ciąg reprezentujący tablicę, a następnie podziel ciąg na tablicę, gdy jej potrzebujesz, np.

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

Takie podejście daje stałą, którą można zapisać w konfiguracji i w razie potrzeby przekształcić w tablicę.

W trosce o kompletność, teraz mamy do dyspozycji również ImmutableArrays. To powinno być naprawdę niezmienne:

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

Wymaga System.Collections.Immutable odniesienia NuGet

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

Jest to sposób na robienie tego, co chcesz:

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

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

Jest to bardzo podobne do robienia tablicy tylko do odczytu.

To jedyna poprawna odpowiedź. Obecnie nie możesz tego zrobić.

Wszystkie pozostałe odpowiedzi sugerują użycie statycznych zmiennych tylko do odczytu, które są podobne , ale nie takie same jak stała. Stała jest na stałe zakodowana w zestawie. Statyczną zmienną tylko do odczytu można ustawić raz, prawdopodobnie podczas inicjalizacji obiektu.

Czasami są one wymienne, ale nie zawsze.

Wierzę, że możesz to zrobić tylko do odczytu.

Tablice są prawdopodobnie jedną z tych rzeczy, które można ocenić tylko w czasie wykonywania. Stałe muszą być oceniane w czasie kompilacji. Spróbuj użyć „tylko do odczytu” zamiast „const”.

Alternatywnie, aby obejść problem z elementami, które można modyfikować za pomocą tablicy tylko do odczytu, można zamiast tego użyć właściwości statycznej. (Poszczególne elementy można nadal zmieniać, ale zmiany te zostaną wprowadzone tylko w lokalnej kopii tablicy).

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

Oczywiście nie będzie to szczególnie wydajne, ponieważ za każdym razem tworzona jest nowa tablica ciągów.

Najlepsza alternatywa:

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