Dichiarazione di un array di byte costante lungo

Question

Ho un array di byte lungo che devo dichiarare nel mio codice C#. Faccio qualcosa di simile a questo:

public static class Definitions 
{ 
    public const byte[] gLongByteArray = new byte[] { 
     1, 2, 3, 
     //and so on 
    }; 
} 

Ma ottengo un errore che l'array const può essere inizializzato solo con valori null.

Se cambio const in static viene compilato, ma la domanda che ho è questa: quando la dichiaro come public static byte[] gLongByteArray non verrà inizializzata ogni volta che la mia app viene caricata, giusto? In tal caso, la variabile gLongByteArray punta semplicemente a un array definito nel file exe/dll compilato che viene caricato in memoria. La ragione che sto chiedendo è perché questo array è piuttosto lungo e non voglio che il mio programma sprechi i cicli della CPU caricandolo ogni volta che l'app inizia, o peggio, questa classe è referenziata ...

Answer 1

Costanti tempo di compilazione (quelle dichiarate con la parola chiave const) sono severamente limitate. Nessun codice deve essere eseguito per ottenere una costante di questo tipo, altrimenti non potrebbe essere una costante in fase di compilazione. Le costanti const sono static per impostazione predefinita.

Se si desidera creare una costante e non è possibile utilizzare una costante fase di compilazione, è possibile utilizzare static readonly invece:

public static readonly byte[] longByteArray = new byte[] { 1, 2, 3, 4, 5 }; 

Il static parola chiave assicura viene inizializzato solo una volta, e parte del tipo di dichiarazione (e non ogni istanza). La parola chiave readonly assicura che la variabile longByteArray non possa essere modificata in seguito.

Definitions.longByteArray = new byte[] { 4, 5, 6 }; // Not possible. 

Warning: Un array è mutevole, così nel codice precedente che posso ancora fare questo:

Definitions.longByteArray[3] = 82;     // Allowed. 

Per evitare che, rendere il tipo non un array ma una sola lettura solo interfaccia di raccolta, come ad esempio IEnumerable<T> o IReadOnlyList<T> o, ancora meglio, un tipo di raccolta di sola lettura come ReadOnlyCollection<T> che non consente nemmeno la modifica tramite la trasmissione.

public static readonly IReadOnlyList<byte> longByteArray = new byte[] { 1, 2, 3, 4, 5 }; 

Answer 2

Puoi creare una matrice const. Secondo il documentation:

tipi definiti dall'utente, comprese le classi, le strutture e gli array, non può essere const.

Avresti di dichiararla come un campo di sola lettura statico come questo

public static class Definitions 
{ 
    public static readonly byte[] gLongByteArray = new byte[] { 
     1, 2, 3, 
     //and so on 
    }; 
} 

Naturalmente, non c'è niente da impedire a qualcuno di overwritting tuoi elementi della matrice in fase di esecuzione, in questo modo:

Definitions.gLongByteArray[0] = 0xFF; 

Dovreste usare uno del costruito in collezioni che @Virtlink suggerisce o creare il proprio classe personalizzata gamma di sola lettura per evitare che (example).

Answer 3

le classi statiche verranno inizializzate quando si carica l'applicazione per la prima volta. Non preoccuparti delle prestazioni, a meno che tu non abbia specificamente misurato che si tratta di un problema.

Answer 4

Scrivi tutto il contenuto in un file e incorpora come risorsa!