Messaggi del compilatore Visual Basic

Aggiornamento: novembre 2007

In questa sezione sono contenuti i messaggi di errore Visual Basic che si verificano in fase di compilazione.

Previsto '-'

'!' richiede che l'operando di sinistra abbia un tipo parametro di tipo classe o interfaccia. L'operando ha invece tipo '<tipo>'

'#Else' deve essere preceduto da un '#If' o '#ElseIf' corrispondente

'#ElseIf' non può seguire '#Else' come parte di un blocco '#If'

'#ElseIf' deve essere preceduto da un '#If' o '#ElseIf' corrispondente

'#ElseIf', '#Else' o '#End If' deve essere preceduto da un '#If' corrispondente

'#End ExternalSource' deve essere preceduto da un '#ExternalSource' corrispondente

'#End Region' deve essere preceduto da un '#Region' corrispondente

Le direttive '#ExternalSource' non possono essere nidificate

L'istruzione '#ExternalSource' deve terminare con un '#End ExternalSource' corrispondente

È necessario concludere il blocco '#If' con un '#End If' corrispondente

Le istruzioni '#Region' e '#End Region' non sono valide nei corpi dei metodi

L'istruzione '#Region' deve terminare con un '#End Region' corrispondente

Previsto '('

'(' imprevisto

Previsto ')'

'.' previsto

':' non consentito

Previsto '{'

Previsto: "}"

'<nomeargomento>' non è un parametro di '<dichiarazionemetodo>'

'<nomeassembly>' è un assembly ed è impossibile farvi riferimento come a un modulo

Impossibile applicare '<attributo>' perché il formato del GUID '<numero>' non è corretto

Impossibile applicare '<nomeattributo>' più di una volta a un assembly

'<nomeinterfacciabase>.<nomemembro>' da 'Implements '<nomeinterfacciaderivata>' è già implementata dalla classe base '<nomeclassebase>'. Prevista nuova implementazione di <tipo>

'<nomeclasse>' non è compatibile con CLS perché deriva da '<nomeclassebase>', che non è compatibile con CLS

'<nomeclasse>' non è compatibile con CLS perché l'interfaccia '<nomeinterfaccia>' implementata non è compatibile

'<nomeclasse1>' non può ereditare da <tipo> '<nomeclasse2>' perché '<nomeclasse2>' è dichiarata 'NotInheritable'

L'elemento '<costruttore>' nel tipo '<tipo>' generato in fase di progettazione deve chiamare il metodo InitializeComponent

'<dichiarazione1>' non può eseguire l'override di '<dichiarazione2>' perché è dichiarato 'NotOverridable'

'<dichiarazione1>' non può eseguire l'override di '<dichiarazione2>' perché è dichiarato 'Shared'

'<dichiarazione1>' non può eseguire l'override di '<dichiarazione2>' perché dispone di un livello di accesso differente

'<nometipoderivato>' non può ereditare da <tipo> '<nometipobasecreato>' perché espande l'accesso di tipo <nometipointerno> all'esterno dell'assembly

'<nometipoderivato>' non può ereditare da <tipo> '<nometipodibasecostruito>' perché espande l'accesso di tipo '<nometipointerno>' a <regione> '<nomeregione>'

'<nomeelemento>' non può essere dichiarato 'Partial' perché i metodi parziali devono essere Sub

'<nomelemento>' per l'alias di Imports per '<nomelementoqualificato>' non si riferisce né a uno spazio dei nomi, né a una classe, né a una struttura, né a un'interfaccia, né a un'enumerazione, né a un modulo

'<nomeelemento>' è ambiguo poiché esistono più tipi di membri con questo nome in <tipo> '<nometipo>'

'<nomeelemento>' non è un parametro di metodo

'<nomeelemento>' non è un parametro del metodo di estensione '<nomemetodo>' definito in '<nometipo>'

'<nomeelemento>' è obsoleto (Errore di Visual Basic)

'<nomeelemento>' è obsoleto (Avviso di Visual Basic)

'<nomelemento>' è obsoleto: '<messaggioerrore>'

'<nomeelemento>' fa riferimento al tipo '<nometipo>' nel progetto '<nomeprogetto>', ma il tipo '<nometipo>' non è stato trovato nel progetto '<nomeprogetto>'

'<costanteempty>' non è dichiarato

<errore>: '<nomeclasse1>' eredita da '<nomeclasse2>'

<errore>: '<nomecostruttore1>' chiama '<nomecostruttore2>'

<errore>: '<nomestruttura1>' contiene '<nomestruttura2>'

'<nomeevento>' definisce in modo implicito '<nomemembro>', che è in conflitto con un membro dichiarato in modo implicito in <tipo> '<nometipo>'

'<nomeevento>' è un evento e non può essere chiamato direttamente

'<nomeevento>' non è un evento di '<nomecontenitore>'

Impossibile utilizzare '<espressione>' come vincolo di tipo

Impossibile fare riferimento a '<nomefile>' perché non è un assembly

'<funzione>' non è dichiarata

'<nomefunzione>' non è dichiarata (errore del compilatore Visual Basic/Smart Device)

'<nomefunzione>' non è dichiarato (errore Visual Basic)

'<clausolaimplements>' non può implementare '<nometipo>' perché '<nometipo>' è un nome riservato

'<nomeinterfaccia>.<nomemembro>' già implementato dalla classe base '<nomeclassebase>'. Prevista nuova implementazione di <tipo>

'<nomeinterfaccia1>' non può implementare '<nomemetodo>' perché non esiste un <metodo> corrispondente nell'interfaccia '<nomeinterfaccia2>'

La funzione di accesso '<parolachiave>' di '<nomeproprietà>' è obsoleta (Errore di Visual Basic)

La funzione di accesso '<parolachiave>' di '<nomeproprietà>' è obsoleta (avviso di Visual Basic)

La funzione di accesso '<parolachiave>' di '<nomeproprietà>' è obsoleta: '<messaggioerrore>' (errore di Visual Basic)

La funzione di accesso '<parolachiave>' di '<nomeproprietà>' è obsoleta: '<messaggioerrore>' (Avviso di Visual Basic)

'<parolachiave>' non valido all'interno di un modulo

'<parolachiave>' non è valido all'interno di una struttura

'<parola chiave>' è valido solo all'interno di una classe

'<parolachiave>' è valido solo all'interno di un metodo di istanza

'<lsetstmt>' non è dichiarata

'<funzionematematica1>' non è dichiarata

'<membro>' è in conflitto con il membro riservato da questo nome che è implicitamente dichiarato in tutte le enumerazioni

'<membro>' è già dichiarato in questa struttura

'<membro>', dichiarato in modo implicito per l'evento '<nomeevento>', non può nascondere un metodo 'MustOverride' nella <classe> base '<nomeclasse>'

'<nomemembro>' non può essere dichiarato 'Shadows' all'esterno di una classe, di una struttura o di un'interfaccia

'<nomemembro>' non può esporre il tipo '<nometipo>' all'esterno del progetto mediante <tipocontenitore> '<nometipocontenitore>'

'<nomemembro>' non può implementare '<nomeinterfaccia>.<nomemembrointerfaccia>' perché i vincoli del parametro di tipo differiscono

'<nomemembro>' esiste in più interfacce di base

'<nomemembro>' ha lo stesso nome di un parametro di tipo

'<nomemembro>' è già dichiarato da '<nomeroutine>' che è stato generato per questo <nomecontenitore>

'<nomemembro>' è ambiguo nelle interfacce ereditate '<nomeinterfaccia1>' e '<nomeinterfaccia2>'

'<nomemembro>' non è un membro di '<nomecontesto>' e non esiste nel contesto corrente

'<nomemembro>' non è dichiarato

'<nomemembro>' non è dichiarato oppure il modulo che lo contiene non è caricato nella sessione di debug

'<nomemembro>' è obsoleto: '<messaggioerrore>'

'<nomemembro1>' e '<nomemembro2>' non possono essere in rapporto di overload perché si differenziano solo per i tipi di parametri facoltativi

'<nomemembro1>' non può eseguire l'override di '<nomemembro2>' perché si differenziano per i tipi di parametri facoltativi

<messaggio> Questo errore può essere causato dall'unione di un riferimento di file a '<nomefile1>' nel progetto '<nomeprogetto1>' con un riferimento di file a '<nomefile2>' nel progetto '<nomeprogetto2>'

<messaggio> L'errore potrebbe inoltre essere dovuto all'unione di un riferimento di file con un riferimento al progetto nell'assembly '<nomeassembly>'

<metodo> '<nomemetodo1>' deve essere dichiarato 'Overloads' perché un altro '<nomemetodo2>' è dichiarato 'Overloads'

'<metodo>' non è accessibile in questo contesto perché è '<modificatore>'

'<metodo1>' e '<metodo2>' non possono essere in rapporto di overload perché si differenziano solo per i parametri facoltativi

'<metodo1>' e '<metodo2>' non possono essere in rapporto di overload perché si differenziano solo per i parametri dichiarati 'ByRef' o 'ByVal'

'<metodo1>' e '<metodo2>' non possono essere in rapporto di overload perché si differenziano solo per parametri dichiarati 'ParamArray'

'<metodo1>' e '<metodo2>' non possono essere in rapporto di overload perché si differenziano solo per i tipi restituiti

'<metodo1>' e '<metodo2>' non possono essere in rapporto di overload perché si differenziano solo per i valori predefiniti dei parametri facoltativi

'<metodo1>' non può eseguire l'override di '<metodo2>' perché espande l'accesso al metodo di base

'<metodo1>' non può eseguire l'override di '<metodo2>' perché è un'istruzione 'Declare'

'<metodo1>' non può eseguire l'override di '<metodo2>' perché si differenziano per un parametro contrassegnato da una parte come 'ByRef' e dall'altra come 'ByVal'

'<metodo1>' non può eseguire l'override di '<metodo2>' perché si differenziano per i parametri facoltativi

'<metodo1>' non può eseguire l'override di '<metodo2>' perché si differenziano per i valori predefiniti dei parametri facoltativi

'<metodo1>' non può eseguire l'override di '<metodo2>' perché si differenziano per i tipi restituiti

'<nomemetodo>' e '<nomemetodo>' non possono essere in rapporto di overload perché si differenziano per 'ReadOnly' o 'WriteOnly'

'<nomemetodo>' non può essere implementato più di una volta

'<nomemetodo>' non può eseguire l'override di un metodo nascosto

'<nomemetodo>' non può nascondere un metodo dichiarato 'MustOverride'

Il metodo '<nomemetodo>' contiene più definizioni con firme identiche

'<nomemetodo>' non è accessibile in questo contesto perché il tipo restituito non è accessibile

'<modificatore>' non valido in un Declare

'<modificatore>' non valido in una dichiarazione Delegate

'<modificatore>' non valido in una dichiarazione di costante locale

'<modificatore>' non valido in una dichiarazione di variabile locale

'<modificatore>' non valido in una dichiarazione di metodo

'<modificatore>' non valido in una dichiarazione di evento

'<modificatore>' non valido in una dichiarazione Interface

'<nomemodulo>' è un modulo ed è impossibile farvi riferimento come a un assembly

Impossibile denominare '<nome>' come parametro in un identificatore di attributi perché non è né un campo né una proprietà

'<nome>' non può esporre il tipo delegato '<tipodelegato>' sottostante dell'evento che viene implementato all'esterno del progetto mediante <identificatore> '<tipo>'

'<nome>' non può esporre il tipo delegato '<tipodelegato>' sottostante dell'evento che viene implementato in <identificatore1> '<tipo1>' tramite <identificatore2> '<tipo2>'

'<nome>' non può esporre il tipo '<tipo>' utilizzato nel tipo delegato '<tipodelegato>' sottostante dell'evento implementato in <identificatore1> '<tipo1>' tramite <identificatore2> '<tipo2>'

'<nome>' non può esporre il tipo <tipo1> in <identificatore> <tipo2> '<nometipo>' tramite <nome>

'<nome>' non può esporre il tipo '<tipo1>' utilizzato nel tipo delegato '<tipodelegato>' sottostante dell'evento che viene implementato all'esterno del progetto mediante <identificatore> '<tipo2>'

'<nome>' non può riferirsi a se stesso attraverso l'istanza predefinita, si consiglia di utilizzare 'Me'

'<nome>' è già dichiarato come '<dichiarazione>' in questo <spaziodidichiarazione>

'<nome>' è già dichiarato come parametro di questo metodo

'<nome>' è ambiguo tra le dichiarazioni nei moduli '<nomemodulo1>' e '<nomemodulo2>'

'<nome>' è ambiguo negli oggetti applicazione '<elenco>'

'<nome>' è ambiguo nello spazio dei nomi '<nomespaziodeinomi>'

'<nome>' è dichiarato nel progetto '<nomeprogetto1>', a cui il progetto '<nomeprogetto2>' non fa riferimento

'<nome>' non è un membro di '<nomeclasse>'

Impossibile trovare '<nome>', necessario per la compilazione di questo costrutto

'<nome1>' è in conflitto con un <tipo> con lo stesso nome dichiarato in '<nome2>'

'<nome1>' per le importazioni '<nome2>' non si riferisce né a uno spazio dei nomi, né a una classe, né a una struttura, né a un'enumerazione, né a un modulo

'<nome1>' è ambiguo ed è importato dagli spazi dei nomi o dai tipi '<nome2>'

'<spaziodeinomi>' non è un nome valido e non può essere utilizzato come nome per lo spazio dei nomi di primo livello

'<nomespaziodeinomi>' è ambiguo

'<costantenull>' non è dichiarato

'<nomeparametro>' è già dichiarato come parametro di tipo di questo metodo

'<routine1>' e '<routine2>' non possono essere in rapporto di overload perché si differenziano solo per i parametri dichiarati 'ByRef' o 'ByVal'

'<nomeroutine>' non può eseguire l'override di '<nomeroutinedibase>' perché si differenziano per vincoli di parametro di tipo

'<nomeroutine>' contiene un tipo restituito non supportato o tipi di parametri non supportati

'<nomeroutine>' non ha parametri e il tipo restituito non può essere indicizzato

Il metodo '<nomeprocedura>' per l'evento '<nomeevento>' non può essere contrassegnato come compatibile con CLS perché il tipo che lo contiene '<nometipo>' non è compatibile con CLS

'<nomeprocedura1>' non può eseguire l'override di '<nomeprocedura2>' perché non è accessibile nel contesto corrente

<nomeroutine1> non può eseguire l'override di <nomeroutine2> per una differenza tra i parametri dichiarati 'ParamArray'

<firmaprocedura1> non è compatibile con CLS perché esegue l'overload di <firmaprocedura2> che differisce da esso solo per matrice del tipi di parametro matrice o per numero di dimensioni del tipi di parametro matrice

I parametri di <proprietà> non possono essere dichiarati 'ByRef'

'<proprietà1>' e '<proprietà2>' non possono essere in rapporto di overload perché solo uno è dichiarato 'Default'

'<nomeproprietà>' non può essere esposto a COM come proprietà 'Let'

La proprietà '<nomeproprietà>' definisce in modo implicito '<nomemembro>', che è in conflitto con un membro con lo stesso nome in <tipo> '<nometipo>'

'<nomeproprietà1>' non può eseguire l'override di '<nomeproprietà2>' perché si differenziano per 'ReadOnly' o 'WriteOnly'

'<metodoqualificato>' non è accessibile in questo contesto perché è '<modificatore>'

'<rsetstmt>' non è dichiarata

'<identificatore>' non valido in una dichiarazione di costante

'<identificatore>' non valido in una dichiarazione di variabile membro

'<identificatore>' non valido in una dichiarazione Structure

'<identificatore>' non valido in una dichiarazione WithEvents

'<identificatore>' non valido in una dichiarazione Enum

'<identificatore>' non valido in una dichiarazione di evento di interfaccia

'<identificatore>' non valido in una dichiarazione di metodo di interfaccia

'<identificatore>' non valido in una dichiarazione di proprietà di interfaccia

<identificatore1> <tipo> non può ereditare da <identificatore2> <tipo> perché espande l'accesso della <tipo> base

Impossibile combinare '<identificatore1>' con '<identificatore2>'

Richiesta una matrice nell'istruzione '<nomeistruzione>'

<tipo> '<nomemetodo>' è in conflitto con altri membri aventi lo stesso nome nella gerarchia di ereditarietà, quindi deve essere dichiarato 'Shadows'

<tipo> '<nometipo>' nasconde un metodo sottoponibile a override nella classe base

'<tipo>' non può essere ereditato più di una volta

I parametri <tipo> non possono essere dichiarati 'Optional'

I parametri <tipo> non possono essere dichiarati 'ParamArray'

<tipo1> '<nomemembro>' è in conflitto con <tipo2> '<nomemembro>' nella classe base <tipo3> '<nomeclasse>', quindi deve essere dichiarato 'Shadows'

<tipo1> '<nomemembro>' nasconde un membro che supporta l'overload dichiarato nella <tipo2> base '<nomeclasse>'

<tipo1> '<nomeproprietà>' è in conflitto con un membro dichiarato in modo implicito per l'evento '<nomeevento>' nella <tipo2> base '<nomeclasse>'

<tipo1> '<nometipo>' e <tipo2> '<nometipo>' sono in conflitto nello <spaziodeinomi> '<nomespaziodeinomi>'

<tipo1> '<nometipo>' e <tipo2> '<nometipo>', dichiarati in '<nome>', sono in conflitto nello <spaziodeinomi> '<nomespaziodeinomi>'

<tipo1> '<nometipo>' non può essere dichiarato 'Overrides' perché non esegue l'override di una <tipo1> in una <tipo2> base

<tipo1> '<nometipo1>' è in conflitto con un membro dichiarato in modo implicito per l'evento '<nomeevento>' in <tipo2> '<nometipo2>'

'<tipo1>' non può eseguire l'override di <tipo2> perché non è dichiarato 'Overridable'

<tipo1> '<nometipo>' deve implementare '<nomemembro>' per l'interfaccia '<nomeinterfaccia>'

<tipo1>'<nometipo>' deve implementare '<nomemetodo>' per l'interfaccia '<nomeinterfaccia>'

<nometipo> '<nomemembro>' deve essere dichiarato 'Shadows' perché un altro membro con lo stesso nome è dichiarato 'Shadows'

'<nometipo>' non può essere utilizzato come attributo perché non ha un attributo 'System.AttributeUsageAttribute'

'<nometipo>' non può essere utilizzato come attributo perché non eredita da 'System.Attribute'

Impossibile utilizzare '<nometipo>' come attributo perché contiene i metodi 'MustOverride' di cui non è stato eseguito l'override

Impossibile utilizzare '<nometipo>' come attributo perché è dichiarato 'MustInherit'

'<nometipo>' non può essere utilizzato come attributo perché non è una classe

'<nometipo>' non può ereditare da <tipo> '<nometipobase>' perché espande l'accesso del <tipo> base all'esterno dell'assembly

'<nometipo>' non può nascondere un metodo 'MustOverride' implicitamente dichiarato per la proprietà '<nomeproprietà>' in <tipo> '<nometipo>'

'<nometipo>' ha lo stesso nome di un altro tipo esposto in un gruppo 'My'

'<nometipo>' nell'assembly '<nomeassembly>' è stato inoltrato a se stesso, quindi non è un tipo supportato

'<nometipo>' è un tipo classe e non può essere utilizzato come espressione

'<nometipo>' è un tipo delegato

'<nometipo>' è un tipo generico e richiede argomenti di tipo

'<nometipo>' è uno spazio dei nomi e non può essere utilizzato come espressione

'<nometipo>' è un tipo struttura e non può essere utilizzato come espressione

'<nometipo>' è un tipo e non può essere utilizzato come espressione

'<nometipo>' è un tipo in '<nomecontenitore>' e non può essere utilizzato come espressione

'<nometipo>' è un tipo Enum non può essere utilizzato come espressione

'<nometipo>' è un tipo di interfaccia e non può essere utilizzato come espressione

'<nometipo>' è un tipo non supportato

'<nometipo>' deve essere dichiarato 'MustInherit' perché contiene metodi dichiarati 'MustOverride'

Impossibile convertire i valori '<nometipo>' in 'Char'

Impossibile convertire '<nometipo1>' in '<nometipo2>'

'<nomevariabile>' non è una variabile locale o un parametro e non può essere utilizzato come una variabile 'Catch'

Inferenza di <nomevariabile> non riuscita perché è una variabile locale statica

Previsto '=' (Dichiarazione)

Previsto '=' (assegnazione Let o Set)

Previsto '=' (inizializzatore di oggetto)

Previsto '>'

Impossibile dedurre un tipo nullable per la variabile '<nomevariabile>'

Il modificatore di accesso '<modificatoreaccesso>' non è valido

Un modificatore di accesso può essere applicato a 'Get' o 'Set', ma non a entrambi

Accesso di membro condiviso tramite un'istanza; l'espressione di qualificazione non verrà valutata

I parametri dei metodi 'AddHandler' e 'RemoveHandler' non possono essere dichiarati 'ByRef'

I parametri dei metodi 'AddHandler' e 'RemoveHandler' devono avere lo stesso tipo delegato dell'evento che li contiene

I metodi 'AddHandler' e 'RemoveHandler' devono avere esattamente un parametro

La dichiarazione 'AddHandler' deve terminare con un 'End AddHandler' corrispondente

Definizione 'AddHandler' mancante per l'evento '<nomeevento>'

'AddHandler' è già dichiarato

L'operando di evento dell'istruzione 'AddHandler' o 'RemoveHandler' deve essere un'espressione completa di punto o un nome semplice

I parametri dei metodi 'AddHandler', 'RemoveHandler' e 'RaiseEvent' non possono essere dichiarati '<modificatore>'

Impossibile applicare 'AddressOf' a 'methodname' perché 'methodname' è un metodo parziale

L'espressione 'AddressOf' non può essere convertita in '<nometipo>' perché '<nometipo>' non è un tipo delegato

L'espressione 'AddressOf' non può essere convertita in '<nometipo>' perché il tipo '<nometipo>' è dichiarato 'MustInherit' ed è impossibile crearlo

Espressioni 'AddressOf' non valide nelle finestre di debug

Espressioni 'AddressOf' non valide nella prima espressione di un'istruzione 'Select Case'

L'operando 'AddressOf' deve essere il nome di un metodo, senza parentesi

Impossibile utilizzare il nome della funzione di aggregazione con un carattere tipo.

L'alias '<nomespaziodeinomi>' è già dichiarato

Se un parametro è tipizzato, allora devono esserlo tutti i parametri

Tutti i progetti in una soluzione Visual Basic devono avere la stessa piattaforma di destinazione. Il progetto che si tenta di aggiungere ha come destinazione una piattaforma da quella specificata per la soluzione

Impossibile utilizzare un'espressione incorporata

Previsto 'And'

Inizializzatori di tipo anonimo non validi nelle finestre di debug

Il nome di membro di tipo anonimo può essere dedotto solo da un nome semplice o completo senza argomenti

Il nome membro di tipo anonimo deve essere preceduto da un punto

Proprietà o membro di tipo anonimo '<nomeproprietà>' già dichiarato

Impossibile utilizzare la proprietà di membro di tipo anonimo '<nomeproprietà>' per dedurre il tipo di un'altra proprietà di membro perché il tipo di '<nomeproprietà>' non è ancora stabilito

Il tipo anonimo deve contenere almeno un membro

Impossibile utilizzare la proprietà di tipo anonimo "<nomeproprietà>" nella definizione di un'espressione lambda nello stesso elenco di inizializzazione

Il parametro '<nomeparametro>' corrispondente all'argomento viene convertito da '<tipo1>' a '<tipo2>' più piccolo

Il parametro '<nomeparametro>' corrispondente all'argomento viene convertito in '<nometipo>'

Argomento non specificato per il parametro '<nomeparametro>'

Argomento non specificato per il parametro '<nomeparametro>' di '<nomemetodo>'

Argomento non specificato per il parametro '<nomeparametro>' del metodo di estensione '<nomemetodo>' definito in '<nometipo>'

Impossibile passare argomenti a un 'New' utilizzato in un parametro di tipo

I limiti di matrice non possono trovarsi negli identificatori di tipo

Le dichiarazioni di matrice non possono specificare limiti inferiori

La matrice dichiarata come variabile per il controllo del ciclo non può essere dichiarata con dimensione iniziale

Le dimensioni di una matrice non possono essere negative

La matrice supera il limite di 32 dimensioni

Impossibile specificare l'inizializzatore di matrici per una dimensione non costante. Utilizzare l'inizializzatore vuoto '{}'

L'inizializzatore ha <numero> elementi in eccesso

Dimensioni insufficienti per l'inizializzatore di matrici

Troppe dimensioni per l'inizializzatore di matrici

<numero> elementi mancanti nell'inizializzatore di matrice

Gli inizializzatori di matrici sono validi solo per le matrici, ma il tipo di '<nomevariabile>' è '<nometipo>'

I limiti inferiori della matrice possono essere solo '0'

Impossibile specificare modificatori di matrici sia sulla variabile che sul tipo

Impossibile specificare modificatori di matrici nel nome di parametro dell'espressione lambda. Specificarli nel relativo tipo.

Espressione di indice di matrice mancante

Le matrici non possono essere dichiarate con 'New'

Le matrici dichiarate come membri di struttura non possono essere dichiarate con una grandezza iniziale

Le matrici di tipo 'System.Void' non sono consentite in questa espressione

Per specificare in modo esplicito i valori per tutti gli elementi sono necessarie matrici utilizzate come argomenti di attributo

'As Any' non è supportato nelle istruzioni 'Declare'

Previsto 'As'

Previsto 'As', virgola o ")"

Impossibile creare l'assembly '<nomeassembly>' perché il percorso è più lungo di 259 caratteri

L'assembly '<percorsofile1>' fa riferimento all'assembly '<identitàassembly>' che è ambiguo tra '<percorsofile2>' (a cui fa riferimento il progetto '<nomeprogetto1>') e '<percorsofile3>' (a cui fa riferimento il progetto '<nomeprogetto2>')

L'assembly '<percorsofile1>' fa riferimento all'assembly '<identitàassembly>' che è ambiguo tra '<percorsofile2>' e '<percorsofile3>'

Attributo di assembly '<nomeattributo>' non valido: <errore>

Le istruzioni di attributi Assembly o Module devono precedere tutte le dichiarazioni di un file

Previsto 'Assembly' o 'Module'

Almeno uno dei tipi di parametri di questo operatore binario deve essere il tipo '<nometipo>' che lo contiene

Impossibile applicare più volte l'attributo '<nomeattributo>'

Impossibile applicare l'attributo '<nomeattributo>' a '<nomemembro>'. Attributo non valido per questo tipo di dichiarazione.

Impossibile applicare l'attributo '<nomeattributo>' a un metodo con parametri facoltativi

Impossibile applicare l'attributo '<nomeattributo>' a un modulo

Impossibile applicare l'attributo '<nomeattributo>' a un assembly

L'attributo '<nomeattributo>' non può essere specificato più di una volta nel progetto, anche con valori di parametro identici

Attributo '<nomeattributo>' non valido: <errore>

Impossibile utilizzare l'attributo perché non contiene un costruttore Public

L'attributo 'Conditional' è valido solo nelle dichiarazioni 'Sub'

La costante di attributo '<nomecostante>' non può essere la destinazione di un'assegnazione

Il costruttore di attributo ha un parametro 'ByRef' di tipo '<nometipo>'. Impossibile utilizzare i costruttori con parametri byref per applicare l'attributo

Il costruttore di attributo ha un parametro di tipo '<tipo>', che non è di tipo integrale, a virgola mobile o Enum e neppure di tipo Char, String, Boolean o System.Type né matrice unidimensionale di questi tipi

Il membro di attributo '<nomemembro>' non può essere la destinazione di un'assegnazione perché non è dichiarato 'Public'

L'identificatore di attributi non è un'istruzione completa

L'attributo 'System.Runtime.InteropServices.DefaultCharSetAttribute' non è supportato in questa versione

Valore di attributo non valido. Previsto 'value'.

Valore di attributo non valido. Previsto 'value1' o 'value2'.

Impossibile applicare gli attributi alle variabili locali

Impossibile applicare attributi a parametri delle espressioni lambda

Gli attributi non possono essere generics o tipi nidificati all'interno di generics

Valore checksum non valido. Cifre esadecimali non presenti o in numero dispari

Formato GUID non valido

Formato XML non valido. Impossibile includere il file '<filecommento>'

La classe base '<nomeclassebase1>' specificata per la classe '<nomeclasseparziale>' non può essere differente dalla classe base '<nomeclassebase2>' di uno degli altri tipi parziali

I limiti possono essere specificati solo per la matrice di primo livello durante l'inizializzazione di una matrice di matrici

Parentesi di chiusura ']' mancante nell'identificatore tra parentesi

Diramazioni all'esterno di 'Finally' non valide

Previsto 'By'

Impossibile utilizzare il parametro 'ByRef' '<nomeparametro>' in un'espressione lambda

Impossibile utilizzare il parametro 'ByRef' <nomeparametro> in un'espressione di query

Impossibile combinare 'ByVal' e 'ByRef'

Impossibile convertire il tipo anonimo in una struttura ad albero dell'espressione. Il tipo anonimo contiene un campo utilizzato nell'inizializzazione di un altro campo.

Impossibile convertire in '<tipo>'

Impossibile convertire 'type1' in 'type2'

Impossibile copiare il valore del parametro 'ByRef' '<nomeparametro>' nell'argomento corrispondente perché il tipo '<nometipo1>' non può essere convertito nel tipo '<nometipo2>'

Impossibile creare un'istanza del modulo '<nomemodulo>'

Impossibile trovare la directory di .NET Framework: <errore>

Impossibile implementare l'interfaccia '<nomeinterfaccia1>.<nomemembro>'. La sua implementazione potrebbe essere in conflitto con l'implementazione di un'altra interfaccia implementata '<nomeinterfaccia2>.<nomemembro2>' per alcuni argomenti di tipo

Impossibile eseguire l'implementazione dell'interfaccia '<nomeinterfaccia1>' perché potrebbe essere in conflitto con l'implementazione di un'altra interfaccia '<nomeinterfaccia2>' per alcuni argomenti di tipo

Impossibile dedurre un tipo comune per il primo e il secondo operando dell'operatore 'If' binario

Impossibile dedurre un tipo comune per il secondo e il terzo operando dell'operatore 'If'

Impossibile dedurre un tipo di dati per '<nomevariabile>' perché le dimensioni di matrice non corrispondono

Impossibile ereditare l'interfaccia '<nomeinterfaccia1>' poiché potrebbe essere identica all'interfaccia '<nomeinterfaccia2>' per alcuni tipi di argomenti

Impossibile ereditare l'interfaccia '<nomeinterfaccia1>' perché potrebbe essere identica all'interfaccia '<nomeinterfaccia2>' da cui l'interfaccia '<nomeinterfaccia3>' eredita, per alcuni tipi di argomenti

Impossibile ereditare l'interfaccia '<nomeinterfaccia1>' perché l'interfaccia '<nomeinterfaccia2>' da cui eredita potrebbe essere identica all'interfaccia '<nomeinterfaccia3>' per alcuni tipi di argomenti

Impossibile ereditare l'interfaccia '<nomeinterfaccia1>' perché l'interfaccia '<nomeinterfaccia2>' da cui eredita potrebbe essere identica all'interfaccia '<nomeinterfaccia3>', da cui l'interfaccia '<nomeinterfaccia4>' eredita, per alcuni tipi di argomenti

Impossibile fare riferimento a '<nome>' perché è un membro del campo di valori '<nome>' della classe '<nomeclasse>' che ha 'System.MarshalByRefObject' come classe base

Impossibile fare riferimento a un membro di istanza di una classe all'interno di un metodo condiviso o di un inizializzatore di membri condivisi senza un'istanza esplicita della classe

Impossibile inviare automaticamente la segnalazione errori

Impossibile impostare il valore di una variabile locale per un metodo che non si trova in cima allo stack

Impossibile specificare sia /win32icon che /win32resource

Impossibile aprire '<nomefile>' per la scrittura.

'Case' può trovarsi solo all'interno di un'istruzione 'Select Case'

'Case' non può seguire 'Case Else' nella stessa istruzione 'Select'

'Case Else' può trovarsi solo all'interno di un'istruzione 'Select Case'

Istruzioni 'Case' non valide nella finestra di controllo immediato

La combinazione di maiuscole e minuscole nel nome dello spazio dei nomi '<nomespaziodeinomi1>' non corrisponde a quella del nome dello spazio dei nomi '<nomespaziodeinomi2>' nel file '<percorsofile>'

Blocco 'Catch' mai raggiunto perché '<nome1>' eredita da '<nome2>'

Blocco 'Catch' mai raggiunto; <eccezione> gestita sopra nella stessa istruzione Try

'Catch' non può trovarsi dopo 'Finally' in un'istruzione 'Try'

Un'istruzione 'Catch' non può trovarsi all'esterno di un'istruzione 'Try'

'Catch' non può intercettare il tipo '<nometipo>' perché non è 'System.Exception' o una classe che eredita da 'System.Exception'

'Catch' deve terminare con un 'End Try' corrispondente

Istruzioni 'Catch' non valide nella finestra di controllo immediato

Impossibile convertire i valori 'Char' in '<nometipo>'

Carattere 'character' (0x<esadecimale>) non consentito all'inizio di un nome XML

Carattere 'character' (0x<esadecimale>) non consentito in un nome XML

Carattere 'character' (0x<esadecimale>) non consentito in un valore letterale XML

La costante carattere deve contenere esattamente un carattere

Carattere non valido

Sequenza di caratteri '--' non consentita in un commento XML

Impossibile trovare la classe '<nomeclasse>'

La classe '<nomeclasse>' non può essere indicizzata perché non contiene proprietà predefinite

La classe '<nomeclasse>' non può ereditare da se stessa: <messaggio>

Impossibile creare la classe '<nomeclasse>': <errore>

La classe '<nomeclasse>' non dispone di 'Sub New' accessibili e non può essere ereditata

La classe '<nomeclasse>' deve dichiarare un 'Sub New' perché la relativa classe base '<nomeclasse2>' non contiene un costruttore accessibile 'Sub New' che possa essere chiamato senza argomenti

La classe '<nomeclasse>' deve dichiarare un 'Sub New' perché '<nomecostruttore>' nella relativa classe base '<nomeclassebase>' è contrassegnato come obsoleto

La classe '<nomeclasse>' deve dichiarare un 'Sub New' perché '<nomecostruttore>' nella relativa classe base '<nomeclassebase>' è contrassegnato come obsoleto: '<messaggioerrore>'

La classe '<nomeclasse>' deve essere dichiarata 'MustInherit' oppure eseguire l'override dei seguenti membri 'MustOverride' ereditati: '<nomimembri>'

La classe '<nomeclasse>' deve dichiarare un 'Sub New' perché '<nomecostruttore>' nella relativa classe base '<nomeclassedibase>' è contrassegnato come obsoleto

La classe '<nomeclasse>' deve dichiarare un 'Sub New' perché '<nomecostruttore>' nella relativa classe base '<nomeclassedibase>' è contrassegnato come obsoleto: '<messaggioerrore>'

La classe '<nomeclasse1>' deve dichiarare un 'Sub New' perché la relativa classe base '<nomeclasse2>' contiene più di un 'Sub New' accessibile che può essere chiamato senza argomenti

Impossibile combinare il vincolo 'Class' e uno specifico vincolo di tipo di classe

Impossibile combinare il vincolo 'Class' e il vincolo 'Structure'

Il vincolo 'Class' non può essere specificato più volte per lo stesso parametro di tipo

La classe di un'interfaccia non può essere dichiarata '<identificatore>'

L'istruzione 'Class' deve terminare con un 'End Class' corrispondente

L'evento 'Class_Initialize' non è più supportato

L'evento 'Class_Terminate' non è più supportato

Le classi possono ereditare solo da altre classi

Le classi non possono essere dichiarate '<identificatore>'

Le classi generiche o che sono contenute in un tipo generico non possono ereditare da una classe Attribute

Tabella codici '<nome>' non valida o non installata.

Prevista virgola

Prevista virgola o ')'

Prevista virgola o ')' (Elenco di argomenti di tipo)

Prevista virgola o ')' (Elenco di parametri di tipo)

Prevista una virgola, ')' o una continuazione di espressione valida

Impossibile valutare le istruzioni di commento.

Previsto 'Compare'

Compilazione non riuscita: <messaggio>

Conflitto tra la proprietà predefinita e 'DefaultMemberAttribute' definito in '|1'

Conflitti con '<nome1>' dichiarato in modo implicito per '<nome2>' in <tipo> '<nome3>'

La dichiarazione Const non può contenere un inizializzatore di matrice

La costante '<nomecostante>' non può dipendere dal proprio valore

Una costante non può essere la destinazione di un'assegnazione

Necessaria espressione costante

Espressione costante non rappresentabile nel tipo '<nometipo>'

Le costanti devono essere di tipo intrinseco o enumerato, non di tipo classe, struttura, parametro di tipo o matrice

Le costanti devono avere un valore

Il vincolo '<vincolo1>' è in conflitto con il vincolo '<vincolo2>' già specificato per il parametro di tipo '<nomeparametrotipo>'

Il vincolo '<vincolo1>' è in conflitto con il vincolo indiretto '<vincolo2>' ottenuto dal vincolo del parametro di tipo '<parametroditipo1>'

Tipo di vincolo '<nometipo>' già specificato per questo parametro di tipo

I vincoli per questo parametro di tipo non corrispondono ai vincoli per il parametro di tipo corrispondente definito in uno degli altri tipi parziali di '|1'

Il costrutto contiene un riferimento indiretto all'assembly '<nomeassembly>' che contiene '<nometipo>'

Il costrutto contiene un riferimento indiretto al progetto '<nomeprogetto>' che contiene '<nometipo>'

Il costruttore '<nome>' non può chiamare se stesso

Una chiamata a un costruttore è valida solo come prima istruzione in un costruttore di istanza

Il costruttore deve essere dichiarato come Sub e non come Function

I costruttori non possono implementare metodi di interfaccia

'Continue Do' può trovarsi solo all'interno di un'istruzione 'Do'

'Continue For' può trovarsi solo all'interno di un'istruzione 'For'

'Continue' deve essere seguito da 'Do', 'For' o 'While'

Istruzioni 'Continue' non valide nella finestra di controllo immediato

'Continue While' può trovarsi solo all'interno di un'istruzione 'While'

In un'espressione costante non può verificarsi una conversione da '<tipo1>' a '<tipo2>'

In un'espressione costante utilizzata come argomento di un attributo non può verificarsi la conversione da '<tipo1>' a '<tipo2>'

La conversione da 'Date' a 'Double' richiede la chiamata del metodo 'Date.ToOADate'

La conversione da 'Double' a 'Date' richiede la chiamata del metodo 'Date.FromOADate'

Gli operatori di conversione non possono convertire da un tipo di base

Gli operatori di conversione non sono in grado di convertire da un tipo derivato

Gli operatori di conversione non possono convertire un tipo nel relativo tipo di base

Gli operatori di conversione non possono convertire un tipo nel relativo tipo derivato

Gli operatori di conversione non possono convertire un tipo nello stesso tipo

Gli operatori di conversione non possono convertire da un tipo interfaccia

Gli operatori di conversione non possono convertire da Object

Gli operatori di conversione non possono convertire a un tipo interfaccia

Gli operatori di conversione non possono convertire all'Oggetto

Gli operatori di conversione devono essere dichiarati 'Widening' o 'Narrowing'

Le conversioni da '<nometipo1>' a '<nometipo2>' devono essere esplicite

Copiando il valore del parametro 'ByRef' '<nomeparametro>' nell'argomento corrispondente viene eseguita la conversione dal tipo '<nometipo1>' a '<nometipo2>', più piccolo

Impossibile trovare la libreria '<nomelibreria>'

Impossibile trovare la libreria standard '<nomefile>'

Il tipo 'Currency' non è più supportato. Utilizzare il tipo 'Decimal'

'Custom Event' deve terminare con un 'End Event' corrispondente

Il modificatore 'Custom' può essere utilizzato solo subito prima di una dichiarazione 'Event'

Modificatore 'Custom' non valido negli eventi dichiarati nelle interfacce

Modificatore 'Custom' non valido negli eventi dichiarati senza tipi delegati espliciti

Non è più possibile utilizzare 'D' per indicare un esponente. Utilizzare 'E'.

Impossibile dedurre da questi argomenti i tipi di dati dei parametri di tipo

Impossibile dedurre da questi argomenti i tipi di dati dei parametri di tipo perché sono possibili più tipi

Impossibile dedurre da questi argomenti i tipi di dati dei parametri di tipo perché non vengono convertiti nello stesso tipo.

Impossibile dedurre da questi argomenti i tipi di dati dei parametri di tipo nel metodo di estensione '<nomemetodo>' definito in '<nometipo>'

Impossibile dedurre da questi argomenti i tipi di dati dei parametri di tipo nel metodo di estensione '<nomemetodo>' definito in '<nometipo>' perché sono possibili più tipi

Impossibile dedurre da questi argomenti i tipi di dati dei parametri di tipo nel metodo di estensione '<nomemetodo>' definito in 'typename' perché non vengono convertiti nello stesso tipo

Impossibile dedurre da questi argomenti i tipi di dati dei parametri di tipo nel metodo '<nomemetodo>'

Impossibile dedurre da questi argomenti i tipi di dati dei parametri di tipo nel metodo '<nomemetodo>' perché sono possibili più tipi

Impossibile dedurre da questi argomenti i tipi di dati dei parametri di tipo nel metodo '<nomemetodo>' perché non vengono convertiti nello stesso tipo

Costante di data non valida

Prevista dichiarazione

Le istruzioni 'Declare' non sono consentite in tipi generici o in tipi contenuti in tipi generici

Le istruzioni Declare in un modulo non possono essere dichiarate '<identificatore>'

Le istruzioni 'Declare' in una struttura non possono essere dichiarate '<identificatore>'

'Default' può essere applicato solo a un nome di proprietà in una <tipo>

Impossibile combinare 'Default' con '<identificatore>'

Il membro predefinito '<nomemembro>' non è una proprietà

La proprietà predefinita '<nomeproprietà1>' è in conflitto con la proprietà predefinita '<nomeproprietà2> nella base '<nomeclasse>', quindi deve essere dichiarata 'Shadows'

L'accesso a una proprietà predefinita è ambiguo tra i membri di interfaccia ereditati '<nomeproprietàpredefinita>' dell'interfaccia '<nomeinterfaccia1>' e '<nomeproprietàpredefinita>' dell'interfaccia '<nomeinterfaccia2>'

Impossibile specificare i valori predefiniti per i parametri che non sono dichiarati 'Optional'

La definizione del metodo <metodo> non è accessibile in questo contesto

La classe delegata '<nomeclasse>' non contiene un metodo Invoke. Un'espressione di questo tipo non può essere la destinazione di una chiamata al metodo

Impossibile trovare il costruttore di delegato per il tipo '<nometipo>', necessario per l'implementazione dei delegati

Il delegato di un'interfaccia non può essere dichiarato '<identificatore>'

Il tipo delegato '<nomedelegato>' dell'evento '<nomeevento>' non è compatibile con CLS

I delegati non possono gestire gli eventi

I delegati non possono implementare metodi di interfaccia

Le classi derivate non possono generare eventi di classe base

Divisione per zero durante la valutazione dell'espressione

'Do' deve terminare con un 'Loop' corrispondente

Attributo XML 'attributeName' duplicato

Il tipo di parametro o il tipo restituito di questo operatore di conversione deve essere il tipo che lo contiene

Tag di fine mancante nell'elemento

Impossibile utilizzare il prefisso 'xmlns' nei nomi di elemento

'Else' deve essere preceduto da un 'If' o da un 'ElseIf' corrispondente

'ElseIf' deve essere preceduto da un 'If' o 'ElseIf' corrispondente

'End AddHandler' deve essere preceduto da una dichiarazione 'AddHandler' corrispondente

'End AddHandler' deve essere la prima istruzione in una riga

'End Class' deve essere preceduto da un 'Class' corrispondente

'End Enum' deve essere preceduto da un 'Enum' corrispondente

'End Event' deve essere preceduto da un 'Custom Event' corrispondente

Previsto 'End Function'

'End Function' deve essere preceduto da un 'Function' corrispondente

'End Function' deve essere la prima istruzione in una riga

'End Get' deve essere preceduto da un 'Get' corrispondente

'End Get' deve essere la prima istruzione in una riga

'End If' deve essere preceduto da un 'If' corrispondente

'End Interface' deve essere preceduto da un 'Interface' corrispondente

'End Module' deve essere preceduto da un 'Module' corrispondente

'End Namespace' deve essere preceduto da un 'Namespace' corrispondente

Prevista fine dell'espressione

Prevista fine dell'elenco parametri

Prevista fine dell'istruzione

Previsto 'End Operator'

'End Operator' deve essere preceduta da un 'Operator' corrispondente

'End Operator' deve essere la prima istruzione in una riga

'End Property' deve essere preceduto da un 'Property' corrispondente

'End RaiseEvent' deve essere preceduto da una dichiarazione 'RaiseEvent' corrispondente

'End RaiseEvent' deve essere la prima istruzione in una riga

'End RemoveHandler' deve essere preceduto da una dichiarazione 'RemoveHandler' corrispondente

'End RemoveHandler' deve essere la prima istruzione in una riga

'End Select' deve essere preceduto da un 'Select Case' corrispondente

'End Set' deve essere preceduto da un 'Set' corrispondente

'End Set' deve essere la prima istruzione in una riga

L'istruzione 'End' non può essere utilizzata nei progetti Libreria di classi

Istruzione 'End' non valida

Istruzioni 'End' non valide nella finestra di controllo immediato

'End Structure' deve essere preceduto da uno 'Structure' corrispondente

Previsto 'End Sub'

'End Sub' deve essere preceduto da un 'Sub' corrispondente

'End Sub' deve essere la prima istruzione in una riga

'End SyncLock' deve essere preceduto da un 'SyncLock' corrispondente

Previsto tag di fine </nometag>

'End Try' deve essere preceduto da un 'Try' corrispondente

'End Using' deve essere preceduto da un 'Using' corrispondente

'End While' deve essere preceduto da un 'While' corrispondente

'End With' deve essere preceduto da un 'With' corrispondente

Le istruzioni 'EndIf' non sono più supportate. Utilizzare 'End If'

L'enumerazione '<nomeenumerazione>' deve contenere almeno un membro

L'enumeratore di un'interfaccia non può essere dichiarato '<identificatore>'

'Enum' deve terminare con un 'End Enum' corrispondente

I tipi Enum non possono essere nullable

I valori Enum devono essere dichiarati come tipo integrale

'Equals' non può confrontare un valore di tipo <tipo1> con un valore di tipo <tipo2>

Previsto 'Equals'.

Errore durante la creazione del manifesto dell'assembly: <messaggio di errore>

Errore durante la creazione delle risorse Win32: <messaggio di errore>

Errore durante l'incorporamento del manifesto Win32: <manifesto>

Errore durante l'incorporamento del manifesto Win32: impossibile trovare il file manifesto <file>.

Errore durante l'incorporamento del manifesto Win32: l'opzione /win32manifest è in conflitto con /nowin32manifest

Errore a livello di progetto nell'importazione '<nomeelementoqualificato>' in '<nomecontenitorequalificato>': <messaggioerrore>

Errore durante il salvataggio del file di risorse Win32 temporaneo '<nomefile>': <messaggio di errore>

Errore durante l'impostazione di un'opzione del manifesto dell'assembly: <messaggio di errore>

Istruzioni 'Error' non valide nella finestra di controllo immediato

Errori durante la compilazione degli schemi XML nel progetto

Valutazione dell'espressione o dell'istruzione interrotta

Timeout della valutazione dell'espressione o dell'istruzione

Valutazione delle espressioni lambda non valida nel debugger

Impossibile trovare l'evento '<nomeevento>'

Impossibile gestire l'evento '<nomeevento>' perché non è accessibile da '<nome>'

L'evento '<nomeevento>' specificato dall'attributo 'DefaultEvent' non è un evento accessibile pubblicamente per questa classe

L'evento '<nomeevento>' dichiara in modo implicito '<nomemembro>', che è in conflitto con un membro della base '<nomeclasse>' '<tipo>'. L'evento deve essere quindi dichiarato 'Shadows'.

L'evento '<nomeevento1>' non può implementare l'evento '<nomeevento2>' perché il relativo tipo delegato non corrisponde al tipo delegato di un altro evento implementato da '<nomeevento1>'

L'evento '<nomeevento1>' non può implementare l'evento '<nomeevento2>' nell'interfaccia '<interfaccia>' poiché i tipi delegati '<delegato1>' e '<delegato2>' non corrispondono

La lunghezza del nome dell'evento non può superare i 1011 caratteri

Impossibile dichiarare gli eventi con un tipo delegato che ha un tipo restituito

Gli eventi non possono avere un tipo restituito

Gli eventi dichiarati con una clausola 'As' devono avere un tipo delegato

Gli eventi di un modulo non possono essere dichiarati '<identificatore>'

Gli eventi nelle interfacce non possono essere dichiarati '<implements>'

Impossibile gestire gli eventi delle variabili WithEvents condivise mediante metodi non condivisi

'Exit AddHandler', 'Exit RemoveHandler' e 'Exit RaiseEvent' non sono validi

'Exit Do' può trovarsi solo all'interno di un'istruzione 'Do'

'Exit For' può trovarsi solo all'interno di un'istruzione 'For'

'Exit Function' non valida in Sub o Property

'Exit' deve essere seguito da 'Sub', 'Function', 'Property', 'Do', 'For', 'While', 'Select' o 'Try'

'Exit Operator' non è valido. Utilizzare 'Return' per uscire da un operatore.

'Exit Property' non valida in Function o Sub

'Exit Select' può trovarsi solo all'interno di un'istruzione 'Select'

Istruzioni 'Exit' non valide nella finestra di controllo immediato

'Exit Sub' non valida in Function o Property

'Exit Try' può trovarsi solo all'interno di un'istruzione 'Try'

'Exit While' può trovarsi solo all'interno di un'istruzione 'While'

Previsto '%=' all'inizio di un'espressione incorporata

Previsto '/' per un tag di fine XML

Previsto '<' di apertura per un tag XML

Previsto '%>' di chiusura per un'espressione incorporata

Previsto ';' di chiusura per un'entità XML

Previsto '?>' di chiusura per un'istruzione del processore XML

Previsto ']]>' di chiusura per una sezione XML CDATA

Previsto '-->' di chiusura per un commento XML

Previsto '>' di chiusura per un tag XML

Previste virgolette di chiusura corrispondenti per un valore di attributo XML

Previsto apostrofo di chiusura corrispondente per un valore di attributo XML

Previsto un elemento 'Dim', 'Const', 'Public', 'Private', 'Protected', 'Friend', 'Shadows', 'ReadOnly' o 'Shared'

Inizializzazione esplicita non consentita per matrici dichiarate con limiti espliciti

Inizializzazione esplicita non consentita con più variabili dichiarate con un singolo specificatore di tipo

Esponente non valido

Un'espressione incorporata non può essere inclusa in un valore di attributo tra virgolette

Impossibile convertire l'espressione in una struttura ad albero dell'espressione

Impossibile valutare l'espressione in questo momento

L'espressione non produce un valore

Prevista espressione

L'espressione è di tipo '<nometipo>' che corrisponde a un tipo limitato e non può essere utilizzato per accedere ai membri ereditati da 'Object' o 'ValueType'

L'espressione è un valore, quindi non può essere la destinazione di un'assegnazione

L'espressione non è un metodo

L'espressione non è una matrice o un metodo e non può avere un elenco di argomenti

L'espressione è di tipo '<nometipo>', che non è un tipo insieme

L'espressione di tipo <tipo> non può essere sottoposta a query

Impossibile convertire l'espressione di tipo '<nometipo>' in "Object" o "ValueType"

L'espressione di tipo '<nometipo1>' non può essere di tipo '<nometipo2>'

Espressione o istruzione non valida nelle finestre di debug

L'espressione chiama in modo ricorsivo l'operatore '<simboloperatore>' che la contiene

L'espressione chiama in modo ricorsivo la proprietà '<nomeproprietà>' che la contiene

È possibile applicare l'attributo 'Extension' solo alle dichiarazioni 'Module', 'Sub' o 'Function'

Il metodo di estensione '<nomemetodo>' definito in '<nomemodulo>' non dispone di una firma compatibile con il delegato '<nomedelegato>'

Il metodo di estensione '<nomemetodo>' definito in '<nomemodulo>' non è generico o non ha parametri di tipo disponibili e quindi non può avere argomenti di tipo

Il metodo di estensione '<Nomemetodo>' definito in '<Nometipo>' non ha la stessa firma del delegato '<Nomedelegato>'

I vincoli di tipo del metodo di estensione '<nomemetodo>' non possono mai essere soddisfatti

I metodi di estensione possono essere definiti solo nei moduli

I metodi di estensione devono dichiarare almeno un parametro

Il campo '<nomecampo>' è di tipo non supportato

Impossibile trovare il campo o la proprietà '<nomemembro>'

Impossibile trovare il file <nomefile>

Il nome di file è già dichiarato con un valore differente per checksum e GUID

Un'istruzione 'Try' non può contenere più di un'istruzione 'Finally'

Un'istruzione 'Finally' non può trovarsi all'esterno di un'istruzione 'Try'

'Finally' deve terminare con un 'End Try' corrispondente

Istruzioni 'Finally' non valide nella finestra di controllo immediato

Il primo operando in un'espressione 'If' binaria deve essere nullable o un tipo riferimento

La prima istruzione del corpo di un metodo non può essere sulla stessa riga della dichiarazione del metodo

La prima istruzione di questo 'Sub New' deve essere una chiamata a 'MyBase.New' o a 'MyClass.New' (più costruttori accessibili senza parametri)

La prima istruzione di questo 'Sub New' deve essere una chiamata a 'MyBase.New' o a 'MyClass.New' (nessun costruttore accessibile senza parametri)

La prima istruzione di questo 'Sub New' deve essere una chiamata esplicita a 'MyBase.New' o a 'MyClass.New' perché '<nomecostruttore>' nella classe base '<nomeclassebase>' di '<nomeclassederivata>' è contrassegnato come obsoleto

La prima istruzione di questo 'Sub New' deve essere una chiamata esplicita a 'MyBase.New' o a 'MyClass.New' perché '<nomecostruttore>' nella classe base '<nomeclassebase>' di '<nomeclassederivata>' è contrassegnato come obsoleto: '<messaggioerrore>'

La prima istruzione di questo 'Sub New' deve essere una chiamata esplicita a 'MyBase.New' o a 'MyClass.New' perché '<nomecostruttore>' nella classe base '<nomeclassebase>' di '<nomeclassederivata>' è contrassegnato come obsoleto.

La prima istruzione di questo 'Sub New' deve essere una chiamata esplicita a 'MyBase.New' o a 'MyClass.New' perché '<nomecostruttore>' nella classe base '<nomeclassebase>' di '<nomeclassederivata>' è contrassegnato come obsoleto: '<messaggioerrore>'

For Each' sul tipo '<nometipo>' è ambiguo perché il tipo implementa più creazioni di istanza di 'System.Collections.Generic.IEnumerable(Of T)'

Variabile di controllo del ciclo For '<nomevariabile>' già in uso da un ciclo For di inclusione

Variabile di controllo del ciclo 'For' già in uso da un ciclo 'For' di inclusione

La variabile di controllo del ciclo 'For' non può essere di tipo '<tipo>'

'For' deve terminare con un 'Next' corrispondente

Il riferimento all'assembly Friend <riferimento> non è valido

Il riferimento all'assembly Friend <riferimento> non è valido. Nelle dichiarazioni InternalsVisibleTo non è possibile specificare la versione, le impostazioni cultura, il token di chiave pubblica o l'architettura del processore.

I caratteri a larghezza intera non sono validi come delimitatori XML

I nomi completi dei tipi negli spazi dei nomi non possono contenere più di <numero> caratteri

La funzione '<nomeroutine>' non restituisce un valore in tutti i percorsi del codice

Valutazione della funzione disattivata a causa del timeout di una valutazione di funzione precedente

Funzione senza clausola 'As'. Verrà utilizzato il tipo restituito Object

I metodi generici non possono essere esposti al COM

I metodi generici non possono utilizzare la clausola 'Handles'

Il tipo di vincolo <nometipo> per il parametro generico non è compatibile con CLS

I parametri generici utilizzati come tipi di parametri facoltativi devono essere vincolati a livello di classe

Impossibile importare più volte il tipo generico '<nometipogenerico>'

La funzione di accesso 'Get' della proprietà '<nomeproprietà>' non è accessibile

'Get' è già dichiarato

L'istruzione 'Get' deve terminare con un 'End Get' corrispondente

Le istruzioni 'Get' non sono più supportate

Le istruzioni 'Get' non sono più supportate (Visual Basic)

'Global' deve essere seguito da '.' e da un identificatore

'Global' non consentito in handle; previsto nome locale

'Global' non consentito in questo contesto; previsto identificatore

Le istruzioni 'GoSub' non sono più supportate

'GoTo <nomeetichetta>' non è valida perché '<nomeetichetta>' si trova all'interno di un'istruzione 'For' o 'For Each' che non contiene questa istruzione

'GoTo <nomeetichetta>' non è valida perché '<nomeetichetta>' si trova all'interno di un'istruzione 'SyncLock' che non contiene questa istruzione

'GoTo <nomeetichetta>' non è valida perché '<nomeetichetta>' si trova all'interno di un'istruzione 'Try', 'Catch' o 'Finally' che non contiene questa istruzione

'GoTo <nomeetichetta>' non è valida perché '<nomeetichetta>' si trova all'interno di un'istruzione 'With' che non contiene questa istruzione

'GoTo <etichettariga>' non è valida perché '|1' si trova all'interno di un'istruzione 'Using' che non contiene questa istruzione

Istruzioni 'GoTo' non valide nella finestra di controllo immediato

Impossibile utilizzare l'istruzione GoTo etichetta' <nomeetichetta>' in un'espressione lambda

'Group' non consentito in questo contesto. Previsto identificatore

Previsto 'Group' o un identificatore

La clausola Handles richiede una variabile WithEvents definita nel tipo che la contiene o in uno dei relativi tipi di base

'Handles' nelle classi deve specificare una variabile 'WithEvents', 'MyBase', 'MyClass' o 'Me' qualificata con un identificatore singolo

'Handles' nei moduli deve specificare una variabile 'WithEvents' qualificata con un identificatore singolo

'Handles' non è valido nelle dichiarazioni di operatore

È previsto un identificatore

Previsto identificatore preceduto da un punto

Identificatore troppo lungo

'If' deve terminare con un 'End If' corrispondente

Gli operandi 'If' non possono essere argomenti denominati

L'operatore 'If' richiede due o tre operandi

Previsto 'If', 'ElseIf', 'Else', 'EndIf' o 'Const'

Opzione /noconfig ignorata perché specificata in un file di risposta.

Espressione per chiamata o espressione che definisce l'indice non valide

Il tipo implementato deve essere un'interfaccia

Impossibile trovare la classe di implementazione '<nomeclasse>' per l'interfaccia <nomeinterfaccia>

La classe di implementazione '<nomeclassesottostante>' per l'interfaccia '<nomeinterfaccia>' non è accessibile in questo contesto perché è '<livelloaccesso>'

'Implements' non è valido nelle dichiarazioni di operatore

'Implements' non valido nei moduli

Le istruzioni 'Implements' devono seguire l'istruzione 'Inherits' e precedere tutte le dichiarazioni all'interno di una classe

Conversione implicita da '<nometipo1>' a '<nometipo2>'

Conversione implicita da '<nometipo1>' a '<nometipo2>' quando il valore del parametro 'ByRef' '<nomeparametro>' viene ricopiato nell'argomento corrispondente

La variabile implicita '<nomevariabile>' non è valida a causa di '<messaggio>'

Importazione del tipo '<nometipo>' dall'assembly o dal modulo '<nome>' non riuscita

L'alias '<nome>' di Imports è in conflitto con '<nome2>' dichiarato nello spazio dei nomi di primo livello

Le istruzioni "Imports" devono precedere qualsiasi dichiarazione

Previsto 'In'

Uso inappropriato della parola chiave <parolachiave> in un modulo

Indice '<numeroindice>' per la dimensione '<numerodimensione>' non compreso nell'intervallo

Il vincolo indiretto '<vincolo1>' ottenuto dal vincolo del parametro di tipo '<parametrodeltipo1>' è in conflitto con il vincolo '<vincolo2>'

Il vincolo indiretto '<vincolo1>' ottenuto dal vincolo del parametro di tipo '<parametrotipo1>' è in conflitto con il vincolo indiretto '<vincolo2>' ottenuto dal vincolo del parametro di tipo '<parametrotipo2>'

Riferimento indiretto all'assembly <nomeassembly> versione <numeroultimaversione> che contiene '<nometipo>'

Informazioni per il tipo di '<nometipo>' non caricate in fase di esecuzione

Non è consentito ereditare da 'System.<nomeclasse>'

'Inherits' può trovarsi solo una volta in un'istruzione 'Class' e può specificare solo una classe

'Inherits' non valido nei moduli

L'istruzione 'Inherits' deve precedere tutte le dichiarazioni di una classe

Le istruzioni 'Inherits' devono precedere tutte le dichiarazioni in un'interfaccia

Errore di inizializzazione

Previsto inizializzatore

Gli inizializzatori di membri di struttura sono validi solo per costanti e membri 'Shared'

Impossibile utilizzare membri di istanza e 'Me' nelle espressioni di query

Impossibile utilizzare membri di istanza e 'Me' in un'espressione lambda delle strutture

Impossibile utilizzare un'istanza di tipo limitato '<nometipo>' in un'espressione lambda

Impossibile utilizzare l'istanza di tipo limitato '<nometipo>' in un'espressione di query

Prevista costante Integer

L'interfaccia '<nomeinterfaccia>' può essere implementata una volta sola da questo tipo

L'interfaccia '<nomeinterfaccia>' non può essere indicizzata perché non contiene proprietà predefinite

L'interfaccia '<nomeinterfaccia>' non può ereditare da se stessa: <messaggio>

L'interfaccia '<nomeinterfaccia>' non è implementata da questa classe

Un'interfaccia può ereditare solo da un'altra interfaccia

I membri di interfaccia devono essere metodi, proprietà, eventi o definizioni di tipi

'Interface' deve terminare con un 'End Interface' corrispondente

I parametri 'InterfaceId' e 'EventsId' per 'Microsoft.VisualBasic.ComClassAttribute' in '<nometipo>' non possono avere lo stesso valore

Errore interno del compilatore

Errore interno del compilatore: il generatore del codice ha ricevuto un input non valido

Previsto 'Into'

Previsto 'Is'

È possibile confrontare l'operando 'Is' del tipo '<nomeparametrotipo>' solo a 'Nothing' perché '<nomeparametrotipo>' è un parametro di tipo senza vincoli di classe

È possibile confrontare l'operando 'Is' del tipo '<nometipo>' solo con 'Nothing' perché '<nometipo>' è un tipo nullable

Gli operandi di 'Is' devono avere tipi di riferimento, ma questo operando ha tipo di valore '<nometipo>'

È possibile confrontare l'operando 'IsNot' del tipo '<nomeparametrotipo>' solo a 'Nothing' perché '<nomeparametrotipo>' è un parametro di tipo senza vincoli di classe

È possibile confrontare l'operando 'IsNot' del tipo '<nometipo>' solo con 'Nothing' perché '<nometipo>' è un tipo nullable

Gli operandi di 'IsNot' devono avere tipi di riferimento, ma questo operando ha tipo di valore '<nometipo>'

Previsto 'Join'

La parola chiave non indica un tipo

Parola chiave non valida come identificatore

L'etichetta '<nomeetichetta>' è già definita nel metodo corrente

Etichetta '<nomeetichetta>' non definita

Etichette non valide nella finestra di controllo immediato

Le etichette non sono valide all'esterno dei metodi

Le etichette che sono numeri devono essere seguite da un segno di due punti

Impossibile convertire l'espressione lambda in '<nometipo>' perché '<nometipo>' non è un tipo delegato

Impossibile convertire l'espressione lambda in '<nometipo>' perché il tipo '<nometipo>' è dichiarato 'MustInherit' e non può essere creato

L'espressione lambda non verrà rimossa da questo gestore eventi

Le espressioni lambda non sono valide nella prima espressione di un'istruzione 'Select Case'

Il parametro lambda '<parametro>' nasconde una variabile in un blocco di inclusione, una variabile di intervallo precedentemente definita o una variabile dichiarata in modo implicito in un'espressione di query.

Impossibile convertire le operazioni di associazione tardiva in una struttura ad albero dell'espressione

Risoluzione ad associazione tardiva; potrebbero verificarsi degli errori in fase di esecuzione

Impossibile applicare la risoluzione dell'overload con associazione tardiva a '<nomeprocedura>' perché l'istanza di accesso è un tipo interfaccia

Il carattere '.' o '!' iniziale può trovarsi solo all'interno di un'istruzione

Il carattere '.' o '!' iniziale non può trovarsi in un'espressione costante

Le istruzioni di assegnazione 'Let' e 'Set' non sono più supportate

Previsto 'Lib'

Il carattere di continuazione di riga '_' deve essere preceduto da almeno uno spazio vuoto e deve essere l'ultimo carattere della riga

Riga troppo lunga

Le istruzioni 'Line' non sono più supportate (errore del compilatore Visual Basic/Smart Device)

Le istruzioni 'Line' non sono più supportate (errore del compilatore Visual Basic)

Impossibile fare riferimento alla variabile locale '<nomevariabile>' prima che sia dichiarata

La variabile locale '<nomevariabile>' è già dichiarata nel blocco corrente

La variabile locale non può avere lo stesso nome della funzione in cui è contenuta

Le variabili locali nei metodi generici non possono essere dichiarate 'Static'

Le variabili locali nei metodi delle strutture non possono essere dichiarate 'Static'

'Loop' non può contenere una condizione se questa è già presente nel 'Do' corrispondente

La variabile di controllo del ciclo non può essere una proprietà o una matrice indicizzata per cui è prevista l'associazione tardiva

'Loop' deve essere preceduto da un 'Do' corrispondente

Istruzioni Loop non valide nella finestra di controllo immediato

L'operatore '<simboloperatore1>' corrispondente è necessario per '<simboloperatore2>'

Superato il numero massimo di errori consentiti

Superato il numero massimo di avvisi consentiti

'Me' non può essere la destinazione di un'assegnazione

Impossibile eseguire l'override del membro '<nomeclasse>.<nomeprocedura>' corrispondente alla firma perché la classe '<nomeclasse>' contiene più membri con nome e firma uguali: <elencofirme>

Impossibile implementare il membro '<nomeinterfaccia>.<nomeroutine>' corrispondente alla firma perché l'interfaccia '<nomeinterfaccia>' contiene più membri con nome e firma uguali: <elencofirme>

Impossibile trovare il membro '<nomemembro>' nella classe '<nomeclasse>'

Impossibile inizializzare il membro '<nome membro>' in un'espressione dell'inizializzatore di oggetti perché non è un campo o una proprietà

Impossibile inizializzare il membro '<nome membro>' in un'espressione dell'inizializzatore di oggetto perché è condiviso

Il membro '<nomemembro>' è in conflitto con il membro '<nomemembro>' nel tipo di base '<nometipobase>', quindi non deve essere dichiarato 'Overloads'

Il membro '<nomemembro>' definisce in modo implicito un membro '<nomemembroimplicito>' che ha lo stesso nome di un parametro di tipo

Il membro '<nomemembro1>' è in conflitto con un membro dichiarato in modo implicito per il membro '<nomemembro2>' nel tipo di base '<nometipobase>', quindi non deve essere dichiarato 'Overloads'

Il membro '<nomemembro1>' dichiara in modo implicito '<nomemembroimplicito>', che è in conflitto con un membro dichiarato in modo implicito per il membro '<nomemembro2>' nella classe base '<nomeclassebase>'

Il membro '<nomemembro1>' dichiara in modo implicito '<nomemembroimplicito>', che è in conflitto con un membro della classe base '<nomeclassedibase>'

I membri di un modulo non possono essere dichiarati '<identificatore>'

I membri di una struttura non possono essere dichiarati '<identificatore>'

Il metodo '<nomemetodo>' non può essere dichiarato 'Partial' perché solo un metodo '<nomemetodo>' può essere contrassegnato come 'Partial'

Il metodo '<nomemetodo>' non può gestire l'evento '<nomeevento>' perché non hanno la stessa firma

La firma del metodo '<nomemetodo>' non è compatibile con il delegato '<nomedelegato>'

Il metodo '<nomemetodo>' non ha la stessa firma del delegato '<nomedelegato>'

Il metodo '<nomemetodo>' è associato a una richiesta di collegamento, ma esegue l'override dei metodi elencati di seguito o li implementa. Tali metodi non sono associati a richieste di collegamento. È possibile che esista un problema di protezione:

Il metodo '<nomemetodo>' è già dichiarato nell'interfaccia '<nomeinterfaccia>'

Il metodo '<nomemetodo1>' non può implementare il metodo parziale '<nomemetodo2>' perché è già implementato da '<nomemetodo3>'

Il metodo '<nomemetodo1>' non ha gli stessi vincoli generici del metodo parziale '<nomemetodo2>'

Il metodo '<nomemetodo1>' deve essere dichiarato 'Private' per implementare il metodo parziale '<nomemetodo2>'

Gli argomenti del metodo devono essere racchiusi tra parentesi

La chiamata al metodo non ha restituito alcun valore

Il metodo non può contenere un'istruzione 'Try' insieme a un'istruzione 'On Error' o 'Resume'

Il metodo non può contenere un'istruzione 'On Error GoTo' insieme a un'espressione lambda o di query

Il metodo non può accettare entrambi i parametri ParamArray e Optional

Le istruzioni per la dichiarazione di un metodo devono essere la prima istruzione in una riga logica

La firma del metodo non è compatibile con il delegato

Il metodo in una struttura non può essere dichiarato 'Protected' o 'Protected Friend'

I metodi non possono essere dichiarati 'Static'

I metodi dichiarati nelle strutture non possono contenere clausole 'Handles'

I metodi dichiarati 'Overrides' non possono essere dichiarati 'Overridable' perché sono implicitamente sottoponibili a override

I metodi di un modulo non possono essere dichiarati '<identificatore>'

I metodi che si trovano in un modulo non possono implementare membri di interfaccia

I metodi di 'System.Nullable(Of T)' non possono essere utilizzati come operandi dell'operatore 'AddressOf'

I metodi o gli eventi che implementano membri di interfaccia non possono essere dichiarati 'Shared'

Impossibile applicare sia 'Microsoft.VisualBasic.ComClassAttribute' che '<attributo>' alla stessa classe

Impossibile applicare 'Microsoft.VisualBasic.ComClassAttribute' a '<nomeclasse>' perché non è dichiarato 'Public'

Impossibile applicare 'Microsoft.VisualBasic.ComClassAttribute' a '<nomeclasse1>' perché il relativo contenitore '<nomeclasse2>' non è dichiarato 'Public'

Impossibile applicare 'Microsoft.VisualBasic.ComClassAttribute' a una classe dichiarata 'MustInherit'

Impossibile applicare 'Microsoft.VisualBasic.ComClassAttribute' a una classe generica o contenuta all'interno di un tipo generico

Si è specificato 'Microsoft.VisualBasic.ComClassAttribute' per la classe '<nomeclasse>', ma '<nomeclasse>' non ha membri public che possano essere esposti a COM. Nessuna interfaccia COM generata

'Microsoft.VisualBasic.ComClassAttribute' nella classe '<nomeclasse>' dichiara in modo implicito <tipo> '<nomemembro>', che è in conflitto con un membro di <tipo> '<nometipo>' avente lo stesso nome

Spazio vuoto obbligatorio mancante

Il modulo '<nomemodulo>' non può essere utilizzato come tipo

Attributo di modulo '<nomeattributo>' non valido: <errore>

L'istruzione 'Module' deve terminare con un 'End Module' corrispondente

Le istruzioni 'Module' possono trovarsi solo a livello di file o di spazio dei nomi

I moduli non possono essere dichiarati '<identificatore>'

I moduli non possono essere generici

Impossibile convertire la matrice multidimensionale in una struttura ad albero dell'espressione

Inizializzazioni multiple di '<nomemembro>'

'MustInherit' non può essere specificato per il tipo parziale '<nometipoparziale>' perché non può essere combinato con 'NotInheritable' specificato per uno degli altri tipi parziali

'MustOverride' non può essere specificato in '<nomeprocedura>' perché è in un tipo parziale dichiarato 'NotInheritable' in un'altra definizione parziale

Il metodo 'MustOverride' '<nomemetodo>' non può essere chiamato con 'MyClass'

'MyBase' non può essere utilizzato con il metodo '<nomemetodo>' perché è dichiarato 'MustOverride'

'MyBase' deve essere seguita da '.' e da un identificatore

'MyClass' non può essere utilizzata all'esterno di una classe

'MyClass' deve essere seguita da '.' e da un identificatore

Il nome <nomemembro> non è compatibile con CLS

Il nome '<nome>' non è dichiarato o non è nell'ambito corrente

Nome '<nome>' non dichiarato

Il nome <nomespaziodeinomi> nello spazio dei nomi di primo livello <nomespaziodeinomicompleto> non è compatibile con CLS

Il nome del campo o della proprietà che si sta inizializzando deve iniziare con '.'

Il nome del parametro di tipo '<nomeparametrotipo1>' non corrisponde a '<nomeparametrotipo2>', il parametro di tipo corrispondente definito nella dichiarazione del metodo parziale '<nomemetodo>'

L'argomento denominato non può corrispondere a un parametro ParamArray

Previsto argomento denominato

Argomenti denominati non validi come indici di matrice

La dichiarazione dello spazio dei nomi deve iniziare con 'xmlns'

La dichiarazione dello spazio dei nomi con prefisso non può avere un valore vuoto all'interno di un valore letterale XML

Lo spazio dei nomi o il tipo '<nome>' è già stato importato

Lo spazio dei nomi o il tipo specificato nelle importazioni '<nomeelementoqualificato>' non contiene alcun membro pubblico o non è definito

Lo spazio dei nomi o il tipo specificato nelle importazioni '<nomeelementoqualificato>' a livello di progetto non contiene alcun membro pubblico o non è definito

L'istruzione 'Namespace' deve terminare con un 'End Namespace' corrispondente

Le istruzioni 'Namespace' possono trovarsi solo a livello di file o di spazio dei nomi

La funzione nidificata non ha la stessa firma del delegato '<nomedelegato>'

La nidificazione di parentesi nell'elenco dei parametri dell'espressione lambda supera la profondità massima consentita

Impossibile utilizzare 'New' in una classe dichiarata 'MustInherit'

Impossibile utilizzare 'New' in un parametro di tipo che non ha un vincolo 'New'

Impossibile utilizzare 'New' in un'interfaccia

'New' non può essere utilizzato nella classe '<nomeclasse>' perché contiene un membro 'MustOverride' di cui non è stato eseguito l'override

Impossibile combinare i vincoli 'New' e 'Structure'

Impossibile specificare il vincolo 'New' più volte per lo stesso parametro di tipo

'New' non valido nel contesto corrente

La variabile di controllo 'Next' non corrisponde alla variabile di controllo del ciclo 'For'

La variabile di controllo Next non corrisponde alla variabile di controllo del ciclo For '<nomevariabile>'

Previsto 'Next'

'Next' deve essere preceduto da un 'For' corrispondente

L'istruzione 'Next' nomina più variabili delle istruzioni 'For' corrispondenti

Nessun '<nomeproceduragenerica>' accessibile accetta questo numero di argomenti di tipo

Nessun '<nomeprocedura>' accessibile è specifico: <elencofirme>

Impossibile trovare in '<nome>' un metodo 'Main' accessibile con una firma appropriata

Nessun metodo accessibile '<nomeroutine>' ha una firma compatibile con il delegato '<nomedelegato>':<elencoerrori>

Impossibile trovare '<nomeroutine>' non generica accessibile

Nessuna origine di input specificata

<nomemembro> non compatibile con CLS non consentito in un'interfaccia compatibile con CLS

Il membro 'MustOverride' non compatibile con CLS non è consentito in una classe <nomeclasse> compatibile con CLS

Nessuno dei metodi 'Main' accessibili con le firme appropriate trovate in '<nometipo>' può essere il metodo di avvio dato che sono generici o nidificati in tipi generici

I nomi di tipo non intrinseco non sono consentiti nelle espressioni di compilazione condizionali

L'attributo 'NonSerialized' non avrà effetto su questo membro poiché la classe che lo contiene non è esposta come 'Serializable'

I membri non condivisi di una struttura non possono essere dichiarati 'New'

Impossibile valutare 'Nothing'

Le classi 'NotInheritable' non possono avere membri dichiarati '<nomeidentificatore>'

Impossibile specificare 'NotOverridable' per metodi che non eseguono l'override di un altro metodo

Impossibile specificare il modificatore nullable '?' e i modificatori di matrici '(' and ')' sia nella variabile che nel relativo tipo

Impossibile specificare un modificatore nullable in dichiarazioni di variabili con 'As New'

Impossibile specificare il modificatore nullable in una variabile e nel relativo tipo

Impossibile utilizzare il modificatore nullable con una variabile il cui tipo implicito è 'Object'

I parametri nullable devono specificare un tipo

L'inferenza di tipi nullable non è supportata in questo contesto

Tipi nullable non consentiti nelle espressioni di compilazione condizionale

I tipi nullable non sono supportati perché la versione corrente di 'mscorlib.dll' non definisce il tipo 'Nullable(of T)'

Il numero di indici è superiore al numero di dimensioni della matrice indicizzata

Il numero di indici è inferiore al numero di dimensioni della matrice indicizzata

L'oggetto creato con la funzione Modifica e continuazione non è ancora disponibile per la valutazione

Impossibile utilizzare la sintassi dell'inizializzatore di oggetti per inizializzare un'istanza del tipo 'Object'

Oggetto non più esistente a causa di un'eliminazione o di un errore di compilazione

'Of' è richiesto quando si specificano argomenti di tipo per un tipo o metodo generico

L'argomento omesso non può corrispondere a un parametro ParamArray

Istruzioni 'On Error' non valide nella finestra di controllo immediato

Istruzioni 'On Error' non valide all'interno di istruzioni 'SyncLock'

Istruzioni 'On Error' non valide all'interno di istruzioni 'Using'

Previsto 'On'

Le istruzioni 'On GoTo' e 'On GoSub' non sono più supportate

Solo gli operatori di conversione possono essere dichiarati '<parolachiave>'

È possibile specificare solo un modificatore tra 'NotOverridable', 'MustOverride' e 'Overridable'

È possibile specificare solo un elemento tra 'Public', 'Private', 'Protected', 'Friend' e 'Protected Friend'

Per ogni elemento di linguaggio è consentito solo un blocco di commento XML

Operandi di tipo Object usati per l'operatore '<simbolooperatore>'. Potrebbero verificarsi errori di runtime.

Operandi di tipo Object utilizzati per l'operatore '<simbolooperatore>'; utilizzare l'operatore 'Is' per verificare l'identità dell'oggetto

Operandi di tipo Object utilizzati per l'operatore '<simbolooperatore>'; utilizzare l'operatore 'IsNot' per verificare l'identità dell'oggetto

Operandi di tipo Object usati in espressioni per istruzioni 'Select' e 'Case'. Potrebbero verificarsi errori di runtime

L'operatore '<operatore>' deve avere un tipo di restituzione Boolean

L'operatore '<operatore>' deve avere un secondo parametro di tipo 'Integer'

L'operatore '<operatore>' deve avere uno o due parametri

L'operatore '<operatore>' deve contenere un parametro

L'operatore '<operatore>' deve avere due parametri

L'operatore '<nomeoperatore>' non è definito per il tipo '<nometipo>'

L'operatore '<nomeoperatore>' non è definito per i tipi '<tipo1>' e '<tipo2>'

L'operatore '<nomeoperatore>' non è definito per i tipi '<nometipo1>' e '<nometipo2>'

L'operatore '<simbolooperatore>' non restituisce un valore in tutti i percorsi del codice

La dichiarazione dell'operatore deve essere una delle seguenti: +,-,*,\,/,^, &, Like, Mod, And, Or, Xor, Not, <<, >>, =, <>, <, <=, >, >=, CType, IsTrue, IsFalse

L'operatore non supporta l'overload

L'operatore 'operator' non è definito per i tipi 'type1' e 'type2'

Operatore senza una clausola 'As'; verrà utilizzato il tipo Object

Gli operatori non possono essere dichiarati '<parolachiave>'

Gli operatori non possono essere dichiarati nei moduli

Gli operatori devono essere dichiarati 'Public'

Gli operatori devono essere dichiarati 'Shared'

Opzione /win32manifest ignorata

L'opzione '<opzione>' deve essere seguita da '+' o '-' o da nessun valore

L'opzione <nomeopzione> può essere seguita solo da '+' o '-'

L'opzione <nomeopzione> richiede <argomento>

L'istruzione 'Option <identificatore>' può essere contenuta una sola volta per file

'Option Compare' deve essere seguito da 'Text' o 'Binary'

'Option Explicit' può essere seguito solo da 'On' o 'Off'

'Option Infer' può essere seguito solo da 'On' o 'Off'

'Option' deve essere seguito da 'Compare', 'Explicit', 'Infer' o 'Strict'

Le istruzioni 'Option' devono precedere tutte le dichiarazioni o le istruzioni 'Imports'

'Option Strict' può essere seguito solo da 'On' o 'Off'

Option Strict Custom può essere utilizzato solo come opzione del compilatore basato su riga di comando (vbc.exe)

Option Strict On non consente conversioni implicite da '<tipo1>' a '<tipo2>'

Option Strict On non consente conversioni implicite da '<tipo1>' a '<tipo2>'. Il tipo insieme di Visual Basic 6.0 non è compatibile con il tipo insieme di .NET Framework

Option Strict On non consente l'associazione tardiva

Option Strict On non consente la riduzione dal tipo '<nometipo1>' al tipo '<nometipo2>' quando il valore del parametro ByRef '<nomeparametro>' viene ricopiato nell'argomento corrispondente

Option Strict On non ammette operandi di tipo Object per l'operatore '<nomeoperatore>'

Option Strict On non consente la riduzione delle conversazioni implicite di tipi tra il metodo di estensione '<nomemetododiestensione>' definito in '<nomemodulo>' e il delegato '<nomedelegato>'

Option Strict On non consente la riduzione in conversioni implicite di tipi tra il metodo '<nomemetodo>' e il delegato '<nomedelegato>'

Option Strict On non consente la riduzione in conversioni implicite di tipi tra l'espressione lambda e il delegato '<nomedelegato>'

Option Strict On non ammette operandi di tipo Object per l'operatore '<nomeoperatore>'

Option Strict On richiede che tutte le dichiarazioni Function, Property e Operator abbiano una clausola 'As'

Option Strict On richiede che tutte le dichiarazioni di variabili abbiano una clausola 'As'

Option Strict On richiede che ciascun parametro di espressione lambda venga dichiarato con una clausola 'As' se non è possibile dedurne il relativo tipo

Option Strict On richiede che tutti i parametri dei metodi abbiano una clausola 'As'

Impossibile combinare 'Optional' e 'ParamArray'

Impossibile applicare 'Optional' al primo parametro di un metodo di estensione

Previsto 'Optional'

Impossibile dichiarare i parametri facoltativi come tipo '<tipo>'

I parametri facoltativi non possono avere tipi struttura

I parametri facoltativi devono specificare un valore predefinito

Memoria insufficiente (errore del compilatore Visual Basic)

Overflow (errore Visual Basic)

Risoluzione dell'overload non riuscita perché nessun '<metodo>' è accessibile

Risoluzione dell'overload non riuscita perché nessun '<nomeroutinegenerica>' accessibile accetta questo numero di argomenti di tipo.

Risoluzione dell'overload non riuscita perché nessun '<metodo>' accessibile accetta questo numero di argomenti

Risoluzione dell'overload non riuscita perché nessun '<metodo>' accessibile può essere chiamato con questi argomenti: <errore>

Risoluzione dell'overload non riuscita perché nessun '<metodo>' accessibile può essere chiamato senza una conversione verso un tipo di dati più piccolo: <errore>

Risoluzione dell'overload non riuscita perché nessun '<metodo>' accessibile è specifico per questi argomenti: <errore>

L'overload di metodi dichiarati in più interfacce di base non è valido

Impossibile applicare 'ParamArray' al primo parametro di un metodo di estensione

Il parametro ParamArray deve essere una matrice unidimensionale

Il parametro ParamArray deve essere una matrice

I parametri ParamArray devono essere dichiarati 'ByVal'

I parametri ParamArray devono contenere un tipo matrice

Il parametro '<nomeparametro>' ha già un argomento corrispondente

Il parametro '<nomeparametro>' ha già un argomento omesso corrispondente

Il parametro '<nomeparametro>' in '<nomemetodo>' contiene già un argomento omesso corrispondente

Il parametro '<nomeparametro>' del metodo di estensione '<nomemetodo>' definito in '<nometipo>' ha già un argomento corrispondente

Il parametro '<nomeparametro>' del metodo di estensione '<nomemetodo>' definito in '<nometipo>' ha già un argomento omesso corrispondente

Il parametro '<nomeparametro>' di '<nomemetodo>' ha già un argomento corrispondente

Parametro già dichiarato con il nome '<nomeargomento>'

Il parametro non può avere lo stesso nome della funzione che lo definisce

Il nome parametro '<nomeparametro1>' non corrisponde al nome del parametro corrispondente '<nomeparametro2>', definito nella dichiarazione del metodo parziale '<nomemetodo>'

L'identificatore di parametro è duplicato

Il tipo di parametro di un operatore unario deve essere il tipo che lo contiene '<nometipo>'

I tipi di parametro di '<operatore>' devono essere '<nometipo>' per poter essere utilizzati in un'istruzione 'For'

Il metodo parziale '<nomemetodo>' non può utilizzare la parola chiave 'Implements'

I metodi parziali devono essere dichiarati 'Private'

I metodi parziali devono essere dichiarati 'Private' anziché '<modificatoreaccesso>'

I metodi parziali devono avere corpi dei metodi vuoti

Rilevato un possibile problema durante la generazione dell'assembly '<nomeassembly>': <errore>

Rilevato un possibile problema durante la generazione dell'assembly: <errore>

'prefix' è un prefisso XML e non può essere utilizzato come espressione

Il progetto '<nomeprogetto>' non può generare un riferimento al file '<nomefile>'

Il progetto '<nomeprogetto>' non può fare riferimento al progetto '<nomeprogetto>' perché '<nomeprogetto>' fa riferimento a '<nomeprogetto>' direttamente o indirettamente

Il progetto '<nomeprogetto>' contiene un riferimento indiretto all'assembly '<nomeassembly>' che contiene '<nomeclasse>'

Il progetto '<nomeprogetto>' richiede un riferimento alla versione '<numeroversione1>' dell'assembly '<nomeassembly>' ma fa riferimento alla versione '<numeroversione2>' dell'assembly '<nomeassembly>'

Il progetto '<nomeprogetto>' richiede un riferimento alla versione '<numeroversione1>' dell'assembly '<nomeassembly>' ma fa riferimento alla versione '<numeroversione2>' dell'assembly '<nomeassembly>'

Il progetto '<nomeprogetto1>' contiene un riferimento indiretto al progetto '<nomeprogetto2>' che contiene '<nometipo>'

Il progetto contiene già un riferimento all'assembly <identitàassembly>

Il progetto è stato chiuso

La costante di compilazione condizionale a livello di progetto '<nomecostante>' non è valida: <errore>

La costante di compilazione condizionale a livello di progetto non è valida: <errore>

Le proprietà non possono essere dichiarate '<nomemodificatore>'

Le proprietà dichiarate 'ReadOnly' non possono avere un 'Set'

Le proprietà dichiarate 'WriteOnly' non possono avere un 'Get'

Le proprietà in un modulo non possono essere dichiarate '<identificatore>'

Le proprietà senza parametri obbligatori non possono essere dichiarate 'Default'

La proprietà '<nomeproprietà>' non può essere dichiarata 'Default' perché esegue l'override di una proprietà nella <tipo> base '<nometipo>' che non è predefinita

Impossibile inizializzare la proprietà '<nome proprietà>' in un'espressione dell'inizializzatore di oggetti. Tutti gli overload accessibili richiedono argomenti

Impossibile inizializzare la proprietà '<nome proprietà>' in un'espressione dell'inizializzatore di oggetti. Richiede argomenti

La proprietà '<nomeproprietà>' non restituisce un valore in tutti i percorsi del codice

La proprietà '<nomeproprietà>' dichiara in modo implicito '<nomemembroimplicito>', che è in conflitto con un membro dichiarato in modo implicito per il membro '<nomemembro>' nella classe base '<nomeclassebase>'

La proprietà '<nomeproprietà>' è di tipo non supportato

La proprietà '<nomeproprietà>' è 'ReadOnly'

La proprietà '<nomeproprietà>' è 'WriteOnly'

La proprietà '<nomeproprietà>' deve essere dichiarata 'Default' perché esegue l'override di una proprietà predefinita nella '<nome>' base

Impossibile trovare la proprietà '<nomeproprietà>' senza parametri

L'accesso alla proprietà deve assegnare un valore alla proprietà o utilizzare quello corrente

Le funzioni di accesso alle proprietà non possono essere dichiarate '<modificatoreaccesso>' in una proprietà 'Default'

Le funzioni di accesso alle proprietà non possono essere dichiarate '<modificatoreaccesso>' in una proprietà 'NotOverridable'

Le funzioni di accesso alle proprietà non possono essere dichiarate '<parolachiave>'

Impossibile dichiarare la proprietà come '<modificatoreproprietà>' perché contiene una funzione di accesso 'Private'

Get, Let e Set non sono più supportati per le proprietà. Utilizzare la nuova sintassi di dichiarazione delle proprietà.

'End Property' mancante nella proprietà

La proprietà o il campo '<nome>' non contiene un tipo di attributo valido

I parametri di proprietà non possono avere il nome 'Value'

Una proprietà senza identificatore 'ReadOnly' o 'WriteOnly' deve fornire sia un 'Get' che un 'Set'

Proprietà senza una clausola 'As'; verrà utilizzato il tipo Object

I tipi protetti possono essere dichiarati solo all'interno di una classe

Le espressioni di query non sono valide nelle finestre di debug

La dichiarazione 'RaiseEvent' deve terminare con un 'End RaiseEvent' corrispondente

Definizione di 'RaiseEvent' mancante per l'evento '<nomeevento>'

'RaiseEvent' è già dichiarato

Il metodo 'RaiseEvent' deve avere la stessa firma '<firma>' del tipo delegato dell'evento che lo contiene

Istruzioni 'RaiseEvent' non valide nella finestra di controllo immediato

Intervallo specificato per l'istruzione 'Case' non valido

La variabile di intervallo <variabile> nasconde una variabile in un blocco di inclusione o una variabile di intervallo precedentemente definita nell'espressione di query.

La variabile di intervallo <variabile> nasconde una variabile in un blocco di inclusione, una variabile di intervallo precedentemente definita o una variabile dichiarata in modo implicito in un'espressione di query

La variabile di intervallo <variabile> è già dichiarata

Il nome di variabile di intervallo può essere dedotto solo da un nome semplice o completo senza argomenti

Il nome della variabile di intervallo non può corrispondere al nome di un membro della classe 'Object'

Impossibile combinare 'ReadOnly' e 'WriteOnly'

La proprietà '<campoproprietà>' dell'attributo 'ReadOnly' non può essere la destinazione di un'assegnazione

Le proprietà 'ReadOnly' non possono avere un modificatore di accesso su 'Get'

La proprietà 'ReadOnly' '<nomeproprietà>' non può essere la destinazione di un'assegnazione

La proprietà 'ReadOnly' deve fornire un 'Get'

La variabile 'ReadOnly' non può essere la destinazione di un'assegnazione

La variabile 'ReadOnly' non può essere la destinazione di un'assegnazione in un'espressione lambda all'interno di un costruttore

'ReDim' non può modificare il numero di dimensioni di una matrice

Non è più possibile utilizzare le istruzioni 'ReDim' per dichiarare le variabili di matrice

Le istruzioni 'ReDim' richiedono un elenco tra parentesi dei nuovi limiti di ciascuna dimensione della matrice

Necessario riferimento all'assembly '<identitàassembly>' contenente il tipo '<nometipo>'. Impossibile trovare un riferimento adatto a causa dell'ambiguità tra i progetti '<nomeprogetto1>' e '<nomeprogetto2>'

Necessario un riferimento all'assembly '<identitàassembly>' contenente il tipo '<nometipo>'. Impossibile trovare un riferimento valido a causa della possibile presenza di riferimenti circolari: <elencodipendenzeriferimento>

Necessario un riferimento all'assembly '<nomeassembly>' contenente la classe base '<nomeclasse>'

Necessario un riferimento all'assembly '<nomeassembly>' contenente la definizione dell'evento '<nomeevento>'

Necessario un riferimento all'assembly '<nomeassembly>' contenente l'interfaccia implementata '<nomeinterfaccia>'

Necessario riferimento all'assembly '<nomeassembly>' contenente il tipo '<nomemembro>'

Necessario un riferimento al modulo '<nomemodulo>' contenente la classe base '<nomeclasse>'

Necessario un riferimento al modulo '<nomemodulo>' contenente la definizione dell'evento '<nomeevento>'

Necessario un riferimento al modulo '<nomemodulo>' contenente l'interfaccia implementata '<nomeinterfaccia>'

Necessario riferimento al modulo '<nomemodulo>' contenente il tipo '<nomemembro>'

Il riferimento a un membro non condiviso richiede un riferimento a un oggetto

Il riferimento all'oggetto in costruzione non è valido durante la chiamata a un altro costruttore

'<nomemembro>' a cui si fa riferimento ha valore 'Nothing'

L'elemento di matrice a cui si fa riferimento ha valore 'Nothing'

Il valore dell'oggetto '<nomeoggetto>' a cui si fa riferimento è 'Nothing'

L'oggetto a cui si fa riferimento ha valore 'Nothing'

Previsto operatore relazionale

La dichiarazione 'RemoveHandler' deve terminare con un 'End RemoveHandler' corrispondente

Definizione 'RemoveHandler' mancante per l'evento '<nomeevento>'

'RemoveHandler' è già dichiarato

Attributo obbligatorio 'version' mancante nella dichiarazione XML

Il nome di risorsa '<nomerisorsa>' non può essere utilizzato più di una volta

Il file di risposta <nomefile> è incluso più volte

Previsto 'Resume' o 'GoTo'

Istruzioni 'Resume' non valide nella finestra di controllo immediato

I tipi restituiti e i tipi di parametro di '<operatorelogico>' devono essere '<nometipo>' per poter essere utilizzati in un'espressione '<operatorecortocircuito>'

I tipi restituiti e i tipi di parametro di '<operatore>' devono essere '<nometipo>' per poter essere utilizzati in un'istruzione 'For'

L'istruzione 'Return' all'interno di un Function, Get o Operator deve restituire un valore

L'istruzione 'Return' in un Sub o Set non può restituire un valore

L'istruzione 'Return' in un metodo 'AddHandler', 'RemoveHandler' o 'RaiseEvent' non può restituire un valore

Istruzioni 'Return' non valide nella finestra di controllo immediato

Il tipo restituito della funzione '<nomeprocedura>' non è compatibile con CLS

Lo spazio dei nomi di primo livello <nomespaziodeinomi> non è compatibile con CLS

Generata eccezione in fase di esecuzione

Generata eccezione in fase di esecuzione: <eccezione> - <eccezione>

L'attributo di protezione '<nomeattributo>' non può essere applicato a un modulo

Attributo di protezione '<nomeattributo>' non valido: <errore>

'Select Case' deve terminare con un 'End Select' corrispondente

Istruzioni 'Select' non valide nella finestra di controllo immediato

La funzione di accesso 'Set' della proprietà '<nomeproprietà>' non è accessibile

'Set' è già dichiarato

Il metodo 'Set' non può avere più di un parametro

Il metodo 'Set' non può essere dichiarato '<identificatore>'

Il parametro 'Set' deve essere dello stesso tipo della proprietà che lo contiene

L'istruzione 'Set' deve terminare con un 'End Set' corrispondente

La proprietà '<campoproprietà>' dell'attributo 'Shared' non può essere la destinazione di un'assegnazione

Impossibile combinare 'Shared' con '<identificatore>' in una dichiarazione di metodo

Impossibile combinare 'Shared' con '<identificatore>' in una dichiarazione di proprietà

'Sub New' condiviso non può essere dichiarato '<identificatore>'

'Sub New' condiviso non può accettare parametri

Effetti secondari non validi durante la valutazione di espressioni in questo contesto

Il file di origine <nomefile> è specificato più volte

L'accesso '<livelloaccesso1>' specificato per '<nometipoparziale>' non corrisponde all'accesso '<livelloaccesso2>' specificato in uno degli altri tipi parziali

L'identificatore è duplicato

Identificatori e attributi non sono validi nelle istruzioni 'Namespace'

Identificatori e attributi non sono validi in questa istruzione

Identificatori non validi nei metodi 'AddHandler', 'RemoveHandler' e 'RaiseEvent'

Identificatori validi solo all'inizio di una dichiarazione

L'istruzione non può trovarsi all'esterno del corpo di un metodo

Questa istruzione non può trovarsi nel corpo di un metodo

L'istruzione non può trovarsi all'interno di un corpo di proprietà

L'istruzione non può trovarsi all'interno di un corpo di enumerazione

L'istruzione non può trovarsi nel corpo di un evento

L'istruzione non può trovarsi all'interno di un corpo di interfaccia

L'istruzione non può trovarsi all'interno di un corpo di interfaccia (errore Visual Basic)

L'istruzione non può terminare con un blocco all'esterno di un'istruzione di riga 'If'

L'istruzione non dichiara un metodo 'Get' o 'Set'

L'istruzione non dichiara un metodo 'AddHandler', 'RemoveHandler' o 'RaiseEvent'

Istruzione non valida in uno spazio dei nomi

L'istruzione non è valida in un'interfaccia

Istruzione non valida all'interno di un metodo

L'istruzione chiama in modo ricorsivo 'AddHandler' per l'evento '<nomeevento>' contenuto

Istruzioni ed etichette non valide tra 'Select Case' e la prima clausola 'Case'

La variabile locale statica '<nomevariabile>' è già dichiarata

Richiesta di arresto in sospeso

Istruzioni 'Stop' non valide nella finestra di controllo immediato

È prevista una costante di stringa

Le costanti stringa devono terminare con le virgolette

La struttura '<nomestruttura>' non può essere indicizzata perché non contiene proprietà predefinite

La struttura '<nomestruttura>' non può contenere un'istanza di se stessa: <errore>

La struttura '<nomestruttura>' deve contenere almeno una dichiarazione di evento o di variabile membro di istanza non contrassegnata 'Custom'

La struttura '<nomestruttura>' deve contenere almeno una dichiarazione di evento o di variabile membro di istanza

Impossibile combinare il vincolo 'Structure' e uno specifico vincolo di tipo di classe

Il vincolo 'Structure' non può essere specificato più volte per lo stesso parametro di tipo

La struttura di un'interfaccia non può essere dichiarata '<identificatore>'

L'istruzione 'Structure' deve terminare con un 'End Structure' corrispondente

Le strutture non possono dichiarare un 'Sub New' non condiviso senza parametri

Le strutture non possono contenere istruzioni 'Inherits'

'Sub Main' è dichiarato più volte in '<spaziodeinomi>': <messaggio>

Impossibile trovare "Sub Main" in '<nome>'

'Sub New' non può essere dichiarato '<modificatore>'

'Sub New' non può essere dichiarato in un'interfaccia

'Sub New' non può essere dichiarato 'Overrides'

'Sub New' non può gestire eventi

'Sub New' non può implementare i membri di interfaccia

Previsto 'Sub' o 'Function'

'Sub' o 'Function' previsto dopo 'Delegate'

Richiesta di sospensione in sospeso

L'operando 'SyncLock' non può essere di tipo '<nometipo>' perché '<nometipo>' non è un tipo di riferimento

L'istruzione 'SyncLock' deve terminare con un 'End SyncLock' corrispondente

Istruzioni 'SyncLock' non valide nella finestra di controllo immediato

Errore di sintassi (errore Visual Basic)

Errore di sintassi nell'operatore cast, sono necessari due argomenti separati da virgola

Errore di sintassi nell'espressione di compilazione condizionale

Impossibile applicare System.CLSCompliantAttribute alla proprietà 'Get'/'Set'

System.Diagnostics.DebuggerHiddenAttribute non ha effetto su 'Get' o 'Set' se applicato alla definizione delle proprietà

'System.Nullable' non soddisfa il vincolo 'Structure' per il parametro di tipo '<nomeparametrotipo>'

Impossibile applicare 'System.ObsoleteAttribute' alle definizioni 'AddHandler', 'RemoveHandler' o 'RaiseEvent'

Impossibile applicare 'System.Runtime.InteropServices.DispIdAttribute' a '<nometipo>' perché 'Microsoft.VisualBasic.ComClassAttribute' riserva valori minori di zero

Impossibile applicare 'System.Runtime.InteropServices.DispIdAttribute' a '<nometipo>' perché 'Microsoft.VisualBasic.ComClassAttribute' riserva il valore zero per la proprietà predefinita

Impossibile applicare 'System.Runtime.InteropServices.DllImportAttribute' a 'Declare'

Impossibile applicare 'System.Runtime.InteropServices.DllImportAttribute' a 'Get' o 'Set'

Impossibile applicare 'System.Runtime.InteropServices.DllImportAttribute' a un metodo generico o contenuto in un tipo generico

Impossibile applicare "System.Runtime.InteropServices.DllImportAttribute" a Sub, Function o Operator con un corpo non vuoto

Impossibile applicare 'System.Runtime.InteropServices.DllImportAttribute' al metodo 'AddHandler', 'RemoveHandler' o 'RaiseEvent'

Impossibile applicare 'System.Runtime.InteropServices.DllImportAttribute' a un metodo di istanza

Impossibile applicare 'System.Runtime.InteropServices.DllImportAttribute' ai metodi di interfaccia

Impossibile applicare sia 'System.STAThreadAttribute' che 'System.MTAThreadAttribute' a '|1'

Impossibile applicare sia 'System.STAThreadAttribute' che 'System.MTAThreadAttribute' allo stesso metodo

'System.Void' può essere usato solo in un'espressione GetType

L'opzione /moduleassemblyname può essere specificata solo durante la compilazione di una destinazione del tipo 'module'

Impossibile utilizzare il carattere '?'

La parola chiave '<parolachiave>' viene utilizzata per eseguire l'overload dei membri ereditati. Non utilizzare la parola chiave '<parolachiave>' per l'overload di 'Sub New'

ConnectionTimeout deve essere maggiore di 0

La versione personalizzata di 'System.Runtime.CompilerServices.ExtensionAttribute' trovata dal compilatore non è valida

Il riferimento all'assembly predefinito '<riferimento>' è stato già aggiunto automaticamente. Operazione ignorata.

Il file '<nomefile>' non è un file di testo

Superato il numero massimo di errori consentiti

La versione di destinazione di .NET Compact Framework non supporta l'associazione tardiva

La versione di destinazione di .NET Compact Framework non supporta la risoluzione dell'overload con associazione tardiva

La versione di destinazione di .NET Compact Framework non supporta l'istruzione "End"

La versione di destinazione di .NET Compact Framework non supporta l'utilizzo del modificatore ANSI, Auto o Unicode

Il tipo '<nometipo>' non può essere un tipo di elemento di matrice, un tipo restituito, un tipo di campo, un tipo di argomento generics, un tipo di parametro 'ByRef' o il tipo di un'espressione convertito in 'Object' o 'ValueType'

Il tipo della variabile '<nomevariabile>' non verrà dedotto perché associato a un ambito di inclusione

Il valore '<valore>' non è valido per l'opzione '<nomeopzione>'

L'ereditarietà genera dipendenze circolari tra <tipo1> '<nometipo1>' e i relativi <tipo2> '<nometipo2>' nidificati

L'operando 'Throw' deve derivare da 'System.Exception'

L'istruzione 'Throw' non può omettere l'operando all'esterno di un'istruzione 'Catch' o all'interno di un'istruzione 'Finally'

Istruzioni 'Throw' non valide nella finestra di controllo immediato

Argomenti di tipo insufficienti

Argomenti di tipo insufficienti in '<nomemetodogenerico>'

Argomenti di tipo insufficienti nel metodo di estensione '<nomemetodo>' definito in '<nometipo>'

Troppi argomenti

Troppi argomenti per '<nomeroutine>'

Troppi argomenti per il metodo di estensione '<nomemetodo>' definito in '<nometipo>'

Troppi argomenti di tipo

Troppi argomenti di tipo per '<nomemetodogenerico>'

Troppi argomenti di tipo per il metodo di estensione '<Nomemetodo>' definito in '<Nometipo>'

'Try' deve terminare con un 'End Try' corrispondente

Try deve avere almeno un 'Catch' o un 'Finally'

Istruzioni 'Try' non valide nella finestra di controllo immediato

L'operando 'TryCast' deve essere un tipo di riferimento, ma '<nometipo>' è un tipo di valore

Gli operandi 'TryCast' devono essere parametri di tipo vincolati da classe, ma '<nometipoparametro>' non ha vincoli di classe

Il tipo '<nometipo>' e il tipo parziale '<nometipo>' sono in conflitto nel contenitore '<nomecontenitore>'. È tuttavia in corso la relativa unione poiché uno di essi è dichiarato come parziale

Il tipo '<nometipo>' e il tipo parziale '<nometipo>' dichiarati in '<nomefile>' sono in conflitto nel contenitore '<nomecontenitore>'. È in corso l'unione poiché uno di essi è dichiarato come parziale

Impossibile utilizzare il tipo '<nometipo>' in un attributo perché non è dichiarato 'Public'

Impossibile utilizzare il tipo '<nometipo>' perché il relativo contenitore '<nomecontenitore>' non è dichiarato 'Public'

Il tipo '<nometipo>' non può implementare l'interfaccia '<nomeinterfaccia>' in quanto dichiara '<firmaevento>' con un tipo di restituzione

Il tipo '<nometipo>' non può ereditare da un tipo nidificato al suo interno

Il tipo '<nometipo>' non può ereditare da un parametro di tipo

Il tipo '<nometipo>' non ha costruttori

'<nometipo>' non ha parametri di tipo, quindi non può avere argomenti di tipo

Il tipo '<nometipo>' nell'assembly '<nomeassembly1>' è stato inoltrato all'assembly '<nomeassembly2>'

Il tipo '<nometipo>' è importato da diverse versioni dell'assembly '<nomeassembly>'

Il tipo <nometipo> non è compatibile con CLS

Tipo '<nometipo>' non definito

Il tipo '<nometipo>' non è definito oppure il modulo che lo contiene non è caricato nella sessione di debug

Il tipo '<nometipo>' non è supportato perché eredita direttamente o indirettamente da se stesso

Il tipo '<nometipo>' deve essere un tipo valore o un argomento di tipo vincolato a 'Structure' per essere utilizzato con 'Nullable' o il modificatore nullable '?'

Il tipo '<nometipo>' deve definire l'operatore '<operatoredeterminante>' per poter essere utilizzato in un'espressione '<operatorecortocircuito>'

Il tipo '<nometipo>' deve definire l'operatore '<operatore>' per poter essere utilizzato in un'istruzione 'For'

Il tipo '<nometipo1>' non può essere contrassegnato come compatibile con CLS perché il tipo che lo contiene '<nometipo2>' non è compatibile con CLS

L'argomento di tipo '<nomeargomentoditipo>' non eredita dal tipo di vincolo '<nomeparametroditipo>' né lo implementa

L'argomento di tipo '<nomeargomentotipo>' non soddisfa il vincolo 'Class' per il parametro di tipo '<nomeparametrotipo>'

L'argomento di tipo '<nomeargomentotipo>' non soddisfa il vincolo 'Structure' per il parametro di tipo '<nomeparametrotipo>'

L'argomento di tipo '<nomeargomentotipo>' è dichiarato 'MustInherit' e non soddisfa il vincolo 'New' per il parametro di tipo '<nomeparametrotipo>'

L'argomento di tipo '<nomeargomentotipo>' deve avere un costruttore di istanza pubblico senza parametri per soddisfare il vincolo 'New' per il parametro di tipo '<nomeparametrotipo>'

Inferenza dell'argomento di tipo non riuscita per il parametro di tipo '<nomeparametrotipo>' di '<firmaroutinegenerica>'

Inferenza dell'argomento di tipo non riuscita per il parametro di tipo '<nomeparametrotipo1>' di '<firmaproceduragenerica>'

Impossibile applicare gli argomenti di tipo all'espressione '<espressione>'

Impossibile dedurre argomenti di tipo dal delegato

Impossibile dedurre dal delegato '<Nomedelegato>' gli argomenti di tipo del metodo di estensione '<Nomemetodo>' definito in '<Nometipo>'

Impossibile dedurre argomenti di tipo per il metodo '<nomeprocedura>' dal delegato '<nomedelegato>'

Gli argomenti di tipo dedotti per il metodo '<nomeprocedura>' hanno restituito i seguenti errori: <elencoerrori>

Gli argomenti di tipo dedotti per il metodo '<nomeroutine>' determinano i seguenti avvisi :<elencoavvisi>

Argomenti di tipo imprevisti

Argomenti di tipo imprevisti. Gli attributi non possono essere generics

Il carattere tipo '<carattere>' non può essere utilizzato in una dichiarazione con un tipo esplicito

Il carattere tipo '<nomecarattere>' non corrispondente al tipo dati dichiarato '<tipo>'

Impossibile utilizzare un carattere tipo in una dichiarazione 'Sub' perché una 'Sub' non restituisce alcun valore

Il carattere del tipo non può essere utilizzato in una dichiarazione del parametro del tipo

Caratteri tipo non consentiti negli identificatori di etichetta

I caratteri del tipo non sono consentiti negli alias di importazione

Impossibile utilizzare i caratteri tipo nelle dichiarazioni di tipi anonimi

Impossibile utilizzare i caratteri di tipo nelle dichiarazioni della variabile di intervallo

Il vincolo di tipo '<espressione>' non è una classe o un'interfaccia

Il vincolo di tipo non può essere una classe 'NotInheritable'

I caratteri di dichiarazione tipo non sono validi in questo contesto

È previsto un tipo

Un tipo in un modulo non può essere dichiarato '<identificatore>'

Impossibile dedurre il tipo di '<nomevariabile>' perché i limiti del ciclo e la clausola STEP non eseguono la conversione nello stesso tipo

Inferenza del tipo di 'nome variabile' non riuscita da un'espressione contenente 'nome variabile'

Il tipo di '<nomevariabile>' è ambiguo perché i limiti del ciclo e la clausola STEP non eseguono l'ampliamento nello stesso tipo

Il tipo di membro '<nomemembro>' non è compatibile con CLS

Il tipo di valore facoltativo per il parametro facoltativo <nomeparametro> non è compatibile con CLS

Il tipo di parametro '<nomeparametro>' non è compatibile con CLS

Previsto tipo o 'New'

Previsto tipo o 'With'

Il parametro di tipo '<nomeparametrotipo>' può avere soltanto un vincolo costituito da una classe

Il parametro di tipo '<nomeparametrotipo>' non può essere vincolato a se stesso: '<messaggioerrore>'

Impossibile dedurre il parametro di tipo '<nomeparametroditipo>'

Impossibile dedurre il parametro di tipo '<nomeparametroditipo>' per '<nomeroutinegenerica>'

Impossibile dedurre il parametro di tipo '<nometipoparametro>' del metodo di estensione '<nomemetodo>' definito in '<nometipo>'

Il parametro di tipo '<nomeparametroditipo>' ha lo stesso nome di un parametro di tipo di un tipo di inclusione

Il parametro di tipo '<nomeparametrotipo1>' deve contenere un vincolo 'New' o 'Structure' per soddisfare il vincolo 'New' per il parametro di tipo '<nomeparametrotipo2>'

Parametro di tipo già dichiarato con il nome '<nomeparametrotipo>'

Il parametro di tipo non può avere lo stesso nome della funzione che lo definisce

Il nome '<nomeparametrotipo1>' del parametro di tipo non corrisponde al nome '<nomeparametrotipo2>' del corrispondente parametro di tipo definito in uno degli altri tipi parziali di '<nometipoparziale>'

Parametro di tipo non consentito nella clausola 'Implements'

Impossibile utilizzare come vincolo il parametro di tipo con un vincolo 'Structure'

I parametri di tipo non possono essere specificati in questa dichiarazione

Impossibile utilizzare i parametri di tipo come qualificatori

I parametri di tipo o i tipi creati con i parametri di tipo non sono ammessi negli argomenti di attributo

Le istruzioni 'Type' non sono più supportate. Utilizzare le istruzioni 'Structure'.

L'operando sinistro di 'TypeOf...Is' deve avere un tipo di riferimento, ma questo operando ha tipo di valore '<tipo>'

Tipi non disponibili in questo contesto

I tipi dichiarati 'Private' devono trovarsi all'interno di un altro tipo

Impossibile accedere al membro

Impossibile applicare gli attributi di protezione a '<nome>': <errore>

Impossibile creare un'interfaccia di runtime .NET: <errore>

Impossibile creare l'oggetto Assembly Linker: <messaggio di errore>

Impossibile creare un assembly con nome sicuro dal file di chiave '<nomefile>': <errore>

Impossibile creare il file temporaneo nel percorso '<nomefile>': <messaggio di errore>

Impossibile creare un file di documentazione XML '<nome>': <messaggio>

Impossibile incorporare il file di risorse '<nomefile>': <messaggio di errore>

Impossibile creare l'assembly: <messaggio di errore>

Impossibile valutare l'espressione

Impossibile trovare il punto di ingresso '<nome>' nella DLL '<nomefile>': <errore>

Impossibile trovare il file richiesto '<nomefile>'

Impossibile generare un riferimento al file '<nomefile>' (utilizzare l'utilità TLBIMP per fare riferimento alle DLL COM): <messaggio di errore>

Impossibile ottenere le informazioni sul tipo relative a '<nometipo>'

Impossibile includere il frammento XML '<percorsoelemento>' del file '<filecommento>'

Impossibile collegare il file di risorse '<nomefile>': <messaggio di errore>

Impossibile caricare la DLL '<nomefile>': <errore>

Impossibile caricare le informazioni per la classe '<nomeclasse>'

Impossibile caricare la libreria a cui si fa riferimento '<nomefile>': <errore>

Impossibile aprire il file '<nomefile>': <errore>

Impossibile aprire il file di chiave '<nomefile>': <errore>

Impossibile aprire il file di modulo '<nomefile>': <errore>

Impossibile aprire il file di risorse '<nomefile>': <errore>

Impossibile aprire il file di risposta '<nomefile>'

Impossibile analizzare XML: <errore>

Impossibile firmare l'assembly: <messaggio di errore>

Impossibile firmare il file '<nomefile>': <errore>

Impossibile scrivere l'output in memoria

Impossibile scrivere il file temporaneo perché il percorso temporaneo non è disponibile

Impossibile scrivere nel file di output '<nomefile>': <errore>

Il tipo sottostante <nometipo> di Enum non è compatibile con CLS

Opzione <nomeopzione> non riconosciuta. Operazione ignorata

Fiber non pianificato

Costante locale non utilizzata: '<costante>'

Variabile locale non utilizzata: '<nomevariabilelocale>'

Utilizzare l'opzione della riga di comando '<opzione>' o le impostazioni di progetto appropriate anziché '<parametro>'

'Using' deve terminare con un 'End Using' corrispondente

L'operando 'Using' di tipo '<nometipo>' deve implementare System.IDisposable

La variabile di risorsa 'Using' deve avere un'inizializzazione esplicita

Il tipo di variabile della risorsa 'Using' non può essere un tipo matrice

Istruzioni 'Using' non valide nella finestra di controllo immediato

L'utilizzo della variabile di iterazione in un'espressione lambda può produrre risultati imprevisti

Impossibile convertire il valore '<nomevalore1>' in '<nomevalore2>'

Impossibile convertire il valore di tipo '<tipo1>' in '<tipo2>'

Impossibile convertire il valore di tipo '<tipo1>' in '<tipo2>' perché '<tipo3>' non è un tipo di riferimento

Impossibile convertire il valore di tipo '<tipo1>' in '<tipo2>' perché '<tipo3>' non è derivato da '<tipo4>'

Impossibile convertire il valore di tipo '<tipo1>' in '<tipo2>' perché i tipi matrice hanno numeri di dimensioni differenti

Impossibile convertire il valore di tipo '<nometipo1>' in '<nometipo2>'

Impossibile convertire il valore del tipo '<nometipo1>' in '<nometipo2>'

Impossibile convertire il valore di tipo 'type1' in 'type2'

La variabile '<nomevariabile>' nasconde una variabile in un blocco di inclusione

Variabile '<nomevariabile>' passata per riferimento prima dell'assegnazione di un valore

Variabile '<nomevariabile>' passata per riferimento prima dell'assegnazione di un valore (Variabile della struttura)

La variabile '<nomevariabile>' viene utilizzata prima che le sia stato assegnato un valore

La variabile '<nomevariabile>' viene utilizzata prima che le sia stato assegnato un valore (Errore di Visual Basic)

Impossibile inizializzare la variabile con il tipo non matrice '<nomeelemento>'

Istruzioni per la dichiarazione di variabili non valide nella finestra di controllo immediato

Dichiarazione di variabile senza clausola 'As'. Verrà utilizzato il tipo Object

La variabile utilizza un tipo di automazione non supportato in Visual Basic

Le variabili nei moduli non possono dichiarare '<identificatore>'

Il tipo 'Variant' non è più supportato. Utilizzare il tipo 'Object'.

Il compilatore Visual Basic 2005 non è in grado di correggere il seguente errore: <errore>

Messaggi del compilatore Visual Basic

Il numero di avviso '<numero>' per l'opzione '<nomeopzione>' non è configurabile o non è valido

Avviso considerato come errore: <errore>

Impossibile valutare i metodi Web nelle finestre di debug

L'attributo 'WebMethod' non avrà alcun effetto su questo membro perché la classe che lo contiene non è esposta come servizio Web

Le istruzioni 'Wend' non sono più supportate. Utilizzare le istruzioni 'End While'

'While' deve terminare con un 'End While' corrispondente

Impossibile utilizzare spazi vuoti

Impossibile combinare 'Widening' e 'Narrowing'

Contesti e istruzioni 'With' non valide nelle finestre di debug

'With' deve terminare con un 'End With' corrispondente

La variabile 'WithEvents' non genera eventi

La variabile 'WithEvents' non genera eventi di istanza accessibili da '<nomecontenitore>'

La lunghezza del nome della variabile WithEvents non può superare i 1019 caratteri

Le variabili 'WithEvents' possono essere solo tipizzate come classi, interfacce o parametri di tipo con vincoli di classe

Le variabili 'WithEvents' non possono essere tipizzate come matrici

Le variabili 'WithEvents' devono avere una clausola 'As'

Le proprietà "WriteOnly" non possono avere un modificatore di accesso su "Set"

La proprietà 'WriteOnly' deve fornire un 'Set'

Numero errato di argomenti di tipo passati al metodo '<nomeproceduragenerica>'

L'attributo XML 'attribute1' deve precedere l'attributo XML 'attribute2'

L'attributo XML 'version' deve essere il primo attributo nella dichiarazione XML

Impossibile selezionare attributi XML dal tipo 'type'

Le proprietà axis XML non supportano l'associazione tardiva

Il blocco di commento XML non può essere associato ad alcun elemento del linguaggio che supporti l'applicazione di commenti relativi alla documentazione XML

Il blocco di commento XML deve precedere immediatamente l'elemento del linguaggio a cui è applicato

Impossibile inserire un commento XML in un metodo o in una proprietà

Impossibile applicare il commento XML più di una volta su un <tipo> parziale

L'eccezione del commento XML deve avere un attributo 'cref'

Il commento XML include un tag con un attributo 'cref' '<attributo>' che non può essere risolto

Il commento XML deve essere la prima istruzione in una riga

Il parametro di commento XML '<parametro>' non corrisponde a un parametro nell'istruzione <parolachiave> corrispondente

Il parametro di commento XML deve avere un attributo 'name'

Il tag di commento XML '<tag>' è presente più di una volta nello stesso blocco di commento XML

Il tag di commento XML '<tag>' non può essere utilizzato sull'elemento '<elemento>' del linguaggio

Il tag di commento XML 'include' deve avere un attributo '<attributo>'

Il tag di commento XML 'returns' non può essere utilizzato sull'elemento 'declare sub' del linguaggio

Il tag di commento XML 'returns' non può essere utilizzato sulla proprietà 'WriteOnly'

Il parametro di tipo commento XML <parametro> non corrisponde a un parametro di tipo nell'istruzione <parolachiave> corrispondente

Il parametro di tipo commento XML deve avere un attributo 'name'

La dichiarazione XML non consente l'attributo 'attributeName'

Impossibile selezionare elementi discendenti XML dal tipo 'type'

Errore di analisi della documentazione XML: <errore>

Errore di analisi della documentazione XML: il tag di inizio '<tag>' non ha un tag di fine corrispondente

DTD XML non supportati

Impossibile selezionare elementi XML dal tipo 'type'

Riferimenti a entità XML non supportati

Il valore letterale XML non può trovarsi in questa posizione a meno che non sia racchiuso tra parentesi

Valori letterali XML e proprietà axis XML non disponibili

I valori letterali XML e le proprietà XML all'interno del codice incorporato non sono supportati in ASP.NET.

Previsto nome XML

Il prefisso dello spazio dei nomi XML 'prefix' è già dichiarato

Il prefisso dello spazio dei nomi XML 'prefix' non è definito

L'utilizzo del prefisso dello spazio dei nomi XML 'prefix' è riservato a XML. Impossibile modificare l'URI dello spazio dei nomi.

L'URI dello spazio dei nomi XML 'http://www.w3.org/XML/1998/namespace' può essere associato solo a 'xmlns'

Il nome di istruzione di elaborazione XML 'name' non è valido

È necessario fare riferimento ad almeno una variabile di intervallo su entrambi i lati dell'operatore 'Equals'

Vedere anche

Attività

Procedura: visualizzare le informazioni sugli errori del compilatore in Visual Basic

Altre risorse

Messaggi di errore (Visual Basic)