Errori e avvisi del preprocessore

Il compilatore genera gli errori seguenti per l'uso non corretto delle direttive del preprocessore:

  • CS1024: Prevista direttiva del preprocessore
  • CS1025: previsto commento a riga singola o fine riga
  • CS1027: direttiva #endif prevista
  • CS1028: direttiva del preprocessore imprevista
  • CS1029: #error: 'text'
  • CS1030: #warning: 'text'
  • CS1032: Impossibile definire/annullare la definizione dei simboli del preprocessore dopo il primo token nel file
  • CS1038: prevista direttiva #endregion
  • CS1040: Le direttive del preprocessore devono essere visualizzate come primo carattere non vuoto in una riga
  • CS1517: espressione del preprocessore non valida
  • CS1560: nome file non valido specificato per la direttiva del preprocessore. Nome file troppo lungo o non un nome file valido
  • CS1576: Il numero di riga specificato nella direttiva #line è mancante o non valido
  • CS1578: Nome file, commento a riga singola o fine riga previsto
  • CS1633: direttiva #pragma non riconosciuta
  • CS1634: previsto disabilitazione o ripristino
  • CS1635: Impossibile ripristinare l'avviso 'codice di avviso' perché è stato disabilitato a livello globale
  • CS1691: 'number' non è un numero di avviso valido
  • CS1692: Numero non valido
  • CS1694: nome file non valido specificato per la direttiva del preprocessore. Nome file troppo lungo o non un nome file valido
  • CS1695: sintassi checksum #pragma non valida. Deve essere #pragma checksum "filename" "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" "XXXX..."
  • CS1696: È previsto un commento a riga singola o il termine della riga
  • CS1709: il nome file specificato per la direttiva del preprocessore è vuoto
  • CS7009: Impossibile usare #r dopo il primo token nel file
  • CS7010: Nome file tra virgolette richiesto
  • CS7011: #r è consentito solo negli script
  • CS8097: #load è consentito solo negli script
  • CS8098: impossibile usare #load dopo il primo token nel file
  • CS8301: nome non valido per un simbolo di pre-elaborazione; 'symbol name' non è un identificatore valido
  • CS8938: il valore della direttiva #line è mancante o non compreso nell'intervallo
  • CS8939: la posizione finale della direttiva #line deve essere maggiore o uguale alla posizione iniziale
  • CS8996: I letterali di stringa raw non sono consentiti nelle direttive del preprocessore
  • CS9028: la direttiva span #line richiede spazio prima della prima parentesi, prima dell'offset del carattere e prima del nome file
  • CS9297: #: le direttive non possono essere dopo il primo token nel file
  • CS9298: #: le direttive possono essere usate solo nelle app basate su file (-features:FileBasedProgram)
  • CS9299: #: le direttive non possono essere successive #if alla direttiva
  • CS9314: #! le direttive possono essere usate solo negli script o nelle app basate su file
  • CS9378: '#!' deve essere il primo carattere della prima riga del file

Sintassi della direttiva del preprocessore non valida

  • CS1024: Prevista direttiva del preprocessore
  • CS1025: previsto commento a riga singola o fine riga
  • CS1027: Direttiva #endif prevista
  • CS1028: direttiva imprevista del preprocessore
  • CS1032: Impossibile definire/annullare la definizione dei simboli del preprocessore dopo il primo token nel file
  • CS1038: direttiva #endregion prevista
  • CS1040: Le direttive del preprocessore devono essere visualizzate come primo carattere non vuoto in una riga
  • CS1517: espressione del preprocessore non valida
  • CS1633: direttiva #pragma non riconosciuta
  • CS1696: Previsto commento su una sola riga o fine della riga
  • CS8996: i valori letterali stringa non elaborati non sono consentiti nelle direttive del preprocessore

Questi errori indicano che è stata usata una sintassi non valida per le direttive del preprocessore. Le cause comuni includono:

  • Uso di una direttiva non riconosciuta dopo # (CS1024, CS1633).
  • Inclusione di commenti su più righe nelle direttive (CS1025, CS1696).
  • Uso di direttive in posizioni impreviste (CS1028).
  • Direttive di corrispondenza obbligatorie mancanti (CS1027, CS1038).
  • Posizionamento di una direttiva #define o #undef dopo il primo token del file (CS1032).
  • Non inserendo la direttiva come primo token su una riga (CS1040).
  • Uso di espressioni non valide nella compilazione condizionale (CS1517).
  • Uso di valori letterali stringa non elaborati nelle direttive del preprocessore (CS8996).

Esempio di CS1024 : prevista direttiva del preprocessore:

#import System   // CS1024 - "import" is not a valid directive

Esempio CS1025: commento su singola riga o fine riga previsto:

#if true /* hello  
*/   // CS1025 - multiline comment not allowed
#endif

Esempio CS1027 - prevista direttiva #endif:

#if true   // CS1027 - missing #endif
class Test { }

Esempio CS1028 - Direttiva del preprocessore imprevista:

#endif   // CS1028 - no matching #if

Esempio di CS1032: #define e #undef le direttive del preprocessore devono essere visualizzate prima di altri token:

class Test { }
#define X   // CS1032 - directive appears after the first token

Per correggere questo errore, inserire tutte le #define direttive e #undef prima del primo token nel file:

#define X
#undef Y
class Test { }

Esempio CS1038 - direttiva #endregion prevista:

#region testing
class Test { }
// CS1038 - missing #endregion

Esempio cs1040: le direttive del preprocessore devono essere visualizzate come primo carattere non vuoto:

/* Comment */ #define X   // CS1040 - directive not first on line

Esempio CS1517 - Espressione del preprocessore non valida:

#if 1           // CS1517 - numeric literals not allowed
#endif
#if ~symbol     // CS1517 - bitwise operators not allowed  
#endif

Esempio di CS1633 - Direttiva #pragma non riconosciuta:

#pragma unknown  // CS1633 - "unknown" is not a valid pragma

Esempio CS8996: i valori letterali stringa non elaborati non sono consentiti nelle direttive del preprocessore:

// CS8996.cs
#pragma checksum """raw_string""" "{406EA660-64CF-4C82-B6F0-42D48172A799}" "hash"  // CS8996
class Test { }

Per correggere questo errore, usare una stringa letterale normale.

#pragma checksum "filename.cs" "{406EA660-64CF-4C82-B6F0-42D48172A799}" "hash"  // OK
class Test { }

Per correggere questi errori, assicurarsi che le direttive del preprocessore seguano le regole di sintassi corrette descritte nella documentazione delle direttive del preprocessore.

Nomi di simboli del preprocessore non validi

  • CS8301: nome non valido per un simbolo di pre-elaborazione; 'symbol name' non è un identificatore valido

Quando si crea CSharpParseOptions a livello di codice, specificare ogni simbolo di compilazione condizionale come un nome con forma di identificatore. Il primo carattere deve essere valido all'inizio di un identificatore C# e i caratteri rimanenti devono essere caratteri di identificatore validi. Roslyn accetta anche il testo della parola chiave come nome di simbolo, ma non aggiunge un @ prefisso. Non includere spazi vuoti, punteggiatura come . o -, un'assegnazione come FEATURE=1o un'espressione condizionale completa.

Un simbolo di pre-elaborazione registra solo se il nome è definito. Non archivia un valore. I nomi non validi specificati tramite la proprietà di progetto DefineConstants o l'opzione del -define compilatore generano invece CS2029 . Vedere DefineConstants.

Errori della direttiva #error e #warning

  • CS1029: #error: 'text'
  • CS1030: #warning: 'text'
  • CS1634: previsto disabilitazione o ripristino
  • CS1635: Impossibile ripristinare l'avviso 'codice di avviso' perché è stato disabilitato a livello globale
  • CS1691: 'number' non è un numero di avviso valido
  • CS1692: Numero non valido

Questi errori si verificano quando il compilatore elabora le direttive #error, #warning e #pragma warning. Queste direttive consentono di generare messaggi di errore e di avviso personalizzati durante la compilazione e il comportamento di avviso del controllo.

CS1029 visualizza il testo di un errore definito con la #error direttiva :

// CS1029.cs
class Sample
{
   static void Main()
   {
      #error Let's give an error here   // CS1029
   }
}

La compilazione produce l'output seguente:

example.cs(9,8): error CS1029: #error: 'Let's give an error here   // CS1029  '

CS1030 visualizza il testo di un avviso definito con la #warning direttiva :

// CS1030.cs
class Sample
{
   static void Main()
   {
      #warning Let's give a warning here
   }
}

La compilazione produce l'output seguente:

example.cs(6,16): warning CS1030: #warning: 'Let's give a warning here'

CS1634 si verifica quando una clausola #pragma warning è malformata, ad esempio quando disabilitare o ripristinare sono omessi.

// CS1634.cs
// compile with: /W:1

#pragma warning   // CS1634
// Try this instead:
// #pragma warning disable 0219

class MyClass
{
  public static void Main()
  {
  }
}

CS1635 si verifica quando si usa l'opzione della riga di comando o l'impostazione /nowarn del progetto per disabilitare un avviso a livello globale, ma usare #pragma warning restore per tentare di ripristinare l'avviso:

// CS1635.cs
// compile with: /w:1 /nowarn:162

enum MyEnum {one=1,two=2,three=3};

class MyClass
{
    public static void Main()
    {
#pragma warning disable 162

    if (MyEnum.three == MyEnum.two)
        System.Console.WriteLine("Duplicate");

#pragma warning restore 162  // CS1635
    }
}

CS1691 si verifica quando un numero passato alla #pragma warning direttiva non è un numero di avviso valido:

// CS1691.cs
public class C
{
    int i = 1;
    public static void Main()
    {
        C myC = new C();
#pragma warning disable 151  // CS1691
// Try the following line instead:
// #pragma warning disable 1645
        myC.i++;
#pragma warning restore 151  // CS1691
// Try the following line instead:
// #pragma warning restore 1645
    }
}

CS1692 si verifica quando un numero nelle direttive del preprocessore come #pragma e #line non è valido perché è troppo grande, nel formato errato o contiene caratteri non validi:

// CS1692.cs

#pragma warning disable a  // CS1692
// Try this instead:
// #pragma warning disable 1691

class A
{
    static void Main()
    {
    }
}

Queste direttive sono utili per gli scenari di compilazione condizionale in cui si vuole avvisare gli sviluppatori di condizioni specifiche nel codice o controllare quali avvisi vengono visualizzati durante la compilazione. Per altre informazioni sull'uso di queste direttive, vedere la documentazione delle direttive del preprocessore e #pragma avviso.

#line errori di file e di direttiva

  • CS1560: nome file non valido specificato per la direttiva del preprocessore. Il nome file è troppo lungo o non è un nome file valido.
  • CS1576: Il numero di riga specificato per la direttiva #line è mancante o non valido.
  • CS1578: nome file, commento a riga singola o fine riga prevista.
  • CS1694: nome file non valido specificato per la direttiva del preprocessore. Il nome file è troppo lungo o non è un nome file valido.
  • CS1695: sintassi di checksum #pragma non valida. Deve essere #pragma checksum "filename" "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" "XXXX...".
  • CS1709: il nome file specificato per la direttiva del preprocessore è vuoto.
  • CS8938: il valore della direttiva #line è mancante o non compreso nell'intervallo.
  • CS8939: la posizione finale della direttiva #line deve essere maggiore o uguale alla posizione iniziale.
  • CS9028: la direttiva span #line richiede spazio prima della prima parentesi, prima dell'offset del carattere e prima del nome del file.

Questi errori indicano un utilizzo errato della direttiva o delle direttive del #line preprocessore correlate ai file. Le cause comuni includono:

  • Nomi file non validi o mancanti (CS1560, CS1694, CS1709).
  • Formato o valori di numeri di riga non corretti (CS1576, CS8938, CS8939).
  • Sintassi corretta mancante per i nomi dei file e i commenti (CS1578).
  • Sintassi non valida #pragma checksum (CS1695).
  • Spaziatura non corretta nelle #line direttive span (CS9028).

Esempio di CS1560/CS1694 - Nome file non valido specificato:

#line 100 "MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890MyFile1234567890.txt"   // CS1560/CS1694 - filename too long

Esempio di CS1576 - Numero di riga mancante o non valido:

#line "abc.sc"         // CS1576 - missing line number
#line abc "file.cs"    // CS1576 - invalid line number format

Esempio CS1578 - Nome del file, commento o fine riga previsti:

#line 101 abc.cs   // CS1578 - filename not quoted

Esempio di CS1695 : sintassi checksum #pragma non valida:

#pragma checksum "12345"  // CS1695 - missing GUID and checksum

Esempio di CS1709 - Nome file vuoto:

#pragma checksum "" "{406EA660-64CF-4C82-B6F0-42D48172A799}" ""  // CS1709 - empty filename

Esempio di CS8938 : valore della direttiva #line mancante o non compreso nell'intervallo:

#line   // CS8938 - missing value
#line 0  // CS8938 - out of range (must be 1-16,707,566)

Esempio di CS8939 - errore di posizione di fine riga:

#line (1, 10) - (1, 5) "file.cs"  // CS8939 - end column < start column

Esempio di CS9028 - spaziatura della direttiva #line span:

#line(1, 1) - (1, 10)"file.cs"  // CS9028 - missing spaces

Per correggere questi errori, verificare che le #line direttive e le direttive del preprocessore correlate ai file seguano la sintassi corretta, come descritto nella documentazione delle direttive del preprocessore.

Uso non corretto delle direttive delle app basate su file

  • CS9297: #: le direttive non possono essere dopo il primo token nel file
  • CS9298: #: le direttive possono essere usate solo nelle app basate su file (-features:FileBasedProgram)
  • CS9299: #: le direttive non possono essere successive #if alla direttiva
  • CS9314: #! le direttive possono essere usate solo negli script o nelle app basate su file
  • CS9378: '#!' deve essere il primo carattere della prima riga del file

Questi errori indicano che le #: direttive o #! sono state usate in modo non corretto. Per altre informazioni sulla sintassi per queste direttive, vedere l'articolo sulle direttive del preprocessore nella sezione sulle app basate su file. In alternativa, è possibile esplorare le app basate su file seguendo l'esercitazione sulle app basate su file.

Uno shebang (#!) seleziona l'eseguibile per uno script o un'app basata su file. Posizionarlo al primo carattere della prima riga, prima di qualsiasi spazio vuoto, commenti o righe vuote (CS9378); vedere le linee guida per le direttive delle app basate su file.

Il file contiene direttive "script.cs"

Gli errori seguenti indicano un uso o una posizione non corretti delle direttive script C#:

  • CS7009: Non è possibile usare #r dopo il primo token nel file
  • CS7010: Nome del file tra virgolette previsto
  • CS7011: #r è consentito solo negli script
  • CS8097: #load è consentito solo negli script
  • CS8098: impossibile usare #load dopo il primo token nel file

In uno script in C# (.csx), una direttiva #load dopo un token genera CS8098:

System.Console.WriteLine("This is the first token.");
#load "helpers.csx" // CS8098

Per correggere CS8098, sposta ogni direttiva #load prima di ogni token nello script:

#load "helpers.csx"
System.Console.WriteLine("The directive precedes the first token.");

In un normale file di origine C# (.cs) #load non è consentito. Tale condizione correlata produce CS8097, non CS8098. Rimuovere #load dai normali file di origine.

  • Last updated on