Mensagens do compilador do Visual Basic

Esta seção contém o Visual Basic mensagens de erro que ocorrem em time de compilar.

'-' esperado

'!' Requer que seu operador esquerdo tenha um parâmetro de tipo, classe ou tipo de interface, mas este operando tem o tipo '<type>'

'# else 'deve ser precedido por uma correspondência' # If' ou '#ElseIf'

' Bloquear 'não pode seguir '#Else' sistema autônomo parte de um' # If' #ElseIf

'#ElseIf' deve ser precedido por um '#ElseIf' ou '# If' correspondente

'#ElseIf', '#Else' ou '# participante If' deve ser precedido por um correspondente '# If'

'# participante ExternalSource' deve ser precedido por um correspondente '# ExternalSource'

'# participante região' deve ser precedido por um correspondente '# Region'

diretivas '# ExternalSource' não podem ser aninhadas

demonstrativo '# ExternalSource' deve finalizar com '# participante ExternalSource'

bloco '# If' deve finalizar com '# participante If' correspondente

instruções '# região' e '# participante região' inválido são válidas dentro de corpos de método

demonstrativo '# região' deve finalizar com '# participante região' correspondente

'(' expected

'(' Unexpected

') ' esperado

'.' esperado

':' não é permitido

' {' esperado

'} ' esperado

'<argumentname>' não é um parâmetro de '<methoddeclaration>'

'<assemblyname>' é um assembly e não pode ser referenciado sistema autônomo um módulo

'<atributo>' não pode ser aplicado porque o formato do GUID '<number>' não está correto

'<attributename>' não pode ser aplicado mais de uma vez a um assembly

' <baseinterfacename>. <membername>'de' implementa <derivedinterfacename>'já foi implementado pela classe base' <baseclassname>'. Reimplementação de <tipo> adotado

'<classname>' não é compatível com CLS porque ela deriva de '<baseclassname>' que não é compatível com CLS

'<classname>' não é compatível com CLS porque a interface '<interfacename>' implementa não é compatível com CLS

'<classname1>' não pode herdar de <type>'<classname2>' porque '<classname2>' está declarado como 'NotInheritable'

'<construtor>' no tipo gerado por designer '<type>' deve chamar o método InitializeComponent

'<declaration1>' não pode substituir '<declaration2>' porque está declarado como 'NotOverridable'

'<declaration1>' não pode substituir '<declaration2>' porque está declarado como 'Shared'

'<declaration1>' não pode substituir '<declaration2>' porque eles têm diferentes níveis de acesso

'<derivedtypename>' não pode herdar de <type>'<constructedbasetypename>' porque expande o acesso do tipo '<internaltypename>' fora do assembly

'<derivedtypename>' não pode herdar de <type>'<constructedbasetypename>' porque expande o acesso do tipo '<internaltypename>' para '<regionname>' <região>

'<elementname>' não pode ser declarado 'parcial' porque os métodos parcial devem ser Subs

'<elementname>' para Imports '<qualifiedelementname>' alias não se refere a Namespace, classe, estrutura, interface, Enum ou módulo

'<elementname>' é ambíguo porque há vários tipos de membros com esse nome em <type>'<typename>'

'<elementname>' não é um parâmetro de método

'<elementname>' não é um parâmetro de método de extensão '<methodname>' definido em '<typename>'

'<elementname>' está obsoleto (erro do Visual Basic)

'<elementname>' é obsoleta (aviso do Visual Basic)

'<elementname>' está obsoleto: '<errormessage>'

'<elementname>' refere-se ao tipo '<typename>' no projeto '<projectname>', mas o tipo '<typename>' não foi encontrado no projeto '<projectname>'

não está declarado como '<emptyconstant>'

<erro>: '<classname1>' herda de '<classname2>'

<erro>: '' chamadas' <constructorname2><constructorname1>'

<erro>: '<structurename1>' contém '<structurename2>'

'<eventname>' define implicitamente '<membername>', que conflita com um membro implicitamente declated em <type>'<typename>'

'<eventname>' é um evento e não pode ser chamado diretamente

'<eventname>' não é um evento de '<containername>'

'<expressão>' não pode ser usado sistema autônomo restrição de tipo

'<filename>' não pode ser referenciado porque não é um conjunto de módulos (assembly)

não está declarado como '<função>'

'<functionname>' não é declarado (dispositivo/Visual Basic Compiler erro SMART)

'<functionname>' não é declarado (erro do Visual Basic)

'<implementsclause>' não é possível implementar '<typename>' porque '<typename>' é um nome reservado

' <interfacename>. <membername>'já foi implementado pela classe base' <baseclassname>'. Reimplementação de <tipo> adotado

'<interfacename1>' não pode implementar '<methodname>' porque não há nenhum <método>correspondente na interface '<interfacename2>'

acessador '<palavra-chave>' de '<propertyname>' está obsoleto (erro do Visual Basic)

acessador '<palavra-chave>' de '<propertyname>' está obsoleto (aviso do Visual Basic)

acessador '<palavra-chave>' de '<propertyname>' está obsoleto: '<errormessage>' (erro do Visual Basic)

acessador '<palavra-chave>' de '<propertyname>' está obsoleto: '<errormessage>' (aviso do Visual Basic)

'<palavra-chave>' inválido dentro de um módulo

'<palavra-chave>' inválido dentro de uma estrutura

'<palavra-chave>' é válido somente dentro de uma classe

'<palavra-chave>' só é válido em um método de instância

não está declarado como '<lsetstmt>'

não está declarado como '<mathfunction1>'

'<member>' está em conflito com o membro reservado por este nome está declarado implicitamente em todos os enums

'<membro>' já está declarado nesta estrutura

'<membro>', implicitamente definida para '<eventname>' não pode ser sombra de um método 'MustOverride' na base de <classe>'<classname>'

'<membername>' não podem ser declarado 'Shadows' fora de uma classe, estrutura ou interface

'<membername>' não pode expor o tipo '<typename>' fora do projeto por meio de <containertype>'<containertypename>'

' <membername>'não é possível implementar' <interfacename>. <interfacemembername>' porque diferem por restrições de parâmetro de tipo

'<membername>' existe em várias interfaces base

' <membername>tem o mesmo nome que um parâmetro de tipo

'<membername>' já foi declarado por '<procedurename>', que foi gerado para este <containername>

'<membername>' é ambíguo nas interfaces herdadas '<interfacename1>' e '<interfacename2>'

'<membername>' não é um membro de '<contextname>'; ele não existe no contexto corrente

não está declarado como '<membername>'

não está declarado como '<membername>' ou o módulo que o contém não está carregado na sessão de depuração

'<membername>' está obsoleto: '<errormessage>'

'<membername1>' e '<membername2>' não podem sobrecarregar um ao Outros porque diferem somente pelos tipos de parâmetros opcionais

'<membername1>' não pode substituir '<membername2>' porque diferem pelos tipos de parâmetros opcionais

<mensagem> Esse erro também pode ocorrer devido à combinação de uma referência de arquivo para '<arquivo1>' no projeto '<projectname1>' com uma referência de arquivo para '<arquivo2>' no projeto '<projectname2>'

Este erro também pode ocorrer devido à combinação de uma referência de arquivo com uma referência de projeto ao assembly '<assemblyname>' <mensagem>

< método > '< methodname1 >' deve ser declarado como 'Overloads' porque outro '< methodname2 >' está declarado como 'Overloads'

'<método>' não está acessível neste contexto porque é '<modifier>'

'<method1>' e '<method2>' não podem sobrecarregar um ao Outros porque diferem somente pelos parâmetros opcionais

'<method1>' e '<method2>' não podem sobrecarregar um ao Outros porque diferem somente pelos parâmetros declarados 'ByRef' ou 'ByVal'

'<method1>' e '<method2>' não é possível sobrecarga Outros porque diferem somente pelos parâmetros declarados como 'ParamArray'

'<method1>' e '<method2>' não podem sobrecarregar um ao Outros porque diferem somente pelos tipos de retorno

'<method1>' e '<method2>' não podem sobrecarregar um ao Outros porque diferem somente pelos valores padrão de parâmetros opcionais

'<method1>' não pode substituir '<method2>' porque expande o acesso do método base

'<method1>' não pode substituir '<method2>' porque ele é uma demonstrativo 'Declare'

'<method1>' não pode substituir '<method2>' porque diferem somente por um parâmetro está marcado sistema autônomo 'ByRef' versus 'ByVal'

'<method1>' não pode substituir '<method2>' porque diferem somente pelos parâmetros opcionais

'<method1>' não pode substituir '<method2>' porque diferem somente pelos valores padrão de parâmetros opcionais

'<method1>' não pode substituir '<method2>' porque diferem pelos tipos de retorno

< methodname > ' e '< methodname >' não pode sobrecarregar cada um porque eles diferem em 'ReadOnly' ou 'WriteOnly'

'<methodname>' não pode ser implementado mais de uma vez

'<methodname>' não pode substituir um método que foi sombreado

'<methodname>' não pode sombrear um método declarado 'MustOverride'

'<methodname>' tem várias definições com assinaturas idênticas

'<methodname>' não está acessível neste contexto porque o tipo de retorno não está acessível

'<modifier>' inválido em Declare

'<modifier>' inválido em declaração delegado

'<modifier>' inválido em declaração de constante local

'<modifier>' inválido em declaração de variável local

'<modifier>' inválido em declaração de método

'<modifier>' inválido em uma declaração de evento

'<modifier>' inválido em declaração de interface

'<modulename>' é um módulo e não pode ser referenciado sistema autônomo assembly

'<nome>' não pode ser nomeado sistema autônomo um parâmetro em um especificador de atributo porque não é um campo ou propriedade

'<nome>' não pode expor o tipo delegado subjacente '<delegatetype>' de evento que está implementando fora do projeto por meio de <especificador>'<type>'

'<nome>' não pode expor o tipo delegado subjacente '<delegatetype>' do evento que está implementando para <specifier1>'<type1>' por meio de <specifier2>'<type2>'

'<nome>' não pode expor o tipo '<type>' usado no tipo de delegado subjacente '<delegatetype>' do evento que está implementando para <specifier1>'<type1>' por meio de <specifier2>'<type2>'

'<nome>' não pode expor o tipo <type1>em <especificador><type2>'<typename>' por meio de <nome>

'<nome>' não pode expor o tipo '<type1>' usado no tipo de delegado subjacente '<delegatetype>' do evento que está implementando fora do projeto por meio de <especificador>'<type2>'

'<nome>' não é possível fazer referência a mesmo por meio de sua instância padrão, use 'Me'

'<nome>' já está declarado sistema autônomo '<declaração>' neste <declarationspace>

'<nome>' já está declarado sistema autônomo um parâmetro deste método

'<nome>' é ambíguo entre declarações nos módulos '<modulename1>' e '<modulename2>'

'<nome>' é ambíguo nos objetos de aplicativo '<lista>'

'<nome>' é ambíguo no namespace '<namespacename>'

'<nome>' está declarado no projeto '<projectname1>' que não é referenciado pelo projeto '<projectname2>'

'<nome>' não é um membro de '<classname>'

'<nome>', necessário para compilação deste construtor não pode ser encontrado

'<name1>' está em conflito com um <type>com o mesmo nome definido em '<name2>'

'<name1>' para Imports '<name2>' não Consulte Namespace, classe, estrutura, Enum ou módulo

'<name1>' é ambíguo, importado de namespaces ou tipos '<name2>'

<namespace>'< namespace >' não é um nome válido e não pode ser usado sistema autônomo o nome do namespace raiz

'<namespacename>' é ambíguo

não está declarado como '<nullconstant>'

'<parametername>' já está declarado sistema autônomo um parâmetro de tipo deste método

'<procedure1>' e '<procedure2>' não é possível sobrecarga Outros porque diferem somente pelos parâmetros declarados 'ByRef' ou 'ByVal'

'<procedurename>' não pode substituir '<baseprocedurename>' porque diferem por restrições de parâmetro de tipo

'<procedurename>' tem um tipo de retorno que não tem suporte ou tipos de parâmetro que não são suportados

'<procedurename>' não tem parâmetros e seu tipo de retorno não pode ser indexado

'<procedurename>' método de evento '<eventname>' não é possível marcar CLS porque seu tipo recipiente '<typename>' não é compatível com CLS

'<procedurename1>' não pode substituir '<procedurename2>' porque ele não está acessível neste contexto

<procedurename1> não pode substituir <procedurename2> porque diferem nos parâmetros declarados no 'ParamArray'

< proceduresignature1 > não é compatível com CLS porque ele sobrecarrega < proceduresignature2 > que difere dele somente pelo array ou classificação dos tipos de parâmetro de array.

parâmetros de <propriedade>não podem ser declarados como 'ByRef'

'<property1>' e '<property2>' não podem sobrecarregar um ao Outros porque somente um está declarado como 'padrão'

'<propertyname>' não pode ser exposto a COM sistema autônomo uma propriedade 'Let'

'<propertyname>' define implicitamente '<membername>', que está em conflito com um membro do mesmo nome em <type>'<typename>'

'<propertyname1>' não pode substituir '<propertyname2>' porque diferem por 'ReadOnly' ou 'WriteOnly'

'<qualifiedmethod>' não está acessível neste contexto porque é '<modifier>'

não está declarado como '<rsetstmt>'

'<especificador>' inválido em declaração de constante

'<especificador>' inválido em declaração de variável de membro

'<especificador>' inválido em declaração de estrutura

'<especificador>' inválido em declaração WithEvents

'<especificador>' inválido em declaração de Enum

'<especificador>' inválido em declaração de evento de interface

'<especificador>' inválido em declaração de método de interface

'<especificador>' inválido em declaração de propriedade de interface

< specifier1 > < tipo > não pode herdar de um < specifier2 > < tipo > porque ele expande o acesso da base < tipo >

'<specifier1>' e '<specifier2>' não podem ser combinados

demonstrativo '<statementname>' requer matriz

<type> '< methodname >' está em conflito com outros membros do mesmo nome entre a hierarquia de herança e portanto deveria ser declarado como 'Shadows'

<tipo> '<nomedotipo>' faz sombra a um método substituível na classe base

'<type>' não pode ser herdada de mais de uma vez

<type>parâmetros não podem ser declarados 'Optional'

<type>parâmetros não podem ser declarados 'ParamArray'

< type1 > '< MemberName >' está em conflito com < type2 > '< MemberName >' sobre a classe base < type3 > '< ClassName >' e deveria ser declarado como 'Shadows'

<tipo1> '<nomedomembro>'sombreia um membro sobrecarregável declarado na base <tipo2> '<nomedaclasse>'

<Tipo1> '<NomeDaPropriedade>' está em conflito com um membro implicitamente declarado para o evento '<NomeDoEvento>' na base <Tipo2> '<NomeDaClasse>'

<type1>'<typename>' e '<typename>' <type2>conflito no <namespace>'<namespacename>'

<type1> '<typename>' e <type2> '<typename>', declarados em '<nome>', conflitam em <namespace> '<namespacename>'

<tipo1> '<nometipo>' não pode ser declarado 'Overrides' porque ele não desautoriza um <tipo1> numa base <tipo2>

<type1>'<typename1>' está em conflito com um membro implicitamente declarado para evento '<eventname>' no '<typename2>' <type2>

'<type1>' não pode substituir <type2>porque não está declarado como 'Overridable'

< type1 > '< tipodenome>' deve implementar '< nomedomembro >' para interface '< nomedainterface >' .

< type1 > '< typename>' deve implementar '< methodname >' para interface '< InterfaceName >' .

<typename> '<membername>' deve ser declarada 'Shadows' pois outro membro com esse nome está declarado como 'Shadows'.

'<typename>' não pode ser usado sistema autônomo atributo porque ele não tem um atributo 'sistema.AttributeUsageAttribute'

'<typename>' não pode ser usado sistema autônomo um atributo porque não herda de 'sistema.Attribute'

'<typename>' não pode ser usado sistema autônomo atributo porque tem métodos 'MustOverride' que não foram substituídos

'<typename>' não pode ser usado sistema autônomo atributo porque está declarado sistema autônomo 'MustInherit'

'<typename>' não pode ser usado sistema autônomo atributo porque não é uma classe

'<typename>' não pode herdar de <type>'<basetypename>' porque expande o acesso da base de <type>fora do assembly

'<typename>' não pode ser sombra de um método 'MustOverride' implicitamente declarado para propriedade '<propertyname>' no '<typename>' <type>

'<typename>' tem o mesmo nome de outro tipo exposto em um agrupar 'My'

'<typename>' no assembly '<assemblyname>' foi encaminhado para si mesmo e, portanto, é um tipo sem suporte

'<typename>' é um tipo de classe e não pode ser usado sistema autônomo uma expressão

'<typename>' é um tipo delegado

'<typename>' é um tipo genérico e requer argumentos de tipo

'<typename>' é um namespace e não pode ser usado sistema autônomo uma expressão

'<typename>' é um tipo de estrutura e não pode ser usado sistema autônomo uma expressão

'<typename>' é um tipo e não pode ser usado sistema autônomo uma expressão

'<typename>' é um tipo em '<containername>' e não pode ser usado sistema autônomo uma expressão

'<typename>' é um tipo Enum e não pode ser usado sistema autônomo uma expressão

'<typename>' é um tipo de interface e não pode ser usado sistema autônomo uma expressão

'<typename>' é um tipo sem suporte

'<typename>' deve ser declarado como 'MustInherit' porque ele contém métodos declarados 'MustOverride'

não é possível converter valores de '<typename>' em 'Char'

'<typename1>' não pode ser convertido em '<typename2>'

'<variablename>' não é uma variável local ou parâmetro e portanto não pode ser usado sistema autônomo variável 'Catch'

<variablename>' não será inferido porque é uma variável local estática

'=' esperado (declaração)

'=' esperado (Let ou conjunto de atribuição)

'=' esperado (inicializador de objeto)

' > ' esperado

Não é possível inferir um tipo que permite valor nulo com para a variável '<variablename>'

Modificador de acesso '<modificadordeacesso>' não é válido

Modificador de acesso só pode ser aplicado a 'Get' ou conjunto ', mas não ambos

Acesso compartilhado membro por meio de uma instância; expressão de qualificação não será avaliada

parâmetros de método 'AddHandler' e 'RemoveHandler' não podem ser declarados como 'ByRef'

sistema autônomo parâmetros de método 'AddHandler' e 'RemoveHandler' devem ter o mesmo delegado digite sistema autônomo o evento recipiente

os métodos 'AddHandler' e 'RemoveHandler' devem ter exatamente um parâmetro

a declaração 'AddHandler' deve terminar com 'participante AddHandler' correspondente

definição de 'AddHandler' faltando para o evento '<eventname>'

'AddHandler' já está declarado.

operando de evento de demonstrativo 'AddHandler' ou 'RemoveHandler' deve ser uma expressão qualificada por ponto ou um nome simples

os parâmetros de método 'AddHandler', 'RemoveHandler' e 'RaiseEvent' não podem ser declarados como '<modifier>'

'AddressOf' não pode ser aplicado a 'methodname' porque 'methodname' é um método parcial

expressão 'AddressOf' não pode ser convertida em '<typename>' porque '<typename>' não é um tipo delegado

expressão 'AddressOf' não pode ser convertida em '<typename>' porque o tipo '<typename>' é declarado como 'MustInherit' e não pode ser criada

expressões 'AddressOf' inválido são válidas em janelas de depurar

expressões 'AddressOf' inválido são válido na primeira expressão de uma demonstrativo 'selecionar caso'

o operando 'AddressOf' deve ser o nome de um método (sem parênteses)

Nome de função agregada não pode ser usado com um caractere de tipo

Alias '< namespacename >' já está declarado

Todos os parâmetros tipados devem ser tipados explicitamente.

Todos os projetos em uma solução Visual Basic devem usar a mesma plataforma, mas o projeto que está tentando adicionar visa uma plataforma diferente da especificada pela sua solução

Uma expressão incorporada não pode ser usada aqui

'E' esperado

Inicializadores de tipo anônimo inválido são válido em janelas de depurar

O nome do membro de tipo anônimo pode ser deduzido apenas a partir de um nome simples ou qualificado sem argumentos

O nome do membro de tipo anônimo deve ser precedido por um período

Tipo de Membro anônimo ou propriedade '<propertyname>' já está declarada.

Propriedade de Membro de tipo anônimo '< PropertyName >' não pode ser usada para inferir o tipo de outra propriedade de membro porque o tipo de '< PropertyName >' ainda não está estabelecido.

Tipo anônimo deve conter pelo menos um membro

Propriedade de tipo anônimo '<propertyname>' não pode ser usada na definição de uma expressão lambda dentro da mesma lista inicialização

O parâmetro do argumento correspondente '< ParameterName >' restringe de '< type1 >' para '< type2 >'

Parâmetro correspondente de argumento '<parametername>' restringe a '<typename>'

Argumento não especificado para o parâmetro '<parametername>'

Argumento não especificado para o parâmetro '<parametername>' de '<methodname>'

Argumento não especificado para o parâmetro '<parametername>' do método de extensão '<methodname>' definido em '<typename>'

Argumentos não podem ser passados para um 'New' usado em um parâmetro do tipo

Os limites de uma matriz não podem aparecer em especificadores de tipo

Declarações de matriz não podem especificar limites inferiores

Matriz declarada como para variável de controle de loop não pode ser declarada com um tamanho inicial

As dimensões de matriz não podem ter dimensionar negativo

Arrays excedem o limite de 32 dimensões

Inicializador de matriz não pode ser especificado para uma dimensão não constante; use o inicializador vazio '{}'

O inicializador de matrizes tem elementos demais <number>.

O Inicializador de array tem poucas dimensões

Inicializador de matriz tem muitas dimensões

Faltam <number> elementos no inicializador de matrizes

Inicializadores de matrizes são válidos somente para matrizes, mas o tipo da '<nomedavariavel>' é '<nomedotipo>'

Limites inferiores da matriz podem ser somente ' 0 '

Não é possível especificar modificadores de matriz em uma variável e seu tipo

Modificadores de matriz não podem ser especificados em nome parâmetros expressão lambda, apenas no seu tipo

Faltando Expressão subscrita de matriz

Matrizes não podem ser declaradas com 'New'

Matrizes declaradas como membros de estruturas não podem ser declaradas com um tamanho inicial.

Matrizes do tipo 'System.Void' não são permitidas nesta expressão

Matrizes usadas como argumentos de atributo são necessárias para especificar explicitamente valores para todos os elementos

'sistema autônomo Any' não tem suporte no instruções 'Declare'

'sistema autônomo' esperado

'sistema autônomo', vírgula ou ') ' esperado

O assembly '<assemblyname>' não pode ser criado porque seu caminho tem mais de 259 caracteres

O assembly '<filepath1>' faz referência ao assembly '<assemblyidentity>', que é ambíguo entre '<filepath2>' (referenciado pelo projeto '<projectname1>') e '<filepath3>' (referenciado pelo projeto '<projectname2>')

O assembly '<filepath1>' faz referência ao assembly '<assemblyidentity>', que é ambíguo entre '<filepath2>' e '<filepath3>'

Atributo do assembly '<attributename>' inválido: <erro>

Declarações de atributo Assembly ou Módulo devem preceder quaisquer declarações num arquivo

'Assembly' ou 'módulo' esperado

Pelo menos um tipo de parâmetro deste operador binário deve ser do tipo recipiente '<typename>'

Atributo '<attributename>' não pode ser aplicado várias vezes

O atributo '<attributename>' não pode ser aplicado a '<membername>' porque o atributo não é válido nesse tipo de declaração.

Atributo '<attributename>' não pode ser aplicado a um método com parâmetros opcionais.

Atributo '<attributename>' não pode ser aplicado a um módulo

O atributo '<attributename>' não pode ser aplicado a um assembly

Atributo '< nome de atributo >' não pode ser especificado mais de uma vez no projeto atual, mesmo com valores de parâmetro idênticos

Atributo '<attributename>' inválido: <erro>

Atributo não pode ser usado porque não tem um construtor Public

Atributo 'condicional' só é válido em declarações 'Sub'

Constante de atributo '< nomedaconstante >' não pode ser o destino de uma atribuição

O construtor de atributos tem um parâmetro 'ByRef' do tipo '<typename>'; não é possível usar construtores com parâmetros byref para aplicar o atributo

O construtor de atributos tem um parâmetro de tipo '<tipo>', que é não um inteiro, ponto flutuante, ou tipo enum ou um Char, String, Boolean, System.Type ou uma matriz unidimensional desses tipos

Membro de atributo '<membername>' não pode ser o destino de uma atribuição porque não está declarado como 'Public'

Especificador de atributo não é uma declaração completa

Não é suporte para atributo 'sistema.tempo de execução.InteropServices.DefaultCharSetAttribute' nesta versão

Valor do atributo não é válido; esperando 'Valor'

Valor atributo não é válido; esperando 'valor1' ou 'valor2'

Não é possível aplicar atributos às variáveis locais

Não é possível aplicar atributos a parâmetros de expressões lambda

Atributos não podem ser genéricos ou tipos aninhados genéricos

Valor incorreto da soma de verificação, dígitos não hexadecimais ou número ímpar de dígitos hexadecimais

Formato de GUID Inválido

XML malformado. O arquivo '< commentfile >' não pode ser incluído

Classe base '<baseclassname1>' especificado para classe '<partialclassname>' não pode ser diferente da classe base '<baseclassname2>' de um dos seus outros tipos parcial

Limites podem ser especificados somente para a matriz de nível superior ao inicializar uma matriz de matrizes

Está faltando o ']' de fechamento do identificador entre colchetes.

Ramificação fora de um 'Finally' não é válida

'Por' esperado

'ByRef' parâmetro '<parâmetroname>' não pode ser usado em uma expressão lambda

parâmetro 'ByRef' <parametername>não pode ser usado em uma expressão de consulta

não é possível combinar 'ByVal' e 'ByRef'

Não é possível converter tipo anônimo em árvore de expressão porque ele contém um campo que é usado na inicialização de outro campo

Não é possível converter para '<type>'

Não é possível converter 'tipo' para 'type2'

Não é possível copiar o valor do parâmetro 'ByRef' '<parametername>' para o argumento correspondente por que o tipo '<typename1>' não pode ser convertido para o tipo '<typename2>'

Não é possível criar uma instância de módulo '< nomedomódulo >'

Não é possível localizar o diretório do .NET estrutura: <erro>

Não é possível implementar '<nomeinterface1>.<nomemembro>' porque sua implementação poderia entrar em conflito com a implementação para '<nomeinterface2>.<nomemembro>' para alguns argumentos de tipo.

Não é possível implementar a interface '<interfacename1>' porque sua implementação poderia entrar em conflito com a implementação de outra interface implementada '<interfacename2>' para alguns argumentos de tipo

Não é possível inferir um tipo comum para o primeiro e segundo operandos do operador 'If' binário

Não é possível inferir um tipo comum para o segundo e terceiro operandos do operador 'If'

Não é possível inferir um tipo de dados para '<variablename>' porque as dimensões de matriz não coincidem

Não é possível herdar a interface '<interfacename1>' porque ela pode ser idêntica à interface '<interfacename2>' para alguns argumentos de tipo

Não pode herdar a interface '<interfacename1>' porque ela pode ser idêntica a interface '<interfacename2>' , da qual a interface '<interfacename3>' herda alguns argumentos de tipo.

Não é possível herdar a interface '<interfacename1>' porque a interface '<nomedainterface2>' de onde ela herda pode ser idêntica à interface '<nomedainterface3>' para alguns tipos de argumentos.

Não é possível herdar a interface '<interfacename1>' porque a interface '<nomedainterface2>' de onde ela herda pode ser idêntica à interface '<nomedainterface3>' de onde a interface '<interfacename4>' herda para alguns tipos de argumentos.

Não pode referenciar '<name>' porque é um membro do campo com valor escrito '<nome>' de classe '<nomedeclasse>' que tem 'System.MarshalByRefObject' como classe base.

Não é possível fazer referência a um membro de instância de uma classe de dentro de um método compartilhado ou inicializador de membro compartilhado sem uma instância explícita da classe

Não é possível enviar relatório de erros automaticamente

Não é possível conjunto o valor de uma variável local para um método que não esteja na parte superior da pilha

Não é possível especificar /win32icon e /win32resource

Não é possível abrir '<nomearquivo>' para gravação

'caso' só pode aparecer dentro de uma demonstrativo selecionar caso

'caso' não pode seguir um 'caso Else' na mesma demonstrativo 'selecionar'

'caso Else' só pode aparecer dentro de uma demonstrativo 'selecionar caso'

instruções 'caso' inválido são válidas na janela Verificação imediata

Casing do espaço para nome nome '<namespacename1>' não corresponde ao uso de maiúsculas e minúsculas do nome do namespace '<namespacename2>' no arquivo '<filepath>'

bloco ' catch' nunca alcançado porque '<name1>' herda de '<name2>'

bloco 'Catch' nunca alcançado; <exceção>manipulado acima na mesma demonstrativo 'Try'

'Catch' não pode aparecer após 'Finally' dentro de uma demonstrativo 'Try'

'Catch' não pode aparecer fora de uma demonstrativo 'Try'

'Catch' não pode detectar o tipo '<typename>' porque ele não é 'sistema.exceção' ou uma classe que herda de 'sistema.exceção'

'Catch' deve finalizar com 'participante Try' correspondente

instruções 'Catch' inválido são válido na janela Verificação imediata

não não possível converter valores 'Char' em '<typename>'

O caractere 'character' (0 x < hexadecimal >) não é permitido no início de um nome XML

Caractere 'character' (0x<hexadecimal>) não é permitido no nome de um XML

Caractere 'character' (0x<hexadecimal>) não é permitido em XML literal

Constante de caractere deve conter exatamente um caractere

Caractere inválido

A sequência de caracteres '--' não é permitida em um comentário XML

Classe '<nomeclasse>' não pode ser encontrada

Classe '<classname>' não pode ser indexada porque não tem nenhuma propriedade padrão

Classe '<classname>' não pode herdar de si mesma: <mensagem>

Classe '<classname>' não pôde ser criada: <erro>

Classe '<NomeDaClasse>' não tem 'Sub New' acessível e não pode ser herdada

Classe '<classname>' deve declarar 'Sub New' porque sua classe base '<classname2>' não tem um 'Sub New' acessível que pode ser chamado sem argumentos

Classe '<nomeclasse>' deve declarar um 'Sub New' porque o '<nomeconstrutor>' na sua classe base '<nomeclassebase>' está marcado como obsoleto

Classe '<classname>' deve declarar 'Sub New' porque '<constructorname>' em sua classe base '<baseclassname>' está marcado como obsoleto: '<errormessage>'

Classe '<classname>' deve ser declarada como 'MustInherit' ou substituir os seguintes membros 'MustOverride' herdados: <membername(s)>

Classe '<classname>' deve declarar 'Sub New' porque '<constructorname>' em sua classe base '<baseclassname>' está marcado como obsoleto

Classe '<classname>' deve declarar 'Sub New' porque '<constructorname>' em sua classe base '<baseclassname>' está marcado como obsoleto: '<errormessage>'

Classe '<classname1>' deve declarar um 'Sub New' pois sua classe base '<classname2>' tem mais de um 'Sub New' acesssíveis que podem ser chamados sem argumentos.

restrição 'Class' e uma restrição de tipo de classe específica não podem ser combinados

restrição 'classe' e a restrição 'estrutura' não podem ser combinados

restrição 'classe' não é possível especificar várias vezes para o mesmo parâmetro de tipo

Classe numa interface não pode ser declarada como '<specifier>'

demonstrativo 'classe' deve finalizar com 'participante classe' correspondente

Não há mais suporte para o evento 'Class_Initialize'

Não há mais suporte para o evento 'Class_Terminate'

Classes podem herdar somente de outras classes

Classes não podem ser declaradas como '< especificador >'

As classes que são genérica ou contidas em um tipo genérico não podem herdar de uma classe de atributos

Página de código '<nome>' é inválido ou não está instalado

Vírgula esperada

Vírgula ou ')' esperado (lista de parâmetros de procedimento)

Vírgula ou ')' esperados (Lista de Argumento de Tipo)

Vírgula ou ') ' esperado (lista de parâmetros de tipo)

Vírgula, ') ', ou uma continuação de expressão válida esperada

Instruções comentário não podem ser avaliadas.

'comparar' esperado

Falha na compilação: <mensagem>

Conflito entre o 'DefaultMemberAttribute' definido em '|1' e a propriedade padrão

Está em conflito com '<name1>', que é implicitamente criada para '<name2>' no '<name3>' <type>

Declaração Const não pode ter um inicializador de matriz

Constante '< nomedaconstante >' não pode depender de seu próprio valor

A constante não pode ser o destino de uma atribuição

Expressão de constante é necessária

Expressão constante não representável no tipo '<typename>'

Constantes devem ser de um tipo intrínseco ou enumerado, não uma classe, estrutura, parâmetro de tipo ou tipo matriz.

Constantes precisam ter um valor

A restrição '< constraint1 >' está em conflito com a restrição '< constraint2 >' já especificada para parâmetro do tipo '< typeparametername >'

A restrição '<constraint1>' está em conflito com a restrição indireta '<constraint2>' obtida da restrição de parâmetro de tipo '<typeparameter1>'

Tipo de restrição '<tipo de nome>' já especificado para este tipo de parâmetro

Restrições para este parâmetro do tipo não coincidem as restrições sobre o parâmetro do tipo correspondente definido em um dos outros tipos parciais de '|1'

Construção faz uma referência indireta ao conjunto de módulos (assembly) '< AssemblyName >', que contém '< NomeDoTipo >'

Construção faz uma referência indireta ao projeto '<projectname>', que contém '<typename>'

Construtor <'nome'> não pode chamar ele mesmo

telefonar de construtor é válida somente sistema autônomo a primeira demonstrativo em um construtor de instância

Construtor deve ser declarado sistema autônomo sub, não sistema autônomo uma função

Construtores não podem implementar métodos de interface

'Continue Do' só pode aparecer dentro de uma demonstrativo 'Do'

'Continue For' só pode aparecer dentro de uma demonstrativo 'For'

'Continue' deve ser seguido por 'Do', 'For' ou 'While'

'Continue' inválido são instruções válido na janela Verificação imediata

'Continue While' só pode aparecer dentro de uma demonstrativo 'While'

Conversão de '<type1>' para '<type2>' não pode ocorrer em uma expressão de constante

Conversão de '<tipo1>' em '<tipo2>' não pode ocorrer em uma expressão constante usada como um argumento para um atributo

Conversão de 'Date' para 'Double' requer chamar o método 'Date.ToOADate'

Conversão de 'Double' em 'data' requer a chamada 'data.FromOADate'

Os operadores de conversão não podem converter de um tipo de base

Os operadores de conversão não podem converter de um tipo derivado

Operadores de conversão não podem converter de um tipo para seu tipo base

Operadores de conversão não podem converter de um tipo para seu tipo derivado.

Operadores de conversão não podem converter de um tipo para um mesmo tipo

Operadores de conversão não podem converter de um tipo de interface

Operadores de conversão não podem converter de Objeto

Operadores de conversão não podem converter para um tipo de interface

Os operadores de conversão não podem converter em Object

Os operadores de conversão devem ser declarados 'Widening' ou 'Narrowing'

Conversões de '< typename1 >' para '< typename2 >' devem ser explícitas

Copiar o valor do parâmetro 'ByRef' '< ParameterName >' de volta para o argumento correspondente limita o '< typename1 >' para o tipo '< typename2 >'

Não foi possível encontrar biblioteca '<libraryname>'

Não foi possível localizar a biblioteca padrão: '<filename>'

'Moeda' não é mais um tipo com suporte; use 'Decimal'

'Custom evento' deve finalizar com 'participante evento' correspondente

o modificador 'Custom' só pode ser usado imediatamente antes ' evento ' declaração

o modificador 'Custom' inválido em eventos declarados em interfaces

o modificador 'Custom' inválido em eventos declarados sem tipos delegado explícitos

' d ' não pode mais ser usado para indicar um expoente, use 'E' em vez disso

Tipos de dados do tipo parâmetro (s) não pode ser deduzido a partir desses argumentos

Dados dos parâmetros de tipo não não possível inferir os tipos de com esses argumentos porque há mais de um tipo possível base

(s) tipo de dados não do tipo de parâmetro (s) pode ser deduzido a partir desses argumentos porque eles não são convertidos para o mesmo tipo

Tipos de dados do tipo de parâmetros no método de extensão '<methodname>' definido em '<typename>' não podem ser deduzidos a partir desses argumentos

Tipos de dados do tipo inferir parâmetros no método de extensão '<methodname>' definido em '<typename>' não podem ser de com base nesses argumentos porque há mais de um tipo possível

(s) tipo de dados não do tipo de parâmetros no método de extensão '<methodname>' definidos em 'typename' pode ser deduzidos a partir desses argumentos porque eles não são convertidos para o mesmo tipo

Dados dos parâmetros de tipo no método '<methodname>' não não possível inferir os tipos de com estes argumentos base

Dados dos parâmetros de tipo no método '<methodname>' não não possível inferir os tipos de com estes argumentos porque há mais de um tipo possível base

Dados dos parâmetros de tipo no método '<methodname>' não não possível inferir os tipos de com esses argumentos porque eles não são convertidos para o mesmo tipo de base

Constante de data não é válida

Declaração esperada

'Declare' instruções não são permitidas em genérica tipos ou tipos contidos em tipos genéricos

Instruções de declaração em um módulo não podem ser declaradas como '< specifier >'

instruções 'Declare' em uma estrutura não podem ser declaradas '<especificador>'

'padrão' pode ser aplicado a apenas uma propriedade nome em um <type>

'padrão' não pode ser combinado com '<especificador>'

Membro padrão '<membername>' não é uma propriedade.

Propriedade padrão '< propertyname1 >' está em conflito com a propriedade padrão '< propertyname2 >' em '< ClassName >' e por isso deve ser declarada como 'Shadows'

Acesso de propriedade padrão é ambíguo entre os membros de interface herdados '<nomepropriedadepadrão>' da interface '<nomeinterface1>' e '<nomepropriedadepadrão>' da interface '<nomeinterface2>'

Valores padrão não podem ser fornecidos para parâmetros que não estão declarados 'Optional'

Definição do método <method>não está acessível neste contexto

A classe Delegate '<classname>' não possui nenhum método Invoke e, por isso, uma expressão deste tipo não pode ser o alvo de uma chamada de método

Construtor delegado para o tipo '<typename>', necessário para implementação de delegates, não foi encontrado

Um delegado numa interface não pode ser declarado '<specifier>'.

Tipo delegate '< delegateName >' de evento '< EventName >' não é compatível com CLS

Delegados não podem manipular eventos

Delegados não podem implementar métodos de interface

Classes derivadas não podem disparar eventos de classes base.

Divisão por zero ocorreu durante a avaliação desta expressão

'Do' deve finalizar com 'Loop' correspondente

Atributo XML 'attributeName' duplicado.

Ou o tipo de parâmetro ou o tipo de retorno do operador da conversão deve ser do tipo recipiente.

Elemento não tem um marca de fim

Nomes de elementos não podem usar o prefixo 'xmlns'

'Else' deve ser precedido por um 'If' ou 'ElseIf' correspondente

'ElseIf' deve ser precedido por um 'If' ou 'ElseIf' correspondente

'participante AddHandler' deve ser precedido por uma declaração 'AddHandler' correspondente

'participante AddHandler' deve ser a primeira demonstrativo em uma linha

'participante classe' deve ser precedido por 'classe' correspondente

'participante Enum' deve ser precedido por 'Enum' correspondente

'participante evento' deve ser precedido por 'Custom evento' correspondente

'participante função' esperado

'participante função' deve ser precedido por 'função' correspondente

'participante função' deve ser a primeira demonstrativo em uma linha

'participante Get' deve ser precedido por 'Get' correspondente

'participante Get' deve ser a primeira demonstrativo em uma linha

'participante If' deve ser precedido por correspondente 'If'

'participante Interface' deve ser precedido por 'Interface' correspondente

'participante módulo' deve ser precedido por 'módulo' correspondente

'participante Namespace' deve ser precedido por 'Namespace' correspondente

Fim da expressão esperado

Fim da lista de parâmetro esperada

Fim da declaração esperada

'participante operador' esperado

'participante operador' deve ser precedido por 'operador' correspondente

'participante operador' deve ser a primeira demonstrativo em uma linha

'participante a propriedade' deve ser precedido por 'Property' correspondente

'participante RaiseEvent' deve ser precedido por uma declaração 'RaiseEvent' correspondente

'participante RaiseEvent' deve ser a primeira demonstrativo em uma linha

'participante RemoveHandler' deve ser precedido por uma declaração 'RemoveHandler' correspondente

'participante RemoveHandler' deve ser a primeira demonstrativo em uma linha

'participante selecionar' deve ser precedido por um correspondente 'selecionar caso'

'participante conjunto 'deve ser precedido por correspondente' conjunto'

'participante conjunto' deve ser a primeira demonstrativo em uma linha

demonstrativo 'participante' não pode ser usada em projetos de biblioteca de classes

demonstrativo 'participante' inválido é válida

instruções 'participante' inválido são válido na janela Verificação imediata

'participante estrutura' deve ser precedido por 'estrutura' correspondente

'participante Sub' esperado

'participante Sub' deve ser precedido por 'Sub' correspondente

'participante Sub' deve ser a primeira demonstrativo em uma linha

'participante SyncLock' deve ser precedido por 'SyncLock' correspondente

Marca End </tagName> esperada

'participante Try' deve ser precedido por 'Try' correspondente

'participante Using' deve ser precedido por 'Using' correspondente

'participante While' deve ser precedido por 'While' correspondente

'participante With' deve ser precedido por 'With' correspondente

Não há mais suporte de instruções 'EndIf'; use 'participante If'

Enum '<enumname>' deve conter pelo menos um membro

Enum é uma interface que não pode ser declarada '<especificador>'

'Enum' deve finalizar com 'participante Enum' correspondente

Tipos Enum não podem ser anuláveis

Enumerações devem ser declaradas como um tipo integral

'Equals' não é possível comparar um valor de tipo <type1>com um valor de tipo <type2>

'Equals' esperado

Erro ao criar manifesto do assembly: mensagem de erro >

Erro ao criar recursos Win32: mensagem de erro >

Erro ao incorporar o manifesto Win32: <manifesto>

Erro ao incorporar o manifesto Win32: Não é possível encontrar o arquivo de manifesto <file>

Erro ao incorporar o manifesto Win32: / Opção win32manifest entra em conflito com /nowin32manifest

Erro na importação de nível de projeto '<qualifiedelementname>' no '<qualifiedcontainername>': <errormessage>

Erro ao salvar arquivo de recurso Win32 temporário '<filename>': mensagem de erro >

Erro ao configurar a opção de manifesto do assembly: mensagem de erro >

instruções 'erro' inválido são válidas na janela Verificação imediata

Ocorreram erros ao compilar os Esquemas XML no projeto

Avaliação de expressão ou instrução interrompida

Avaliação de expressão ou instrução esgotado

Avaliação de expressões lambda inválido no depurador

Evento '<eventname>' não pode ser encontrado

Não é possível manipular o evento '<eventname>' porque ele não é acessível a partir de '<nome>'

Evento '<nomeevento>' especificado pelo atributo 'DefaultEvent' não é um evento publicamente acessível para esta classe

Evento '< EventName >' declara implicitamente '< MemberName >', que está em conflito com um membro na base < tipo > '< ClassName >', e então o evento deve ser declarado como 'Shadows'

Eventos '<eventname1>' não podem implementar eventos '<eventname2>' porque seus tipos delegados não correspondem aos tipos delegados de outro evento implementado por '<eventname1>'

O Evento '<eventname1>' não pode implementar o evento '<eventname2>' na interface '<interface>'porque seus tipos delegados '<delegado1>' e <'delegado2'> não correspondem.

O comprimento do nome do evento não pode exceder 1011 caracteres

Eventos não podem ser declarados com tipo delegado que tenha um tipo de retorno.

Eventos não podem ter um tipo de retorno

Eventos declarados com ' sistema autônomo' cláusula deve ter um tipo delegado

Eventos em um Módulo não podem ser declarados como '<specifier>'

Eventos em interfaces não podem ser declarados como '< implements >'

Eventos de variáveis WithEvents compartilhadas não podem ser manipuladas por métodos não compartilhados.

'sair AddHandler', 'sair RemoveHandler' e 'sair RaiseEvent' inválido são válido

'sair Do' só pode aparecer dentro de uma demonstrativo 'Do'

'sair For' só pode aparecer dentro de uma demonstrativo 'For'

'sair função' inválido em sub ou propriedade

'sair ' deve ser seguido por 'Sub', 'função', 'propriedade', 'Do',' para', 'While', 'selecionar' ou 'Try'

'sair operador' inválido. Utilize 'Return' para sair de um Operador

'sair a propriedade' inválido em função ou sub

'sair selecionar' só pode aparecer dentro de uma demonstrativo 'selecionar'

instruções 'sair' inválido são válidas na janela Verificação imediata

'sair Sub' inválido em função ou propriedade

'sair Try' só pode aparecer dentro de uma demonstrativo 'Try'

'sair While' só pode aparecer dentro de uma demonstrativo 'While'

Esperado ' % = ' no início de uma expressão incorporada

Marca de participante XML ' / ' esperado

Início esperado ' < ' para uma marca XML

Fechamento esperado ' % > ' para expressão incorporada

Fechamento esperado ';' para a entidade XML

Fechamento esperado '?>' para instrução de processador XML

Fechamento esperado ']] > ' para a seção XML CDATA

-->' de fechamento esperado para comentário XML

Fechamento '>' esperado para tag XML

Correspondência Esperada ao fechar aspas duplas para valor atributo XML

Esperadas aspas de fechamento correspondentes para o valor XML de atributo

Esperado um de 'Dim', 'Const', 'Public', 'Private', 'Protected', 'Friend', 'Shadows', 'ReadOnly' ou 'Shared'

Inicialização explícita não é permitida para matrizes declaradas com limites explícitos

Inicialização explícita não é permitida com múltiplas variáveis declaradas com um especificador de tipo único

Expoente não é válido

Expressão não pode aparecer dentro de um valor de atributo entre aspas

Expressão não pode ser convertida em uma árvore de expressão

A expressão não pode ser avaliada dessa vez

Expressão não produz um valor

Expressão esperada

Expressão tem o tipo '< NomeDoTipo >' que é um tipo restrito e não pode ser usado para acessar membros herdados de 'Object' ou 'ValueType'

Expressão é um valor e, portanto, não pode ser o destino de uma atribuição

Expressão não é um método

Expressão não é uma matriz ou um método e não pode ter uma lista de argumentos

Expressão é do tipo '<typename>' que não é um tipo de coleção

Expressão do tipo < tipo > é não questionável

A expressão do tipo '<typename>' não pode ser convertida em 'objeto' ou 'ValueType'

Expressão do tipo '<typename1>' nunca pode ser do tipo '<typename2>'

Expressão ou instrução não é válida em janelas de depuração

Expressão chama recursivamente o Operador recipiente '<operatorsymbol>'.

Expressão chama recursivamente a propriedade '<propertyname>' contida

o atributo 'extensão' pode ser aplicado somente para declarações 'módulo', 'Sub' ou 'função'

Método de extensão '<methodname>' definido em '<modulename>' não tem uma assinatura compatível com delegado '<delegatename>'

Método de extensão '< methodname >' definido em '< modulename >' não é genérico (ou não tem parâmetros livres de tipo ) e portanto não pode ter argumentos de tipo

Método de extensão '<methodname>' definido em '<typename>' não tem a mesma assinatura do delegado '<delegatename>'

Método de extensão '<methodname>' tem restrições de tipo que nunca podem ser atendidas

Métodos de extensão podem ser definidos apenas em módulos

Métodos de extensão devem declarar pelo menos um parâmetro

Campo '<nomedocampo>' é de um tipo não suportado

O campo ou propriedade '< MemberName >' não é encontrado

Arquivo <arquivo> não foi encontrado

Nome de arquivo já declarado com um valor GUID e soma de verificação diferentes

'Finally' só pode aparecer uma vez em uma demonstrativo 'Try'

'Finally' não pode aparecer demonstrativo fora um 'Try'

'Finally' deve finalizar com 'participante Try' correspondente

instruções 'Finally' inválido são válido na janela Verificação imediata

O primeiro operando em uma expressão 'If' binária deve ser anulável ou um tipo de referência

A primeira instrução de um corpo de método não pode ser na mesma linha como a declaração de método

A primeira declaração deste ' Sub New ' deve ser uma chamada para 'MyBase.New' ou 'MyClass.New' (mais de um construtor acessível sem parâmetros)

A primeira declaração deste ' Sub New ' deve ser uma chamada para 'MyBase.New' ou 'MyClass.New' (mais de um construtor acessível sem parâmetros)

A primeira declaração deste 'Sub New' deve ser uma chamada explícita do 'MyBase.New' ou 'MyClass.New' proque o '<constructorname>' na classe base '<baseclassname>' da '<derivedclassname>' está marcada como obsoleta.

Primeira demonstrativo deste 'Sub New' deve ser uma telefonar explícita para 'MyBase.New' ou 'MyClass.New' porque '<constructorname>' na classe base '<baseclassname>' de '<derivedclassname>' está marcado como obsoleto: '<errormessage>'

A primeira declaração deste 'Sub New' deve ser uma chamada explícita do 'MyBase.New' ou 'MyClass.New' proque o '<constructorname>' na classe base '<baseclassname>' da '<derivedclassname>' está marcada como obsoleta.

Primeira demonstrativo deste 'Sub New' deve ser uma telefonar explícita para 'MyBase.New' ou 'MyClass.New' porque '<constructorname>' na classe base '<baseclassname>' de '<derivedclassname>' está marcado como obsoleto: '<errormessage>'

'For Each' digite em '<typename>'é ambíguo porque o tipo implementa várias instanciações de' sistema.Collections.Generic.IEnumerable (Of T)'

Variável de controle de loop '<variablename>' já está em uso por um loop for delimitador

'variável de controle de loop já em uso por um 'loop for' delimitador for'

'loop for' variável de controle não pode ser do tipo '<type>'

'For' deve finalizar com 'Next' correspondente

A referência do assembly autorizado <reference> é inválida.

<reference>De referência de assembly Friend é inválido. Declarações InternalsVisibleTo não podem ter uma versão, cultura, token de chave pública ou arquitetura de processador especificada.

Caracteres de largura total inválido são válido sistema autônomo delimitadores de XML

Nomes totalmente qualificados para tipos em namespaces não podem ter mais de caracteres <number>

Função '<procedurename>' não retorna um valor em todos os caminhos de código

A função de avaliação está desativada porque uma função anterior teve seu tempo esgotado

Função sem ' sistema autônomo' cláusula; tipo de retorno de objeto assumido

Métodos genéricos não podem ser expostos ao COM

Métodos genéricos não podem usar cláusula 'Handles'

O tipo de restrição de parâmetro genérico <typename>não é compatível com CLS

Parâmetros genéricos usados como tipos de parâmetro opcionais devem ser restritos de classe.

Tipo genérico '<generictypename>' não é possível importar mais de uma vez

acessador 'Get' da propriedade '<propertyname>' não está acessível

'Get' já está declarado

demonstrativo 'Get' deve finalizar com 'participante Get' correspondente

Não há mais suporte para instruções 'Get'

instruções 'Get' não são mais suportadas (Visual Basic)

'Global ' deve ser seguido por'.' e um identificador

'Global' não permitido em identificadores; nome local esperado

'Global' não é permitida neste contexto; identificador esperado

Não há mais suporte para instruções 'GoSub'

'GoTo <labelname>' inválido porque '<labelname>' está contido em uma demonstrativo 'For ' ou ' for each' que inválido contém essa demonstrativo

'GoTo <labelname>' inválido porque '<labelname>' está contido em uma demonstrativo 'SyncLock' que inválido contém essa demonstrativo

'GoTo <labelname>' inválido porque '<labelname>' está dentro de 'Try', 'Catch' ou 'Finally' demonstrativo que inválido contém essa demonstrativo

'GoTo <labelname>' inválido porque '<labelname>' está contido em uma demonstrativo 'With' que inválido contém essa demonstrativo

'GoTo <linelabel>' inválido porque '<linelabel>' está contido em uma demonstrativo 'Using' que inválido contém essa demonstrativo

instruções 'GoTo' inválido são válidas na janela Verificação imediata

Ir para o rótulo '< nomedorótulo >' não pode ser usado dentro de expressões lambda

'agrupar' não permitido neste contexto; identificador esperado

'agrupar' ou um identificador esperado

A cláusula Handles requer uma variável WithEvents definida no tipo que a contém ou um dos seus tipos base.

'Handles' em classes devem especificar uma variável 'WithEvents', 'MyBase',' MyClass' ou 'Me' qualificada com um identificador único

' handles' em módulos devem especificar uma variável 'WithEvents' qualificada com um identificador único

'Handles' inválido em declaração do operador

Identificador esperado

Identificador esperado, precedido de um ponto

Identificador é grande demais

'If' deve finalizar com 'participante If' correspondente

operandos 'If' não podem ser argumentos nomeados

o operador 'If' requer dois ou três operandos

'If', 'ElseIf', 'Else', 'participante If' ou 'Const' esperado

Ignorando opção /noconfig porque ela foi especificada em um arquivo de resposta

Expressão de telefonar ilegal ou de índice

O tipo implementado deve ser uma interface

Classe de implementação '<nomedaclasse >' para interface < nomedainterface > não pode ser encontrada

Implementar classe '<underlyingclassname>' para interface '<interfacename>' não é acessível neste contexto porque ele é '<accesslevel>'

'Implements' inválido em declaração do operador

'Implements' inválido em módulos

demonstrativo 'Implements' deve siga qualquer demonstrativo 'Inherits' e preceder todas as declarações em uma classe

Conversão implícita de '< typename1 >' para '< typename2 >'

Conversão implícita de '<typename1>' para '<typename2>' ao copiar o valor de 'ByRef 'parâmetro' <parametername>' de volta para o argumento correspondente.

Variável implícita '<nomedevariável>' é inválida por causa de '<mensagem>'

Falha na importação do tipo '< NomeDoTipo >' do assembly ou do módulo '< nome >'

Importações alias '<name>' está em conflito com '<name2>' declarado no espaço para nome raiz

instruções 'Imports' devem preceder qualquer declaração

'In' esperado

Uso inadequado da palavra-chave <keyword> em um módulo

O índice '<indexnumber>' para dimensão '<dimensionnumber>' está fora do intervalo

Restrição indireta '<constraint1>' obtida do tipo de parâmetro restrição '<typeparameter1>' está em conflito com a restrição '<constraint2>'

A restrição indireta '< constraint1 >' obtida da restrição de parâmetro do tipo '< typeparameter1 >' está em conflito com a restrição indireta '< constraint2 >' obtida da da restrição de parâmetro do tipo '< typeparameter2 >'

Referência indireta está sendo feita para o assembly <assemblyname> versão <laterversionnumber>, que contém '<typename>'

Informações para o tipo de '<typename>' não foi carregadas no tempo de execução

Herdar de ' sistema. <classname>' inválido

'Inherits' só pode aparecer uma vez dentro de uma demonstrativo 'Class' e só pode especificar uma classe

'Inherits' inválido válido em módulos

demonstrativo 'Inherits' deve preceder todas as declarações em uma classe

instruções 'Inherits' devem preceder todas as declarações em uma interface

Erro de inicialização

Inicializador esperado

Inicializadores em mebros de estrutura são válidos apenas para membros e constantes 'Shared'

Os membros da instância e 'Me' não podem ser usados em uma expressão de consulta

Membros de instância e 'Me' não podem ser usados numa expressão lambda em estruturas.

Instância de tipo restrito '<typename>' não pode ser usada em uma expressão lambda

Instância de tipo restrito '<typename>' não pode ser usada em uma expressão de consulta

Constante de inteiro esperado

Interface '< InterfaceName >' pode ser implementada apenas uma vez por este tipo

Interface '<interfacename>' não pode ser indexada porque não tem nenhuma propriedade padrão

Interface '<interfacename>' não pode herdar de si mesma: <mensagem>

Interface '<interfacename>' não é implementada por esta classe

Interface pode herdar somente de outra interface

Membros de interface devem ser métodos, propriedades, eventos, ou definições de tipos

'Interface' deve finalizar com 'participante Interface' correspondente

'parâmetros InterfaceId' e 'EventsId' para 'Microsoft.VisualBasic.ComClassAttribute' em '<typename>' não pode ter o mesmo valor

Erro interno do compilador

Erro interno do compilador: Gerador de códigos recebeu uma entrada incorreta

'Em' esperado

'Is' esperado

'Is' operando do tipo '<typeparametername>' pode ser comparado apenas a 'Nothing' porque '<typeparametername>' é um parâmetro de tipo sem nenhuma restrição de classe

operando 'Is' do tipo 'typename' só pode ser comparado a 'Nothing' porque 'typename' é um tipo que permite valor nulo

'Is' requer operandos que tenham tipos de referência, mas esse operando tem o tipo de valor '<typename>'

operando 'IsNot' do tipo '<typeparametername>' pode ser comparado apenas a 'Nothing' porque '<typeparametername>' é um parâmetro de tipo sem nenhuma restrição de classe

operando 'IsNot' do tipo 'typename' só pode ser comparado a 'Nothing' porque 'typename' é um tipo que permite valor nulo

'IsNot' requer operandos que tenham tipos de referência, mas esse operando tem o tipo de valor '<typename>'.

'Ingressar' esperado

Palavra chave não nomeia um tipo

Palavras-chave não são válidas como um identificador

Rótulo '<labelname>' já está definido no método corrente

Rotulo '<nomedorotulo>' não definido

Rótulos inválido são válido na janela Verificação imediata

Rótulos não são métodos exteriores válidos

Rótulos que são números devem ser seguidos por dois-pontos

Expressão lambda não pode ser convertido em '<typename>' porque '<typename>' não é um tipo delegado

Expressão lambda não pode ser convertido em '<typename>' porque o tipo '<typename>' é declarado como 'MustInherit' e não pode ser criado

Expressão lambda não será removido do manipulador de eventos

Expressões lambda não são válidas na primeira expressão de uma declaração 'Select Case'

Parâmetro lambda '<parameter>' oculta uma variável em bloco delimitador, uma variável de intervalo definida anteriormente ou uma variável declarada implicitamente em uma expressão de consulta.

As operações de associação tardia não podem ser convertida em uma árvore de expressão

Resoluções de ligação tardias; poderão ocorrer erros de tempo de execução

Resolução de sobrecarregamento ligada tardiamente não pode ser aplicada a '<nomeprocedimento>' porque a instância que acessa é um tipo interface

O primeiro '. 'ou'! ' só pode aparecer dentro uma instrução 'With'

entrelinhamento '. 'ou'! ' não pode aparecer em uma expressão de constante

'Let' e 'conjunto' não há mais suporte para instruções de atribuição

'Lib' esperado

Caractere de continuação de linha '_' deve ser precedido por pelo menos um espaço em branco e deve ser o último caractere na linha

A linha é muito longa

instruções 'linha' não são mais suportados (dispositivo/Visual Basic Compiler erro SMART)

instruções 'linha' não são mais suportados (erro de compilador do Visual Basic)

Não se pode referir à Variável local '< nomedevariável >' antes que esta seja declarada

Variável local '<variablename>' já está declarada no bloco atual

Variável local não pode ter o mesmo nome que a função que a contém

Variáveis locais dentro de métodos genéricos não podem ser declaradas 'estático'

Variáveis locais em métodos de estruturas não podem ser declaradas 'Static'

'Loop' não pode ter uma condição se 'Do' correspondente tiver uma

Variável de controle de loop não pode ser uma propriedade ou um array vinculado atrasado

'Loop' deve ser precedido por 'Do' correspondente

Instruções de loop inválido são válidas na janela Verificação imediata

Operador '<operatorsymbol1>' correspondente é necessário para '<operatorsymbol2>'

Número máximo de erros foi excedido

Número máximo de avisos foi ultrapassado.

'Me' não pode ser o destino de uma atribuição

Membro ' <classname>. <procedurename>' que corresponde a essa assinatura não é possível substituir porque a classe '<classname>' contém vários membros com o mesmo nome e assinatura: <signaturelist>

Membro ' <interfacename>. <procedurename>' que corresponde a essa assinatura não é possível implementar porque a interface '<interfacename>' contém vários membros com o mesmo nome e assinatura: <signaturelist>

Membro '<nomemembro>' não pode ser encontrado na classe '<nomeclasse>'

Membro '< NomeDoMembro >' não pode ser inicializado em uma expressão inicializador de objeto porque não é um campo ou propriedade

O Membro '< MemberName >' não pode ser inicializado em uma expressão inicializadora de objeto porque ele é compartilhado

Conflitos do membro < 'nomedomembro'> com o membro < 'nomedomembro'> no tipo base <'nomedotipobase'> não deve ser declarado com 'Overloads'

Membro '<membername>' define implicitamente um membro '<implicitmembername>' qual h sistema autônomo o mesmo nome sistema autônomo um parâmetro de tipo

Membro '< membername1 >' entra em conflito com um membro implicitamente declarado para membro '< membername2 >' no tipo base '< basetypename >' e portanto não devem ser declarados como 'Overloads'

Membro '< membername1 >' declara implicitamente '< implicitmembername >', que está em conflito com um membro implicitamente declarado para membro '< membername2 >' in a classe base '< baseclassname >'

Membro '<membername1>' declara implicitamente '<implicitmembername>', que está em conflito com um membro na classe base '<baseclassname>'

Os membros em um módulo não podem ser declarados '<especificador>'

Membros em uma estrutura não podem ser declarados como '< especificador >'

Método '<methodname>' não pode ser declarado como 'parcial' porque somente um método '<methodname>' pode ser marcado como 'parcial'

Método '<methodname>' não pode manipular o evento '<eventname>' porque eles não possuem a mesma assinautura

O método '<methodname>' não tem uma assinatura compatível com delegado <'delegatename'>

Método '<nomemétodo>' não possui a mesma assinatura que delegado '<nomedelegado>'

Método '<methodname>' possui uma demanda de link, mas substitui ou implementa os métodos a seguir, que não possuem uma demanda de link. Pode haver uma falha na segurança:

Método '<nomemétodo>' já está declarado na interface '<nomeinterface>'

O método '< methodname1 >' não é possível implementar o método parcial '< methodname2 >' porque '< methodname3 >' já o implementa.

O método '<methodname1>' não tem sistema autônomo mesmas restrições genéricas sistema autônomo o método parcial '<methodname2>'

Método '<methodname1>' deve ser declarado "Private' a fim de implementar o método parcial '<methodname2>'

Argumentos de método devem ser colocados entre parênteses

Chamada de método não retornou um valor

O método não pode conter uma instrução 'Try' e uma instrução 'On Error' ou 'Resume'

O método não pode conter uma declaração 'On Error GoTo' e uma expressão lambda ou de consulta.

Método não pode ter parâmetros ParamArray e Optional ao mesmo tempo

Declarações de declaração de método devem ser as primeiras numa linha lógica

O método não tem uma assinatura compatível com o delegado

Um método em uma estrutura não pode ser declarado como 'Protected' ou 'Protected Friend'

Métodos não podem ser declarados como estáticos

Métodos declarados em estruturas não podem ter cláusulas 'Handles'

Métodos declarados 'Overrides' não podem ser declarado como 'Overridable' porque são implicitamente substituíveis

Métodos em um módulo não podem ser declarados como '<especificador>'

Métodos em um Módulo não podem implementar membros de interface.

Métodos de 'System.Nullable (Of T)' não podem ser usados como operandos do operador 'AddressOf'

Métodos ou eventos que implementam membros de interface não podem ser declarados como 'Shared'

'Microsoft.VisualBasic.ComClassAttribute' e '<atributo>' não podem ser aplicados à mesma classe

'Microsoft.VisualBasic.ComClassAttribute' não pode ser aplicado a '<classname>' porque não está declarado como 'Public'

'Microsoft.VisualBasic.ComClassAttribute' não pode ser aplicado a '<classname1>' porque seu contêiner '<classname2>' não está declarado como 'Public'

'Microsoft.VisualBasic.ComClassAttribute' não pode ser aplicado a uma classe declarada 'MustInherit'

'Microsoft.VisualBasic.ComClassAttribute' não pode ser aplicado a uma classe é genérico ou aninhado dentro de um tipo genérico

'Microsoft.VisualBasic.ComClassAttribute' está especificado para classe '<classname>', mas ele não tem membros públicos que podem ser expostos para com.; portanto nenhuma interface COM foi gerada

'Microsoft.VisualBasic.ComClassAttribute' na classe '<classname>' declara implicitamente <type>'<membername>', que está em conflito com um membro do mesmo nome em <type>'<typename>'

Falta de Espaço em branco necessário

O módulo '<modulename>' não pode ser usado sistema autônomo um tipo

Atributo de módulo '<attributename>' inválido: <erro>

demonstrativo 'módulo' deve finalizar com 'participante módulo' correspondente

instruções 'módulo' só podem ocorrer no nível do arquivo ou namespace

Módulos não podem ser declarados como '<especificador>'

Módulos não podem ser genéricos

A matriz multidimensional não pode ser convertida em uma árvore de expressão

Várias inicializações de '< MemberName >'

'MustInherit' não pode ser especificado para o tipo parcial '<partialtypename>' porque ele não pode ser combinado com 'NotInheritable' especificado para um de seus outros tipos parciais

'MustOverride' não pode ser especificado em '<procedurename>' porque ele está em um parcial tipo é declarado 'NotInheritable' em outra definição parcial

método 'MustOverride' '<methodname>' não pode ser chamado com 'MyClass'

'MyBase' não pode ser usado com o método '<methodname>' porque está declarado como 'MustOverride'

'MyBase ' deve ser seguido por'.' e um identificador

'MyClass' não pode ser usado fora de uma classe

'MyClass ' deve ser seguido por'.' e um identificador

Nome <membername>não é compatível com CLS

O nome '<name>' não está declarado ou não no escopo corrente

Nome '<nome>' não está declarado

Nome <namespacename>no namespace raiz <fullnamespacename>não é compatível com CLS

Nome de campo ou propriedade a ser inicializados devem começar com '.'

Nome do parâmetro de tipo '<typeparametername1>' não corresponde a '<typeparametername2>', parâmetro definido na declaração de método parcial '<methodname>' de tipo correspondente

Argumento nomeado não pode corresponder a parâmetro ParamArray

Argumento nomeado esperado

Argumentos nomeados não são válidos como subscritos de matriz

Declaração namespace deve começar com 'xmlns'

A declaração do namespace com prefixo não pode ter um valor vazio em literais XML

O namespace ou tipo '<nome>' já foi importado

O namespace ou tipo especificado em Imports '<qualifiedelementname>' não contém nenhum membro público ou não foi encontrado

Tipo ou Namespace especificado em Imports '<qualifiedelementname>' a nível de projeto não contem nenhum membro público ou não podem ser achados.

demonstrativo 'Namespace' deve finalizar com 'participante Namespace' correspondente

instruções 'Namespace' só podem ocorrer no nível do arquivo ou namespace

A função aninhada não tem a mesma assinatura do delegado '< delegateName >'

Aninhamento de parênteses em lista de parâmetros de expressões lambda excede profundidade máxima permissível.

'New' não pode ser usado em uma classe declarada 'MustInherit'

não é possível usar 'New' em um parâmetro de tipo que não possui uma restrição 'New'

'New' não pode ser usado em uma interface

'New' não pode ser usado na classe '<classname>' porque ele contém um membro 'MustOverride' que não foi substituído

não é possível combinar a restrição 'New' e a restrição 'estrutura'

'New' não é possível especificar a restrição várias vezes para o mesmo parâmetro de tipo

'New' inválido neste contexto

a variável de controle 'Next' não corresponde à 'variável de controle de loop for'

A variável de controle Next não corresponde de variável de controle de loop '<variablename>'

'Next' esperado

'Next' deve ser precedido por 'For' correspondente

demonstrativo 'Next' nomeia mais variáveis do que as contidas 'nas instruções for' correspondentes

Nenhum '<genericprocedurename>' acessível aceita este número de argumentos de tipo.

Nenhum '<procedurename>' acessível é mais específico: <signaturelist>

Nenhum método 'Main' acessível com uma assinatura apropriada foi encontrado em '< nome >'

Nenhum método acessível '<procedurename>' tem uma assinatura compatível com delegado '<delegatename>': <suberrorlist>

Nenhum '<procedurename>' não genérico acessível foi encontrado

Não há fontes de entrada especificadas

<NomeDoMembro> CLS-não compatível não é permitido em uma interface CLS-compatível

O membro não compatível com CLS 'MustOverride' não é permitido numa <classname> compatível com CLS.

Nenhum dos métodos 'Main' acessíveis com as assinaturas apropriadas encontradas no '< NomeDoTipo >' pode ser o método de inicialização porque eles são genéricos ou aninhados em tipos genéricos

Nomes de tipo não intrínsecos não são permitidos em expressões compilação condicional

o atributo 'NonSerialized' não afetará esse membro porque sua classe recipiente não é exposta sistema autônomo 'Serializable'

Membros não compartilhados numa Estrutura não podem ser declarados como 'Novo'

'Nothing' não pode ser avaliada

classes 'NotInheritable' não podem ter membros declarados '<specifiername>'

'NotOverridable' não pode ser especificado em métodos que não substituem outro método

Modificador anulável '? 'e modificadores de matriz, '(' and ')', não pode ser especificado em uma variável e seu tipo

O modificador anulável não pode ser especificado em declarações de variável com 'As New'

Modificador anulável não pode ser especificado em uma variável e seu tipo

Modificador anulável não pode ser usado com uma variável cujo tipo implícito é 'Object'

Parâmetros anuláveis devem especificar um tipo.

Inferência de tipo anulável não é suportada neste contexto

Tipos anuláveis não são permitidos em expressões de compilação condicional

Tipos anuláveis não são suportados porque a versão corrente de 'mscorlib.dll' não define o tipo 'Nullable (of T)'

Número de índices excede o número de dimensões da matriz indexada

Número de índices excede o número de dimensões do array indexado

Objeto criado por Edit e Continue ainda não está disponível para avaliação.

Sintaxe do inicializador do objeto não pode ser usada para inicializar uma instância do tipo Objeto.

Objeto não existe mais devido a erro de compilar ou exclusão

'Of' necessário ao especificar argumentos de tipo para um tipo genérico ou método

Argumento omitido não pode corresponder a parâmetro ParamArray

instruções 'On erro' inválido são válido na janela Verificação imediata

'On erro' instruções inválido são válidas em declarações 'SyncLock'

instruções 'On erro' inválido são válido nas instruções 'Using'

'On' esperado

'On GoTo ' e ' On GoSub' instruções não são mais suportadas

Somente os operadores de conversão podem ser declarados '<Palavra-chave>'

Somente um 'NotOverridable', 'MustOverride' ou 'Overridable' pode ser especificado

Somente um 'Public', 'particular', 'Protected', 'Friend' ou 'Protected Friend' pode ser especificado

Somente um bloco de comentários XML é permitido por elemento de linguagem

Operandos do tipo objeto usados para o operador '<operatorsymbol>'; poderão ocorrer erros em tempo de execução

Operandos do tipo Objeto usados pelo operador '<operatorsymbol>'; use o operador 'Is' para testar a identidade do objeto

Operandos do tipo Object usados para o operador '<operatorsymbol>'; use o operador 'IsNot' para testar a identidade do objeto

Operandos do tipo objeto usado em expressões para declarações 'selecionar' de 'caso'; poderão ocorrer erros em tempo de execução

O operador '<operador>' deve ter um tipo de retorno booleano

O operador '<operator>' deve ter um segundo parâmetro do tipo 'Integer'

O operador '< operador >' deve ter um ou dois parâmetros

O operador '< operador >' deve ter um parâmetro

O operador '< operator >' deve ter dois parâmetros

Operador '< NomeDoOperador >' não está definido para o tipo '< NomeDoTipo >'

O operador '<operatorname>' não está definido para tipos '<type1>' e '<type2>'

O operador '<operatorname>' não está definido para tipos '<typename1>' e '<typename2>'

O operador '<símbolodooperador>' não retorna um valor em todos os caminhos de código

Declaração do operador deve ser um destes: +,-, *, \, /, ^, &, Como MOD, and, or, Xor, Not, <<, >>, = <>, <, < =, >, > =, CType, IsTrue, IsFalse

Operador não é sobrecarregável

Operador 'operador' não está definido para tipos de 'tipo' e 'type2'

Operador sem uma cláusula 'As' ; tipo de objeto assumido

Os operadores não podem ser declarados '<palavra-chave>'

Operadores não podem ser declarados em Módulos

Os operadores devem ser declarados 'Public'

Operadores devem ser declarados 'Shared'

Opção /win32manifest ignorada

Opção '< opção >' não pode ser seguida de '+' ou '-'; ignorado

A opção < Optionname > pode ser seguida somente por '+' ou '-'

Opção < Optionname > requer < argumento >

demonstrativo 'Option <especificador>' só pode aparecer uma vez por arquivo

'Option comparar' deve ser seguido por 'Texto' ou 'binário'

'Option Explicit 'pode ser seguido somente por' on 'ou' off'

'Option Infer 'pode ser seguido somente por' on 'ou' off'

'Option' deve ser seguido por 'comparar', 'Explicit', 'Infer' ou 'Strict'

instruções 'Option' devem preceder quaisquer declarações ou instruções 'Imports'

'Option Strict 'pode ser seguido somente por' on 'ou' off'

Option Strict Custom só pode ser usada sistema autônomo uma opção para o compilador de linha de comando (vbc.exe)

Option Strict On não permite conversões implícitas de '<type1>' em '<type2>'

Option Strict On não permite conversões implícitas de '< type1 >' para '< type2 >'; o tipo de coleção Visual Basic 6.0 é incompatível com o tipo de coleção do .NET Framework

A opção Strict On desabilita vinculação posterior

Option Strict On não permite restringir do tipo '< typename1 >' ao tipo '< typename2 >' na cópia do valor do parâmetro < ParameterName > ByRef ' de volta para o argumento correspondente

Option Strict On não permite operandos do tipo objeto para o operador '<operatorname>'

Option Strict On não permite restringir a conversões de tipo implícitas entre método de extensão '< extensionmethodname >' definido no '< nomedomódulo >' e representante '< delegateName >'

Option Strict On não permite limitação nas conversões de tipo implícito entre o método '<methodname>' e '<delegatename>' delegado

Option Strict On não permite restringir em conversões implícitas de tipo entre a expressão lambda e delegar '< delegateName >'

Option Strict On proíbe operandos do tipo objeto para o operador '<operatorname>'

Opção Strict ligada requer que todas as Funções, Propriedades e Declarações de Operador tenham uma cláusula 'As'

Opção Strict On exige todas as declarações de variável para ter uma cláusula ' As ' .

Opção Strict On requer que cada parâmetro de expressão lambda seja declarado com uma cláusula 'As' se seu tipo não pode ser inferido.

Option Strict ativada requer que todos os parâmetros de método tenham uma cláusula 'As'

não é possível combinar 'Optional' e 'ParamArray'

'Optional' não pode ser aplicado ao primeiro parâmetro de um método de extensão

'Optional' esperado

Parâmetros opcionais não podem ser declarados como o tipo '<type>'

Parâmetros opcionais não podem ter tipos de estrutura

Parâmetros opcionais devem especificar um valor padrão

Sem memória disponível (Erro do Compilador do Visual Basic)

Estouro de capacidade (erro do Visual Basic)

Falha na resolução de sobrecarga porque nenhum <método>está acessível

Falha na resolução de sobrecarga porque nenhum '<genericprocedurename>' acessível aceita este número de argumentos de tipo

Falha na resolução de sobrecarga porque nenhum '<método>' acessível aceita este número de argumentos

Resolução de sobrecarga falhou porque nenhum '<método>' acessível pode ser chamado com estes argumentos:<erro>

Falha na resolução de sobrecarga porque nenhum '<método>' acessível pode ser chamado sem uma conversão de restrição: <erro>

Falha na resolução de sobrecarga porque nenhum '<método>' acessível é mais específico para estes argumentos: <erro>

Métodos de sobrecarga declarados em várias interfaces base não é válido

'ParamArray' não pode ser aplicado ao primeiro parâmetro de um método de extensão

Parâmetro ParamArray deve ser uma matriz unidimensional

Parâmetro ParamArray deve ser uma matriz

Parâmetros ParamArray devem ser declarados como 'ByVal'

Parâmetros ParamArray devem ter um tipo de matriz

Parâmetro '<parametername>' já tem um argumento correspondente

Parâmetro '<parametername>' já tem um argumento omitido correspondente

Parâmetro '<parametername>' no '<methodname>' já tem um argumento omitido correspondente

Parâmetro '<nomedoparâmetro>' em método de extensão '<nomedométodo>' definido em '<nomedotipo>' já tem um argumento correspondente

O parâmetro '<nomedoparâmetro>' no método de extensão '<nomedométodo>' definido em '<nomedotipo>' já tem um argumento omitido correspondente

O parâmetro '<parametername>' do método '<methodname>' já tem um argumento correspondente

Parâmetro já declarado com nome '< argumentname >'

O parâmetro não pode ter o mesmo nome da função que o define

Nome do parâmetro '< parametername1 >' não coincide com o nome do correspondente parâmetro, '< parametername2 >', definido em declaração de método o parcial '< methodname >'

O especificador de parâmetro está duplicado

Tipo de parâmetro desse operador unário deve ser do tipo '<typename>' do contenedor.

Os tipos de parâmetro de '<operador>' devem ser '<typename>' para serem usados em uma demonstrativo 'For'

O método parcial '< methodname >' não pode usar a palavra-chave 'Implements'

Métodos parciais devem ser declarados como 'Private'

Métodos parcial devem ser declarados como 'particular ', em vez de' <accessmodifier>'

Métodos parciais devem ter corpos de métodos vazios

Possível problema detectado ao compilar o assembly '<assemblyname>': <erro>

Possível problema detectado ao compilar o assembly: <erro>

'prefixo' é um prefixo XML e não pode ser usado sistema autônomo uma expressão

O Projeto '< projectname >' não pode gerar uma referência ao arquivo '<filename>'

Projeto '<NomeDoProjeto>' não pode fazer referência ao '<NomeDoProjeto>' porque '<NomeDoProjeto>' direta ou indiretamente referencia '<NomeDoProjeto>'

Projeto '<projectname>' faz uma referência indireta ao assembly '<assemblyname>' que contém '<classname>'

O projeto '<projectname>' requer uma referência à versão '<versionnumber1>' do assembly '<assemblyname>', mas referencia a versão '<versionnumber2>' do assembly '<assemblyname>' (erro do Visual Basic)

Projeto '< NomeDoProjeto >' requer uma referência à versão '< versionnumber1 >' do conjunto de módulos (assembly) '< AssemblyName >', mas faz referência a versão '< versionnumber2 >' do conjunto de módulos (assembly) '< AssemblyName >' (aviso Visual Basic)

O projeto '<projectname1>' faz uma referência indireta ao projeto '<projectname2>', que contém '<typename>'

Projeto já tem uma referência para o conjunto de módulos (assembly) <assemblyIdentity>

Projeto foi fechado

Constante de compilação condicional no nível do projeto '<constantname>' inválido: <erro>

Constante de compilação condicional no nível do projeto inválido: <erro>

Propriedades não podem ser declaradas '<modifiername>'

Propriedades declaradas como 'ReadOnly' não podem ter 'Set'

Propriedades declaradas como 'WriteOnly' não podem ter 'Get'

Propriedades em um módulo não podem ser declarados como '<specifier>'

Propriedades sem nenhum parâmetro necessário não podem ser declaradas como 'Default'

A propriedade '<propertyname>' não pode ser declarada 'Default' porque substitui uma propriedade na base <type>'<typename>' que não seja padrão

Propriedade '<propertyname>' não pode ser inicializada em uma expressão de inicializador de objeto porque todas as sobrecargas acessíveis requerem argumentos

A propriedade '<propertyname>' não pode ser inicializada em uma expressão inicializadora de objeto porque ela requer argumentos

A propriedade '<NomeDaPropriedade>' não retorna um valor em todos os caminhos de código

Propriedade '<propertyname>' declara implicitamente '<implicitmembername>', que está em conflito com um membro implicitamente declarado para o membro '<membername>' na classe base '<baseclassname>'

A propriedade '<nomedapropriedade>' é de um tipo sem-suporte

Propriedade '<propertyname>' é 'ReadOnly'

Propriedade '<nomepropriedade>' é 'WriteOnly'

A propriedade '<nome de propriedade>' precisa ser declarada 'Padrão' porque isso desautoriza uma propriedade padrão na base '<nome>'

Propriedade '< PropertyName >' sem nenhum parâmetro não pode ser encontrada

Acesso à propriedade deve atribuir à propriedade ou usar seu valor

Os assessores da propriedade não podem ser declarados '< accessmodifier >' em uma propriedade 'Default'

Os assessores da propriedade não podem ser declarados '< accessmodifier >' em uma propriedade 'NotOverridable'

Os acessadores da propriedade não podem ser declarados como '<palavra-chave>'

Propriedade não pode ser declarada como '< propertymodifier >' porque ela contém um assessor 'Private'

Propriedade Get/Let/conjunto são não há mais suporte para; use a nova sintaxe de declaração de propriedade

Propriedade sem 'End Property'

Propriedade ou campo '<name>' não tem um tipo de atributo válido

Parâmetros de propriedade não podem ter o nome 'valor'

Propriedade sem um especificador 'ReadOnly' ou 'WriteOnly' deve fornecer 'Get' e 'conjunto'

Propriedade sem uma cláusula 'As' ; tipo de objeto assumido

Tipos protegidos só podem ser declarados dentro de uma classe

Expressões de consulta não são válidas em janelas de depuração

declaração 'RaiseEvent' deve finalizar com 'participante RaiseEvent' correspondente

definição de 'RaiseEvent' faltando para o evento '<eventname>'

'RaiseEvent' já está declarado.

o método 'RaiseEvent' deve ter a mesma assinatura que tipo de delegado do evento recipiente '<signature>'

instruções 'RaiseEvent' inválido são válidas na janela Verificação imediata

O intervalo especificado para a instrução 'Case' não é válido

Variável de alcance <variável> oculta uma variável em um bloco envolvente ou uma variável de alcance definida na expressão de consulta.

A variável de intervalo <variable> oculta uma variável num bloco delimitado, variável de intervalo definida previamente, ou variável declarada implicitamente numa expressão de consulta.

Já foi declarado <variable>variável de intervalo

O nome da variável de intervalo pode ser deduzido apenas a partir de um nome simples ou qualificado sem argumentos

Nome de variável intervalo não pode coincidir com o nome de um membro da classe 'Object'

não é possível combinar 'ReadOnly' e 'WriteOnly'

a propriedade de atributo 'ReadOnly' '<propertyfield>' não pode ser o destino de uma atribuição

Propriedades 'ReadOnly' não podem ter um modificador de acesso em 'Get'

'<propertyname>' propriedade' ReadOnly' não pode ser o destino de uma atribuição

a propriedade 'ReadOnly' deve fornecer 'Get'

a variável 'ReadOnly' não pode ser o destino de uma atribuição

a variável 'ReadOnly' não pode ser o destino de uma atribuição em uma expressão lambda dentro de um construtor

'ReDim' não é possível alterar o número de dimensões de uma matriz

instruções 'ReDim' não podem ser usadas para declarar variáveis de matriz

instruções 'ReDim' exigem uma lista de parênteses dos novos limites de cada dimensão da matriz

Referência necessária para o assembly '< IdentidadeDoAssembly >' contendo o tipo '< NomeDoTipo >', mas uma referência adequada não foi pôde ser encontrada devido à ambiguidade entre os projetos '<projectname1>' e '<projectname2>'

Referência necessária ao assembly '<assemblyidentity>' contendo o tipo '<typename>', mas uma referência adequada não foi encontrado devido a possíveis referências circulares: <referencedependencylist>

Referência necessária para o conjunto de módulos (assembly) '< AssemblyName >' contendo a classe base '< ClassName >'

Referência exigida para o assembly '<nomeassembly>' contendo a definição para evento '<nomeevento>'

Referência necessária para o assembly '<assemblyname>' que contém a interface implementada '<interfacename>'

Referência necessária para o assembly '<assemblyname>' que contém o tipo '<membername>'

Referência necessária ao módulo '<modulename>' que contém a classe base '<classname>'

Referência necessária para o módulo '< nomedomódulo >' que contém a definição para evento '< EventName >'

Referência necessária para o módulo '< nomedomódulo >' que contém a interface implementada '< InterfaceName >'

Referência necessária ao módulo '<modulename>' que contém o tipo '<membername>'

Referência a um membro não compartilhado requer uma referência de objeto

Referência a um objeto em construção não é válida ao chamar outro construtor

< MemberName >' referenciado tem um valor de 'Nothing'

Elemento da matriz referenciado tem um valor de 'Nothing'

Objeto referenciado '< ObjectName >' tem um valor de 'Nothing'

Objeto referenciado tem um valor de 'Nothing'

Operador relacional esperado

declaração 'RemoveHandler' deve finalizar com 'participante RemoveHandler' correspondente

definição de 'RemoveHandler' ausente para o evento '<eventname>'

'RemoveHandler' já está declarado.

Atributo necessário 'versão' faltando na declaração XML

Nome do recurso '<nomedorecurso >' não pode ser usado mais de uma vez

Arquivo de resposta <Arquivo> incluído várias vezes

'Resume' ou 'GoTo' esperado

instruções 'Resume' inválido são válidas na janela Verificação imediata

Os tipos de parâmetro e de retorno de '< logicaloperator >' devem ser '< NomeDoTipo >' para serem usados em uma expressão '< shortcircuitoperator >'

Os tipos de parâmetro e de retorno de '< operador >' devem ser '< NomeDoTipo >' para serem usados em uma instrução 'For'

demonstrativo 'Return' em função, Get ou operador deve retornar um valor

demonstrativo 'Return' em sub ou conjunto não pode retornar um valor

' retornar 'demonstrativo ' AddHandler', 'RemoveHandler' ou o método 'RaiseEvent' não pode retornar um valor

instruções 'Return' inválido são válidas na janela Verificação imediata

Tipo de retorno da função '< NomeDoProcedimento >' é não compatível com CLS

O namespace raiz <namespacename>não é compatível com CLS

Exceção lançada em tempo de execução

Exceção em time de execução acionada: <exceção>- <exceção>

Atributo de segurança '<attributename>' não pode ser aplicado a um módulo

Atributo de segurança '<attributename>' inválido: <erro>

'selecionar caso' deve finalizar com 'participante selecionar' correspondente

instruções 'selecionar' inválido são válidas na janela Verificação imediata

acessador 'conjunto' da propriedade '<propertyname>' não está acessível

'conjunto' já está declarado

método 'conjunto' não pode ter mais de um parâmetro

parâmetro 'conjunto' não pode ser declarado como '<especificador>'

o parâmetro 'conjunto' deve ter o mesmo tipo da propriedade recipiente

demonstrativo 'conjunto' deve finalizar com 'participante conjunto' correspondente

o atributo 'Compartilhado' propriedade '<propertyfield>' não pode ser o destino de uma atribuição

'Shared' não pode ser combinado com '<especificador>' em declaração de método

'Shared' não pode ser combinado com '<especificador>' em declaração de propriedade

Sub New' compartilhado não pode ser declarado como '<Especificador>'

Sub New' compartilhada não pode ter nenhum parâmetro.

Efeitos colaterais inválidos durante a avaliação da expressão neste contexto

Arquivo de origem <nomedoarquivo> especificado várias vezes

Acesso ' <accesslevel1> especificado para '<partialtypename>' não corresponde ao acesso '<accesslevel2>' especificado em um de seus outros tipos parciais

O especificador está duplicado

Especificadores e atributos não são válidos em declarações 'Namespace'

Especificadores e atributos não são válidos nessa instrução

Especificadores não são válidos nos métodos 'AddHandler', 'RemoveHandler' e 'RaiseEvent'.

Especificadores válidos somente no início de uma declaração

demonstrativo não pode aparecer fora do corpo de um método de

A declaração não pode aparecer no interior de um corpo de método

Instrução não pode aparecer dentro um corpo de propriedade

A declaração não pode aparecer num corpo de enumeração.

demonstrativo não pode aparecer dentro do corpo de evento

A declaração não pode aparecer num corpo de interface

demonstrativo não pode aparecer dentro do corpo de uma interface (erro do Visual Basic)

Instrução não pode finalizar um bloco fora de uma instrução 'If' de linha

Instrução não declara um método 'Get' ou 'Set'

demonstrativo não declara ' AddHandler ', 'RemoveHandler' ou 'RaiseEvent' método

Instrução não é válida em um namespace

Instrução não é válida em uma interface

Declaração não é válida dentro de um método

Chama o recipiente 'AddHandler' para evento '< EventName >' Instrução recursivamente

Instruções e rótulos não são válidos entre ' Select Case ' e primeiro 'Case'

Variável local estática '<variablename>' já está declarada

Solicitação de interrupção está pendente

instruções 'Stop' inválido são válido na janela Verificação imediata

Sequência de caracteres constante esperada

Constantes de seqüência de caracteres devem finalizar com aspas duplas

Estrutura '<structurename>' não pode ser indexada porque não tem nenhuma propriedade padrão

Estrutura '<structurename>' não pode conter uma instância de si mesma: <erro>

Estrutura '<nomeestrutura>' deve conter pelos menos uma variável membro de instância ou pelo menos uma declaração de evento de instância não marcada como 'Personalizada'

A estrutura '<structurename>' deve conter pelo menos uma instância de membro de variável ou declaração de evento

restrição 'estrutura' e uma restrição de tipo de classe específica não podem ser combinados

restrição 'estrutura' não é possível especificar várias vezes para o mesmo parâmetro de tipo

A estrutura numa interface não pode ser declarada '<especificador>'

demonstrativo 'estrutura' deve finalizar com 'participante estrutura' correspondente

Estruturas não podem declarar 'Sub New' não compartilhado sem parâmetros

Estruturas não podem ter instruções 'Inherits'

'Sub Main' está declarado mais de uma vez em '<namespace>': <mensagem>

'Sub Main' não foi encontrado '<nome>'

'Sub New' não pode ser declarado '<modifier>'

'Sub New' não pode ser declarado em uma interface

'Sub New' não podem ser declarados 'Overrides'

'Sub New' não pode tratar eventos

'Sub New' não pode implementar membros de interface

'Sub' ou 'função' esperado

'Sub' ou 'função' esperado após 'delegado'

Solicitação de suspensão está pendente

o operando 'SyncLock' não pode ser do tipo '<typename>' porque '<typename>' não é um tipo de referência

demonstrativo 'SyncLock' deve finalizar com 'participante SyncLock' correspondente

instruções 'SyncLock' inválido são válidas na janela Verificação imediata

Erro de sintaxe (Erro Visual Basic)

Erro de sintaxe no operador cast; são necessários dois argumentos separados por vírgulas

Erro de sintaxe em expressão de compilação condicional

System.CLSCompliantAttribute não pode ser aplicado à propriedade 'Get'/'Set'

System.Diagnostics.DebuggerHiddenAttribute não afeta 'Get' ou 'Set' quando aplicado à definição da propriedade

'sistema.Nullable' não satisfaz a restrição 'estrutura' para o parâmetro de tipo '<typeparametername>'

'sistema.ObsoleteAttribute' não pode ser aplicado a definições 'AddHandler', 'RemoveHandler' ou 'RaiseEvent'

valor 'sistema.tempo de execução.InteropServices.DispIdAttribute' não pode ser aplicado a '<typename>' porque 'Microsoft.VisualBasic.ComClassAttribute' reserva valores menores que zero

valor 'sistema.tempo de execução.InteropServices.DispIdAttribute' não pode ser aplicado a '<typename>' porque 'Microsoft.VisualBasic.ComClassAttribute' reserva zero para a propriedade padrão

'sistema.tempo de execução.InteropServices.DllImportAttribute' não pode ser aplicado a 'Declare'

'sistema.tempo de execução.InteropServices.DllImportAttribute' não pode ser aplicado a 'Get' ou 'conjunto'

'sistema.tempo de execução.InteropServices.DllImportAttribute' não pode ser aplicado a um método é genérica ou aninhados em um tipo genérico

'sistema.tempo de execução.InteropServices.DllImportAttribute' não pode ser aplicado a um sub, função ou operador com um corpo não vazio

'sistema.tempo de execução.InteropServices.DllImportAttribute' não pode ser aplicado a métodos 'AddHandler', 'RemoveHandler' ou 'RaiseEvent'

'sistema.tempo de execução.InteropServices.DllImportAttribute' não pode ser aplicado a métodos de instância

'sistema.tempo de execução.InteropServices.DllImportAttribute' não pode ser aplicado a métodos de interface

'sistema.STAThreadAttribute' e 'sistema.MTAThreadAttribute' não podem ser aplicados a '|1'

'sistema.STAThreadAttribute' e 'sistema.MTAThreadAttribute' não podem ser aplicados ao mesmo método

'sistema.Void' só pode ser usado em uma expressão GetType

A opção/nomedoassemblydenome deve ser especificada somente quando contruindo um destino do tipo 'módulo'

O caractere '?' não pode ser usado aqui

A palavra-chave '< Palavra-chave >' é usada para sobrecarregar membros herdados; não use a palavra-chave '< Palavra-chave >' quando sobrecarregando ' Sub New '

O ConnectionTimeout deve ser maior que 0

A versão personalizada de 'sistema.tempo de execução.CompilerServices.ExtensionAttribute' encontrados pelo compilador inválido é válida

A referência do assembly padrão '<referência>' já foi automaticamente adicionada; ignorada

O arquivo '<nomearquivo>' não é um arquivo de texto

O número máximo de erros foi excedido

A versão de destino do .NET Compact estrutura não dá suporte à ligação atrasada

A versão de destino do .NET Compact Framework não oferece suporte a resolução de sobrecarga lateBound

A versão de destino do .NET Compact estrutura não dá suporte a demonstrativo 'participante'

O versão de destino do Framework .NET Compacto não oferece suporte ao usar o modificador Ansi, Auto ou Unicode

O tipo '< NomeDoTipo >' não pode ser um tipo, tipo de retorno, tipo de campo, tipo de argumento genérico, tipo de parâmetro 'ByRef' ou o tipo de uma expressão convertido em 'Objeto' ou 'ValueType' de um elemento array.

O tipo de variável '<variablename>' não será inferido porque está limite a um campo em um escopo de fechamento

o valor '<value>' é inválido para a opçãp '<optionname>'

Esta herança causa dependências circulares entre <tipo1> '<nomedotipo1>' e seu <tipo2>'<nomedotipo2>' aninhado.

o operando 'Throw' deve ser derivado de 'sistema.exceção'

demonstrativo 'Throw' não pode omitir o operando fora de uma demonstrativo 'Catch' ou dentro de uma demonstrativo 'Finally'

instruções 'Throw' inválido são válidas na janela Verificação imediata

Muito poucos argumentos de tipo

Poucos argumentos de tipo para '<genericmethodname>'

Muito poucos argumentos de tipo para método de extensão '< methodname >' definidos no '< NomeDoTipo >'

Excesso de argumentos

Excesso de argumentos para '<nomedoprocedimento>'

Muitos argumentos para o método de extensão '<methodname>' definidos em '<typename>'

Muitos argumentos de tipo

Muitos argumentos de tipo para '<genericmethodname>'

Muitos argumentos de tipo para o método de extensão '<methodname>' definidos em '<typename>'

'Try' deve finalizar com 'participante Try' correspondente

Try deve ter pelo menos 'Catch' ou 'Finally'

instruções 'Try' inválido são válidas na janela Verificação imediata

o operando 'TryCast' deve ser do tipo de referência, mas '<typename>' é um tipo de valor

Os operandos 'TryCast' devem ser parâmetros de tipo com restrição de classe, mas '<typeparametername>' não tem nenhuma restrição de classe

Tipo '<typename>' e o tipo parcial '<typename>' estão em conflito no contêiner '<containername>', mas estão sendo mesclados porque um deles é declarado parcial

Tipo '< NomeDoTipo >' e tipo parcial '< NomeDoTipo >' declarados em '< NomeDoArquivo >' estão em conflito no continente '< NomeDoContinente >', mas estão sendo mesclados porque um deles é declarado parcial

Tipo '<typename>' não pode ser usado sistema autônomo um atributo porque não está declarado sistema autônomo 'Public'

Tipo '<nomedotipo>' não pode ser usado como um atributo porque seu recipiente '<nomedorecipiente>' não está declarado como 'Public'

O tipo '<typename>' não pode implementar a interface '<interfacename>' porque ele declara '<eventsignature>', que tem um tipo de retorno.

Tipo '<typename>' não pode herdar de um tipo aninhado dentro dele

Tipo '< NomeDoTipo >' não pode herdar de uma parâmetro de tipo

Tipo '<typename>' não tem nenhum construtor

Tipo '<typename>' não tem tipo de parâmetros e, portanto, não podem ter argumentos de tipo

O tipo '< NomeDoTipo >' no conjunto de módulos (assembly) '< NomeDoAssembly1 >' foi encaminhado para o conjunto de módulos (assembly) '< NomeDoAssembly2 >'

Tipo '<nomedotipo>' é importado de diferentes versões do assembly '<nomedoassembly>'

Tipo < NomeDoTipo > é não compatível com CLS

Tipo '<typename>' não está definido

O tipo '<typename>' não está definido ou o módulo que o contém não está carregado na sessão de depuração

'<typename>' Não há suporte para tipo porque ele herda direta ou indiretamente de si mesmo

Tipo '<typename>' deve ser um tipo de valor ou um argumento de tipo restrito a 'estrutura ' para ser usado com o modificador 'Nullable' ou anulável'?'

O tipo <typename>' deve definir o operador '< determinantoperator >' para ser usado em uma expressão '< shortcircuitoperator >'

O tipo '<typename>' deve definir o operador <operator>a ser usado em uma demonstrativo 'For'

Tipo '<typename1>' não pode ser marcado com CLS porque seu tipo recipiente '<typename2>' não é compatível com CLS

Argumento de tipo '<typeargumentname>' não herda de ou implementa o tipo de restrição '<typeparametername>'

Argumento de tipo '<nomedoargumentdetip >' não satisfaz a restrição 'Class' para o parâmetro de tipo '<nomedoparâmetrodetipo>'

Argumento de tipo '< NomeDeTipoDeArgumento >' não satisfaz a restrição 'Structure' para parâmetro de tipo '< NomeDeTipoDeParâmetro >'

O argumento de tipo '< typeargumentname >' é declarado 'MustInherit' e não satisfaz a restrição 'New' para parâmetro do tipo '< typeparametername >'

Argumento de tipo '< typeargumentname >' deve ter uma instância de construtor público sem-parâmetros para satisfazer a restrição 'New' para parâmetro do tipo '< typeparametername >'

Inferência de argumento de tipo falhou para o parâmetro de tipo '<typeparametername>' do '<genericproceduresignature>'

Digite a inferência de argumento fracassada para o parâmetro de tipo '<typeparametername>' do '<genericproceduresignature>'

Argumentos de tipo não podem ser aplicados a expressão '<expression>'

Argumentos de tipo não puderam ser inferidos do delegado

Argumentos de tipo para o método de extensão '<methodname>' definido em '<typename>' não podem ser deduzidos a partir do delegado '<delagatename>'

Argumento de tipo para o método '<procedurename>' não puderam ser referidos pelo delegado '<delegatename>'

Argumentos de tipo inferidos para método '<nomeprocedimento>' resulta dos seguintes erros:<listaerros>

Argumentos de tipo inferidos para o método '<procedurename>' resultam nos seguintes avisos: <warninglist>

Argumentos de tipo inesperados

Digite os argumentos inesperados porque atributos não podem ser genéricos

Caractere de tipo '<character>' não pode ser usado em uma declaração com um tipo explícito

Caractere de tipo '<charactername>' não corresponde ao tipo de dados declarado '<tipo>'

Caractere de tipo não pode ser usado em uma declaração 'Sub' porque 'Sub' não retorna um valor

Caractere de tipo não pode ser usado em uma declaração de parâmetro de tipo

Caracteres de tipo não são permitidos nos identificadores de rótulo

Caracteres de tipo não são permitidos em aliases de importação

Caracteres de tipo não podem ser usados em declarações de tipo anônimas.

Caracteres de tipo não podem ser usados em declarações da variável de intervalo

Tipo de restrição '< expressão >' não é uma classe ou interface

Restrição de tipo não pode ser uma classe 'NotInheritable'

Caracteres de declaração de tipo inválido são válido neste contexto

Tipo esperado

Tipo em um módulo não pode ser declarados como '<especificador>'

Tipo de '<nomedavariável>' não pode ser inferido porque o loop corre e a variável de etapa não se amplia ao mesmo tipo

Tipo de '< NomeDeVariável >' não pode ser inferido de uma expressão que contém '< NomeDeVariável >'

O tipo de '<nome de variável>' é ambíguo porque os limites do loop e a variável STEP não se estende ao mesmo tipo

Tipo de membro '<membername>' não é compatível com CLS

Tipo de valor opcional para parâmetro opcional <nomedoparâmetro> não é compatível com CLS

Tipo de parâmetro '<parametername>' não é compatível com CLS

Tipo ou 'New' esperado

Tipo ou 'With' esperado

Parâmetro de tipo '<typeparametername>' só pode ter uma restrição que seja uma classe

O parâmetro de tipo '<typeparametername>' não pode ser restrito a mesmo: '<errormessage>'

Parâmetro de tipo '<NomeDeParâmetroDeTipo>' não pode ser inferido

O parâmetro de tipo '<typeparametername>' para '<genericprocedurename>' não pode ser deduzido

Parâmetro de tipo '< typeparametername >' para método de extensão '< methodname >' definido no '<typename>' não pode ser inferido

O parâmetro de tipo '<typeparametername>' tem o mesmo nome que o parâmetro de tipo de um tipo de delimitador

Parâmetro de tipo '<typeparametername1>' deve ter uma restrição 'New' ou uma restrição 'Structure' para satisfazer a restrição 'New' para parâmetro do tipo '< typeparametername2 >'

O parâmetro de tipo já declarado com nome '<typeparametername>'

Um parâmetro de tipo não pode ter o mesmo nome da função que o define.

Nome do parâmetro de tipo '< NomeDoParametroDeTipo1 >' não coincide com o nome '< NomeDoParametroDeTipo2 >' do parâmetro de tipo correspondente definido em um dos outros tipos parciais de '< NomeDeTipoParcial >'

Parâmetro de tipo não permitido em cláusula 'Implements'

Parâmetro de tipo com uma restrição "Estrutura" não pode ser usada como uma restrição.

Parâmetros de tipo não podem ser especificados nesta declaração

Parâmetros de tipo não podem ser usados sistema autônomo qualificadores

Parâmetros de tipo ou tipos construídos com parâmetros de tipo não são permitidos em argumentos de atributo

instruções 'Type' não são mais suportadas; use instruções 'estrutura'

'TypeOf... Is' exige que seu operando esquerdo tenha um tipo de referência, mas esse operando tem o tipo '<type>'

Tipos não estão disponíveis neste contexto

Tipos declarados 'Private' deve estar em outro tipo

Não é possível acessar o membro

Não é possível aplicar a segurança atributo(s) para '<nome>': <erro>

Não é possível criar uma interface .NET tempo de execução: <erro>

Não é possível criar objeto vinculador do assembly: mensagem de erro >

Não é possível criar assembly de nome forte a partir do arquivo de chave '<filename>': <erro>

Não é possível criar arquivo temporário no caminho '<filename>': mensagem de erro >

Não é possível criar arquivo de documentação XML '<nome>': <mensagem>

Não é possível incorporar o arquivo de recurso '<filename>': mensagem de erro >

Não é possível emitir assembly: mensagem de erro >

Não é possível avaliar a expressão

Não é possível encontrar o ponto de entrada '<nome>' na DLL '<filename>': <erro>

Incapaz de encontrar arquivo '<nomearquivo>' necessário

Não é possível gerar uma referência ao arquivo '<filename>' (use o utilitário TLBIMP para referenciar COM DLLs): mensagem de erro >

Não é possível obter informações sobre tipo '< NomeDoTipo >'

Não é possível incluir fragmento de XML '<elementpath>' do arquivo '<commentfile>'

Não é possível vincular ao arquivo de recurso '<filename>': mensagem de erro >

Não é possível carregar a DLL '<filename>': <erro>

Não é possível carregar informações para a classe '<classname>'

Não é possível carregar biblioteca referenciada '<filename>': <erro>

Não é possível em em aberto o arquivo '<filename>': <erro>

Não é possível em em aberto o arquivo de chave '<filename>': <erro>

Não é possível em em aberto o arquivo de módulo '<filename>': <erro>

Não é possível em em aberto o arquivo de recurso '<filename>': <erro>

Não é possível abrir arquivo de resposta '< NomeDoArquivo >'

Não é possível analisar XML: <erro>

Não é possível assinar assembly: mensagem de erro >

Não é possível assinar arquivo '<filename>': <erro>

Não foi possível gravar a saída para memória

Não foi possível escrever um arquivo temporário porque o caminho temporário não está disponível

Não é possível gravar no arquivo '<filename>' de saída: <erro>

Tipo sujacente < NomeDoTipo > de Enum não é compatível com CLS

Opção não reconhecida < Optionname >; ignorado

Fibra Não Agendada

Constante local não utilizada: '<constante>'

Variável local não utilizada: '<localvariablename>'

Usar opção de linha de comando '<opção>' ou configurações de projeto apropriadas em vez de '<parâmetro>'

'Using' deve finalizar com 'participante Using' correspondente

operando do tipo '<typename>' ' using' deve implementar sistema.IDisposable

variável de recurso ' using' deve ter uma inicialização explícita

o tipo de variável de recurso 'Using' não pode ser do tipo de matriz

instruções 'Using' inválido são válidas na janela Verificação imediata

Uso da variável de iteração em uma expressão lambda pode ter resultados inesperados

Valor '<valuename1>' não pode ser convertido em '<valuename2>'

Valor do tipo '<type1>' não pode ser convertido em '<type2>'

O valor do tipo '<type1>' não pode ser convertido em '<type2>' porque '<type3>' não é um tipo de referência

Valor do tipo '< type1 >' não pode ser convertido em '< type2 >' porque '< type3 >' não é derivado de '< type4 >'

Valores do tipo '<tipo1>' não podem ser convertidos para '<tipo2>' porque os tipos de matrizes têm diferentes dimensões numéricas.

Valor do tipo '<typename1>' não pode ser convertido para '<typename2>'.

Valor do tipo '<typename1>' não pode ser convertido para '<typename2>' (Referências a arquivo múltiplo)

Valor do tipo 'tipo1' não pode ser convertido para 'tipo2'

A variável '<variablename>' oculta uma variável em bloco delimitador

Variável '<variablename>' é passada por referência antes que tenha sido atribuído um valor.

Variável '<variablename>' é passada por referência antes que tenha sido atribuído um valor (Variável de Estrutura)

Variável '< variablename >' é usada antes dela receber um valor

Variável '<nomevariável>' é usada antes de um valor ter sido designado a ela (Erro Visual Basic)

Variável não pode ser inicializada com '<elementname>' do tipo não matriz

Afirmações de declaração de variáveis não são válidas na janela Imediato

Declaração de variável sem uma cláusula 'As' cláusula; tipo de Object assumido

Variável usa um tipo de automação não tem suportado no Visual Basic

Variáveis em módulos não podem ser declaradas como '<specifier>'

'Variant' não é mais um tipo com suporte; use 'objeto'

Compilador do Visual Basic não consegue recuperar do seguinte erro: <erro>

Mensagens do compilador do Visual Basic

Número de aviso '<número>' para a opção '<optionname>' é não configurável ou não é válida

Aviso tratado sistema autônomo erro: <erro>

Métodos da Web não podem ser avaliados em janelas de depuração

o atributo 'WebMethod' não afetará esse membro porque sua classe recipiente não é exposta sistema autônomo serviço Web

instruções 'Wend' são não há mais suporte para; use instruções 'participante While'

'While' deve finalizar com 'participante While' correspondente

Espaço em branco podem não aparecer aqui

não é possível combinar 'Widening ' e ' estreitando'

'instruções e contextos with' inválido são válidas na janelas de depurar

'With' deve terminar com um correspondente 'participante With'

a variável 'WithEvents' não eleva nenhum evento

variável 'WithEvents' não eleva nenhum evento instância acessível para '<containername>'

Tamanho de nome de variável WithEvents não pode exceder 1019 caracteres

variáveis 'WithEvents' só podem ser digitadas sistema autônomo classes, interfaces ou parâmetros de tipo com restrições de classe

variáveis 'WithEvents' não podem ser digitadas sistema autônomo matrizes

variáveis 'WithEvents' devem ter ' sistema autônomo' cláusula

Propriedades 'WriteOnly' não podem ter um modificador de acesso em 'conjunto'

propriedade 'WriteOnly' deve fornecer 'conjunto'

Número errado de argumentos de tipo passado para o método '< genericprocedurename >'

O atributo XML 'attribute1' deve aparecer antes do atributo XML 'attribute2'

Atributo XML 'version' precisa ser o primeiro atributo na declaração XML

Elementos XML não podem ser selecionados do tipo 'tipo'

Propriedades do eixo XML não têm suporte para vinculação atrasada

Não é possível associar qualquer elemento de linguagem que suporta a aplicação de comentários da documentação XML com o bloco de comentário XML

Bloco de comentários XML imediatamente deve preceder o elemento de linguagem ao qual ela se aplica

Comentário XML não pode aparecer dentro de um método ou propriedade

Comentário XML não pode ser aplicado mais de uma vez em um parcial < tipo >

Exceção de comentário XML deve ter um atributo 'cref'

Comentário XML tem uma marca com o atributo 'cref' '<attribute>' que não pôde ser resolvido

Comentário XML deve ser a primeira demonstrativo em uma linha

Parâmetro de comentário XML < parâmetro > não coincide com um parâmetro de tipo na declaração < keyword > correspondente

O parâmetro de comentário XML deve ter um atributo 'nome'

A marca de comentário XML '< tag >' aparece com atributos idênticos mais de uma vez no mesmo bloco de comentário XML

A marca de comentário XML '<marca>' não é permitida em um elemento de linguagem '<elemento>'

A marca de comentário XML 'include' deve ter um atributo '<attribute>'

A tag de comentário 'returns' não é permitida em um elemento de linguagem 'declare sub'

O rótulo de comentário XML 'returns' não é permitido em uma propriedade 'WriteOnly'

Parâmetro XML de tipo de comentário < parâmetro > não coincide com um parâmetro de tipo na declaração < keyword > correspondente

Parâmetro do tipo comentário XML deve ter um atributo 'nome'

Declaração XML não permite atributo 'attributeName'

Elementos XML descendentes não podem ser selecionados do tipo 'tipo'

Erro de análise de documentação XML: <erro>

Erro de análise de documentação XML: Marca de início '<tag>' não tem uma correspondente marca de participante

XML os DTDs não são suportados

Elementos XML não podem ser selecionados do tipo 'tipo'

Referências a entidades XML não são suportadas.

XML literal não pode aparecer aqui, a menos que esteja entre parênteses

As literais e propriedades de eixo XML não estão disponível

Não há suporte para literais XML e propriedades XML no código incorporado no ASP.NET

Nome XML esperado

O prefixo 'prefixo' de namespace XML já está declarado

O prefixo para namespace XML 'prefix' não está definido

prefixo de namespace de XML 'prefixo' é reservado para uso pelo XML e o namespace que URI não pode ser alterada

Namespace para XML com URI 'http://www.w3.org/XML/1998/namespace' pode ser vinculado apenas a 'xmlns'

inválido' nome de instrução de processamento de XML'

Você deve referenciar pelo menos uma variável range em ambos os lados do operador 'Igual'

Consulte também

Tarefas

Como: Obtenha informações sobre erros do compilador Visual Basic

Outros recursos

Mensagens de erro (Visual Basic)