Cannot create constructed generic type from another constructed generic type. Não é possível criar um tipo genérico construído com base em outro tipo genérico construído.

Cannot create constructed generic type from non-generic type. Não é possível criar um tipo genérico construído com base em um tipo não genérico.

To use '@$' instead of '$@' for an interpolated verbatim string, please use language version {0} or greater. Para usar '@$' em vez de '$@' para uma cadeia de caracteres textual interpolada, use a versão da linguagem {0} ou superior.

Cannot use a nullable reference type in object creation. Não é possível usar um tipo de referência que permite valor nulo na criação do objeto.

Element names are not permitted when pattern-matching via 'System.Runtime.CompilerServices.ITuple'. Os nomes de elemento não são permitidos em caso de correspondência de padrões por meio de 'System.Runtime.CompilerServices.ITuple'.

It is not legal to use nullable reference type '{0}?' in an as expression; use the underlying type '{0}' instead. It is not legal to use nullable reference type '{0}?' in an as expression; use the underlying type '{0}' instead.

Asynchronous foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a suitable public instance definition for '{1}' A instrução foreach assíncrona não pode operar em variáveis do tipo '{0}' porque '{0}' não contém uma definição da instância pública adequada para '{1}'

Asynchronous foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a public instance definition for '{1}'. Did you mean 'foreach' rather than 'await foreach'? A instrução foreach assíncrona não pode operar em variáveis do tipo '{0}' porque '{0}' não contém uma definição da instância pública para '{1}'. Você quis dizer 'foreach' em vez de 'await foreach'?

Cannot use a collection of dynamic type in an asynchronous foreach Não é possível usar uma coleção do tipo dinâmico em uma foreach assíncrona

Invalid option '{0}' for /nullable; must be 'disable', 'enable', 'safeonly', 'warnings' or 'safeonlywarnings' Opção inválida '{0}' para /nullable; precisa ser 'disable', 'enable', 'safeonly', 'warnings' ou 'safeonlywarnings'

Invalid operand for pattern match; value required, but found '{0}'. Operando inválido para correspondência de padrão. Um valor era obrigatório, mas '{0}' foi encontrado.

__arglist cannot have an argument passed by 'in' or 'out' __arglist não pode ter um argumento passado por 'in' ou 'out'

Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}' O parâmetro de tipo '{1}' tem a restrição 'unmanaged' e, por isso, '{1}' não pode ser usado como uma restrição de '{0}'

The name '{0}' does not match the corresponding 'Deconstruct' parameter '{1}'. O nome '{0}' não corresponde ao parâmetro 'Deconstruct' '{1}'.

A default literal 'default' is not valid as a pattern. Use another literal (e.g. '0' or 'null') as appropriate. To match everything, use a discard pattern '_'. Um literal padrão 'default' não é válido como um padrão. Use outro literal (por exemplo, '0' ou 'null') conforme o necessário. Para corresponder a tudo, use um padrão de descarte '_'.

The discard pattern is not permitted as a case label in a switch statement. Use 'case var _:' for a discard pattern, or 'case @_:' for a constant named '_'. O padrão de descarte não é permitido como um rótulo de caso em uma instrução switch. Use 'case var _:' para um padrão de descarte ou 'case @_:' para uma constante chamada '_'.

'{0}' is explicitly implemented more than once. '{0}' é implementado explicitamente mais de uma vez.

'else' cannot start a statement. 'else' não pode iniciar uma instrução.

Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed. Não é permitida a aplicação explícita de 'System.Runtime.CompilerServices.NullableAttribute'.

The given expression cannot be used in a fixed statement A expressão determinada não pode ser usada em uma instrução fixa

An expression tree may not contain a null coalescing assignment Uma árvore de expressão não pode conter uma atribuição de união nula

Expression tree cannot contain value of ref struct or restricted type '{0}'. A árvore de expressão não pode conter um valor de struct de referência ou o tipo restrito '{0}'.

An expression tree may not contain a switch expression. Uma árvore de expressão não pode conter uma expressão switch.

An expression tree may not contain a tuple == or != operator Uma árvore de expressão não pode conter um operador == ou != de tupla

The feature '{0}' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version. The feature '{0}' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.

Feature '{0}' is experimental and unsupported; use '/features:{1}' to enable. O recurso '{0}' é experimental e sem suporte; use '/features:{1}' para habilitar.

Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 8.0. Use a versão de linguagem {1} ou superior.

foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a public instance definition for '{1}'. Did you mean 'await foreach' rather than 'foreach'? A instrução foreach não pode operar em variáveis do tipo '{0}' porque '{0}' não contém uma definição da instância pública para '{1}'. Você quis dizer 'await foreach' em vez de 'foreach'?

A goto cannot jump to a location before a using declaration within the same block. Um goto não pode saltar para um local antes de uma declaração using no mesmo bloco.

A goto cannot jump to a location after a using declaration. Um goto não pode saltar para um local antes de uma declaração using.

The suppression operator is not allowed in this context The suppression operator is not allowed in this context

Arguments with 'in' modifier cannot be used in dynamically dispatched expressions. Os argumentos com o modificador 'in' não podem ser usados em expressões expedidas dinamicamente.

'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter '{0}' não pode implementar o membro de interface '{1}' no tipo '{2}' porque tem um parâmetro __arglist

Invalid hash algorithm name: '{0}' Nome de algoritmo de hash inválido: '{0}'

Invalid object creation Criação de objeto inválido

"Invalid rank specifier: expected ']' "Especificador de classificação inválido: era esperado ']'

It is not legal to use nullable reference type '{0}?' in an is-type expression; use the underlying type '{0}' instead. It is not legal to use nullable reference type '{0}?' in an is-type expression; use the underlying type '{0}' instead.

An expression of type '{0}' can never match the provided pattern. Uma expressão do tipo '{0}' nunca pode corresponder ao padrão fornecido.

Method '{0}' with an iterator block must be 'async' to return '{1}' Method '{0}' with an iterator block must be 'async' to return '{1}'

Pattern missing Padrão ausente

The 'new()' constraint cannot be used with the 'unmanaged' constraint A restrição 'new()' não pode ser usada com a restrição 'unmanaged'

'{0}': type used in an async using statement must be implicitly convertible to 'System.IAsyncDisposable' or implement a suitable 'DisposeAsync' method. Did you mean 'using' rather than 'await using'? '{0}': o tipo usado em uma instrução using assíncrona precisa ser implicitamente conversível em 'System.IAsyncDisposable'. Você quis dizer 'using' em vez de 'await using'?

'{0}': type used in a using statement must be implicitly convertible to 'System.IDisposable' or implement a suitable 'Dispose' method. Did you mean 'await using' rather than 'using'? '{0}' o tipo usado em uma instrução using precisa ser implicitamente conversível em 'System.IDisposable'. Você quis dizer 'await using' em vez de 'using'?

Expected 'enable', 'safeonly', 'disable', or 'restore' Esperado 'enable', 'safeonly', 'disable' ou 'restore'

Invalid '{0}' value: '{1}' for C# {2}. Please use language version {3} or greater. Valor '{0}' inválido: '{1}' para C# {2}. Use a versão da linguagem {3} ou superior.

A nullable type parameter must be known to be a value type or non-nullable reference type. Consider adding a 'class', 'struct', or type constraint. Um parâmetro de tipo que permite valor nulo precisa ser um tipo de valor ou um tipo de referência não nulo. Considere a possibilidade de adicionar 'class', 'struct' ou restrição de tipo.

An out variable cannot be declared as a ref local Uma variável out não pode ser declarada como uma referência local

Pattern-matching is not permitted for pointer types. A correspondência de padrões não é permitida para tipos de ponteiro.

The body of an async-iterator method must contain a 'yield' statement. O corpo de um método iterador assíncrono precisa conter uma instrução 'yield'.

The body of an async-iterator method must contain a 'yield' statement. Consider removing 'async' from the method declaration or adding a 'yield' statement. O corpo de um método de iterador assíncrono precisa conter uma instrução 'yield'. Considere a possibilidade de remover 'async' da declaração de método ou de adicionar a instrução 'yield'.

A property subpattern requires a reference to the property or field to be matched, e.g. '{{ Name: {0} }}' Um subpadrão de propriedade requer que uma referência à propriedade ou ao campo seja correspondida, por exemplo, '{{ Name: {0} }}'

Cannot ref-assign '{1}' to '{0}' because '{1}' has a narrower escape scope than '{0}'. Não é possível atribuir ref '{1}' a '{0}' porque '{1}' tem um escopo de escape mais limitado que '{0}'.

The left-hand side of a ref assignment must be a ref local or parameter. O lado esquerdo da atribuição ref precisa ser um parâmetro ou local ref.

A single-element deconstruct pattern requires some other syntax for disambiguation. It is recommended to add a discard designator '_' after the close paren ')'. Um padrão de desconstrução de elemento único requer alguma outra sintaxe para desambiguação. É recomendado adicionar um designador de descarte '_' após o parêntese de fechamento ')'.

A static local function cannot contain a reference to 'this' or 'base'. Uma função local estática não pode conter uma referência a 'this' ou a 'base'.

A static local function cannot contain a reference to '{0}'. Uma função local estática não pode conter uma referência a '{0}'.

The pattern has already been handled by a previous arm of the switch expression. O padrão já foi manipulado por um braço anterior da expressão switch.

The switch case has already been handled by a previous case. O caso do switch já foi manipulado por um caso anterior.

No best type was found for the switch expression. Não foi encontrado um tipo melhor para a expressão switch.

Parentheses are required around the switch governing expression. É necessário colocar a expressão que rege a switch entre parênteses.

Unexpected character sequence '...' Sequência de caracteres inesperada '...'

The name '{0}' does not identify tuple element '{1}'. O nome '{0}' não identifica o elemento de tupla '{1}'.

Tuple types used as operands of an == or != operator must have matching cardinalities. But this operator has tuple types of cardinality {0} on the left and {1} on the right. Os tipos de tupla usados como operandos de um operador == ou != precisam ter cardinalidades correspondentes. No entanto, este operador tem tipos de tupla de cardinalidade {0} na esquerda e {1} na direita.

'{0}': cannot specify both a constraint class and the 'unmanaged' constraint '{0}': não é possível especificar uma classe de restrição e a restrição 'unmanaged'

The 'unmanaged' constraint must come before any other constraints A restrição 'unmanaged' deve vir antes das outras restrições

The type '{2}' must be a non-nullable value type, along with all fields at any level of nesting, in order to use it as parameter '{1}' in the generic type or method '{0}' O tipo '{2}' precisa ser um tipo de valor que não permite valor nulo, juntamente com todos os campos em qualquer nível de aninhamento, para ser usado como um parâmetro '{1}' no tipo genérico ou no método '{0}'

A using variable cannot be used directly within a switch section (consider using braces). Uma variável using não pode ser usada diretamente em uma seção de switch (considere o uso de chaves).

The syntax 'var' for a pattern is not permitted to refer to a type, but '{0}' is in scope here. A sintaxe 'var' de um padrão não pode referenciar um tipo, mas '{0}' está no escopo aqui.

Matching the tuple type '{0}' requires '{1}' subpatterns, but '{2}' subpatterns are present. A correspondência ao tipo de tupla '{0}' requer '{1}' subpadrões, mas '{2}' subpadrões estão presentes.

File name '{0}' is empty, contains invalid characters, has a drive specification without an absolute path, or is too long Nome do arquivo "{0}" está vazio, contém caracteres inválidos, tem uma especificação de unidade sem um caminho absoluto ou é muito longo

Expression is probably never null. A expressão provavelmente é nunca nula.

Result of the comparison is possibly always false. O resultado da comparação possivelmente é sempre falso.

Result of the comparison is possibly always true. O resultado da comparação possivelmente é sempre verdadeiro.

Visual C# Compiler Options - OUTPUT FILES - -out:<file> Specify output file name (default: base name of file with main class or first file) -target:exe Build a console executable (default) (Short form: -t:exe) -target:winexe Build a Windows executable (Short form: -t:winexe) -target:library Build a library (Short form: -t:library) -target:module Build a module that can be added to another assembly (Short form: -t:module) -target:appcontainerexe Build an Appcontainer executable (Short form: -t:appcontainerexe) -target:winmdobj Build a Windows Runtime intermediate file that is consumed by WinMDExp (Short form: -t:winmdobj) -doc:<file> XML Documentation file to generate -refout:<file> Reference assembly output to generate -platform:<string> Limit which platforms this code can run on: x86, Itanium, x64, arm, arm64, anycpu32bitpreferred, or anycpu. The default is anycpu. - INPUT FILES - -recurse:<wildcard> Include all files in the current directory and subdirectories according to the wildcard specifications -reference:<alias>=<file> Reference metadata from the specified assembly file using the given alias (Short form: -r) -reference:<file list> Reference metadata from the specified assembly files (Short form: -r) -addmodule:<file list> Link the specified modules into this assembly -link:<file list> Embed metadata from the specified interop assembly files (Short form: -l) -analyzer:<file list> Run the analyzers from this assembly (Short form: -a) -additionalfile:<file list> Additional files that don't directly affect code generation but may be used by analyzers for producing errors or warnings. -embed Embed all source files in the PDB. -embed:<file list> Embed specific files in the PDB - RESOURCES - -win32res:<file> Specify a Win32 resource file (.res) -win32icon:<file> Use this icon for the output -win32manifest:<file> Specify a Win32 manifest file (.xml) -nowin32manifest Do not include the default Win32 manifest -resource:<resinfo> Embed the specified resource (Short form: -res) -linkresource:<resinfo> Link the specified resource to this assembly (Short form: -linkres) Where the resinfo format is <file>[,<string name>[,public|private]] - CODE GENERATION - -debug[+|-] Emit debugging information -debug:{full|pdbonly|portable|embedded} Specify debugging type ('full' is default, 'portable' is a cross-platform format, 'embedded' is a cross-platform format embedded into the target .dll or .exe) -optimize[+|-] Enable optimizations (Short form: -o) -deterministic Produce a deterministic assembly (including module version GUID and timestamp) -refonly Produce a reference assembly in place of the main output -instrument:TestCoverage Produce an assembly instrumented to collect coverage information -sourcelink:<file> Source link info to embed into PDB. - ERRORS AND WARNINGS - -warnaserror[+|-] Report all warnings as errors -warnaserror[+|-]:<warn list> Report specific warnings as errors -warn:<n> Set warning level (0-4) (Short form: -w) -nowarn:<warn list> Disable specific warning messages -ruleset:<file> Specify a ruleset file that disables specific diagnostics. -errorlog:<file> Specify a file to log all compiler and analyzer diagnostics. -reportanalyzer Report additional analyzer information, such as execution time. - LANGUAGE - -checked[+|-] Generate overflow checks -unsafe[+|-] Allow 'unsafe' code -define:<symbol list> Define conditional compilation symbol(s) (Short form: -d) -langversion:? Display the allowed values for language version -langversion:<string> Specify language version such as `default` (latest major version), or `latest` (latest version, including minor versions), or specific versions like `6` or `7.1` -nullable[+|-] Specify nullable context option enable|disable. -nullable:{enable|disable|safeonly|warnings|safeonlywarnings} Specify nullable context option enable|disable|safeonly|warnings|safeonlywarnings. - SECURITY - -delaysign[+|-] Delay-sign the assembly using only the public portion of the strong name key -publicsign[+|-] Public-sign the assembly using only the public portion of the strong name key -keyfile:<file> Specify a strong name key file -keycontainer:<string> Specify a strong name key container -highentropyva[+|-] Enable high-entropy ASLR - MISCELLANEOUS - @<file> Read response file for more options -help Display this usage message (Short form: -?) -nologo Suppress compiler copyright message -noconfig Do not auto include CSC.RSP file -parallel[+|-] Concurrent build. -version Display the compiler version number and exit. - ADVANCED - -baseaddress:<address> Base address for the library to be built -checksumalgorithm:<alg> Specify algorithm for calculating source file checksum stored in PDB. Supported values are: SHA1 or SHA256 (default). -codepage:<n> Specify the codepage to use when opening source files -utf8output Output compiler messages in UTF-8 encoding -main:<type> Specify the type that contains the entry point (ignore all other possible entry points) (Short form: -m) -fullpaths Compiler generates fully qualified paths -filealign:<n> Specify the alignment used for output file sections -pathmap:<K1>=<V1>,<K2>=<V2>,... Specify a mapping for source path names output by the compiler. -pdb:<file> Specify debug information file name (default: output file name with .pdb extension) -errorendlocation Output line and column of the end location of each error -preferreduilang Specify the preferred output language name. -nosdkpath Disable searching the default SDK path for standard library assemblies. -nostdlib[+|-] Do not reference standard library (mscorlib.dll) -subsystemversion:<string> Specify subsystem version of this assembly -lib:<file list> Specify additional directories to search in for references -errorreport:<string> Specify how to handle internal compiler errors: prompt, send, queue, or none. The default is queue. -appconfig:<file> Specify an application configuration file containing assembly binding settings -moduleassemblyname:<string> Name of the assembly which this module will be a part of -modulename:<string> Specify the name of the source module Visual C# Compiler Options - OUTPUT FILES - -out:<file> Specify output file name (default: base name of file with main class or first file) -target:exe Build a console executable (default) (Short form: -t:exe) -target:winexe Build a Windows executable (Short form: -t:winexe) -target:library Build a library (Short form: -t:library) -target:module Build a module that can be added to another assembly (Short form: -t:module) -target:appcontainerexe Build an Appcontainer executable (Short form: -t:appcontainerexe) -target:winmdobj Build a Windows Runtime intermediate file that is consumed by WinMDExp (Short form: -t:winmdobj) -doc:<file> XML Documentation file to generate -refout:<file> Reference assembly output to generate -platform:<string> Limit which platforms this code can run on: x86, Itanium, x64, arm, arm64, anycpu32bitpreferred, or anycpu. The default is anycpu. - INPUT FILES - -recurse:<wildcard> Include all files in the current directory and subdirectories according to the wildcard specifications -reference:<alias>=<file> Reference metadata from the specified assembly file using the given alias (Short form: -r) -reference:<file list> Reference metadata from the specified assembly files (Short form: -r) -addmodule:<file list> Link the specified modules into this assembly -link:<file list> Embed metadata from the specified interop assembly files (Short form: -l) -analyzer:<file list> Run the analyzers from this assembly (Short form: -a) -additionalfile:<file list> Additional files that don't directly affect code generation but may be used by analyzers for producing errors or warnings. -embed Embed all source files in the PDB. -embed:<file list> Embed specific files in the PDB - RESOURCES - -win32res:<file> Specify a Win32 resource file (.res) -win32icon:<file> Use this icon for the output -win32manifest:<file> Specify a Win32 manifest file (.xml) -nowin32manifest Do not include the default Win32 manifest -resource:<resinfo> Embed the specified resource (Short form: -res) -linkresource:<resinfo> Link the specified resource to this assembly (Short form: -linkres) Where the resinfo format is <file>[,<string name>[,public|private]] - CODE GENERATION - -debug[+|-] Emit debugging information -debug:{full|pdbonly|portable|embedded} Specify debugging type ('full' is default, 'portable' is a cross-platform format, 'embedded' is a cross-platform format embedded into the target .dll or .exe) -optimize[+|-] Enable optimizations (Short form: -o) -deterministic Produce a deterministic assembly (including module version GUID and timestamp) -refonly Produce a reference assembly in place of the main output -instrument:TestCoverage Produce an assembly instrumented to collect coverage information -sourcelink:<file> Source link info to embed into PDB. - ERRORS AND WARNINGS - -warnaserror[+|-] Report all warnings as errors -warnaserror[+|-]:<warn list> Report specific warnings as errors -warn:<n> Set warning level (0-4) (Short form: -w) -nowarn:<warn list> Disable specific warning messages -ruleset:<file> Specify a ruleset file that disables specific diagnostics. -errorlog:<file> Specify a file to log all compiler and analyzer diagnostics. -reportanalyzer Report additional analyzer information, such as execution time. - LANGUAGE - -checked[+|-] Generate overflow checks -unsafe[+|-] Allow 'unsafe' code -define:<symbol list> Define conditional compilation symbol(s) (Short form: -d) -langversion:? Display the allowed values for language version -langversion:<string> Specify language version such as `default` (latest major version), or `latest` (latest version, including minor versions), or specific versions like `6` or `7.1` -nullable[+|-] Specify nullable context option enable|disable. -nullable:{enable|disable|safeonly|warnings|safeonlywarnings} Specify nullable context option enable|disable|safeonly|warnings|safeonlywarnings. - SECURITY - -delaysign[+|-] Delay-sign the assembly using only the public portion of the strong name key -publicsign[+|-] Public-sign the assembly using only the public portion of the strong name key -keyfile:<file> Specify a strong name key file -keycontainer:<string> Specify a strong name key container -highentropyva[+|-] Enable high-entropy ASLR - MISCELLANEOUS - @<file> Read response file for more options -help Display this usage message (Short form: -?) -nologo Suppress compiler copyright message -noconfig Do not auto include CSC.RSP file -parallel[+|-] Concurrent build. -version Display the compiler version number and exit. - ADVANCED - -baseaddress:<address> Base address for the library to be built -checksumalgorithm:<alg> Specify algorithm for calculating source file checksum stored in PDB. Supported values are: SHA1 or SHA256 (default). -codepage:<n> Specify the codepage to use when opening source files -utf8output Output compiler messages in UTF-8 encoding -main:<type> Specify the type that contains the entry point (ignore all other possible entry points) (Short form: -m) -fullpaths Compiler generates fully qualified paths -filealign:<n> Specify the alignment used for output file sections -pathmap:<K1>=<V1>,<K2>=<V2>,... Specify a mapping for source path names output by the compiler. -pdb:<file> Specify debug information file name (default: output file name with .pdb extension) -errorendlocation Output line and column of the end location of each error -preferreduilang Specify the preferred output language name. -nosdkpath Disable searching the default SDK path for standard library assemblies. -nostdlib[+|-] Do not reference standard library (mscorlib.dll) -subsystemversion:<string> Specify subsystem version of this assembly -lib:<file list> Specify additional directories to search in for references -errorreport:<string> Specify how to handle internal compiler errors: prompt, send, queue, or none. The default is queue. -appconfig:<file> Specify an application configuration file containing assembly binding settings -moduleassemblyname:<string> Name of the assembly which this module will be a part of -modulename:<string> Specify the name of the source module Visual C# Compiler Options

disposable descartável

alternative interpolated verbatim strings cadeias de caracteres textuais interpoladas alternativas

coalescing assignment atribuição de união

delegate generic type constraints restrições de tipo genérico delegate

enum generic type constraints restrições de tipo genérico enum

declaration of expression variables in member initializers and queries declaração de variáveis de expressão em inicializadores e em consultas do membro

extensible fixed statement instrução fixa extensível

index operator operador de índice

indexing movable fixed buffers buffers fixos móveis de indexação

name shadowing in nested functions name shadowing in nested functions

nullable reference types tipos de referência que permitem valor nulo

object generic type constraint restrição de tipo genérico de objeto

warning action enable or safeonly warning action enable or safeonly

range operator operador de intervalo

recursive patterns padrões recursivos

ref conditional expression expressão condicional ref

ref for-loop variables variáveis de loop ref for

ref foreach iteration variables variáveis de iteração ref foreach

ref reassignment reatribuição de ref

stackalloc initializer inicializador stackalloc

static local functions funções locais estáticas

tuple equality igualdade de tupla

unconstrained type parameters in null coalescing operator parâmetros de tipo irrestrito em operador de união nulo

unmanaged constructed types unmanaged constructed types

unmanaged generic type constraints restrições de tipo genérico unmanaged

using declarations declarações using

(Location of symbol related to previous error) (Local do símbolo relacionado ao erro anterior)

(Location of symbol related to previous warning) (Local do símbolo relacionado ao aviso anterior)

<! -- Comentário XML mal formado ignorado para o membro "{0}" -->

Badly formed XML file "{0}" cannot be included Arquivo XML mal formado "{0}" não pode ser incluído

Failed to insert some or all of included XML Falha ao inserir alguns ou todos os XML incluídos

Include tag is invalid Marca include inválida

No matching elements were found for the following include tag Nenhum elemento correspondente foi encontrado na seguinte marca include

Missing file attribute Atributo de arquivo ausente

Missing path attribute Atributo de caminho ausente

generics genéricos

anonymous methods métodos anônimos

module as an attribute target specifier módulo como um especificador de destino de atributo

namespace alias qualifier qualificador alias de namespace

fixed size buffers buffers de tamanho fixo

#pragma #pragma

static classes classes static

readonly structs structs somente leitura

partial types tipos parciais

async function função assíncrona

switch on boolean type opção em tipo booleano

method group grupo de métodos

anonymous method método anônimo

lambda expression expressão lambda

collection coleção

access modifiers on properties modificadores de acesso nas propriedades

extern alias alias externo

iterators iteradores

default operator operador padrão

default literal literal padrão

private protected protegido de forma privada

nullable types tipos anuláveis

pattern matching correspondência de padrões

expression body property accessor acessador da propriedade do corpo da expressão

expression body constructor and destructor destruidor e construtor do corpo da expressão

throw expression expressão throw

implicitly typed array matriz digitada implicitamente

implicitly typed local variable variável local digitada implicitamente

anonymous types tipos anônimos

automatically implemented properties propriedades implementadas automaticamente

readonly automatically implemented properties propriedades somente leitura implementadas automaticamente

object initializer inicializador de objeto

collection initializer inicializador de coleção

query expression expressão de consulta

extension method método de extensão

partial method método parcial

method método

type tipo

namespace namespace

field campo

property propriedade

element elemento

variable variável

label rótulo

event evento

type parameter parâmetro de tipo

using alias alias using

extern alias alias externo

constructor construtor

foreach iteration variable variável de iteração foreach

fixed variable variável fixed

using variable variável using

contravariant contravariant

contravariantly contravariantly

covariant covariant

covariantly covariantly

invariantly invariantement

dynamic dinâmica

named argument argumento nomeado

optional parameter parâmetro opcional

exception filter filtro de exceção

type variance variação de tipo

SyntaxTree is not part of the compilation A SyntaxTree não faz parte da compilação

SyntaxTree is not part of the compilation, so it cannot be removed A SyntaxTree não faz parte da compilação, portanto, não pode ser removida

The name '_' refers to the constant, not the discard pattern. Use 'var _' to discard the value, or '@_' to refer to a constant by that name. O nome '_' refere-se à constante, não ao padrão de descarte. Use 'var _' para descartar o valor ou '@_' para referir-se a uma constante por esse nome.

Do not use '_' for a case constant. Não use '_' para uma constante de caso.

Converting null literal or possible null value to non-nullable type. Conversão de literal nula ou possível valor nulo em tipo não nulo.

'default' is converted to 'null', not 'default({0})' 'default' é convertido em 'null', e não 'default({0})'

'default' is converted to 'null' 'default' é convertido em 'null'

'{0}' is already listed in the interface list on type '{1}' with different nullability of reference types. '{0}' já está listado na lista de interfaces no tipo '{1}' com uma nulidade diferente de tipos de referência.

Interface is already listed in the interface list with different nullability of reference types. A interface já está listada na lista de interfaces com uma nulidade diferente de tipos de referência.

The given expression always matches the provided constant. A expressão fornecida sempre corresponde à constante fornecida.

The given expression never matches the provided pattern. A expressão fornecida nunca corresponde ao padrão fornecido.

Expected nullable Expected nullable

Expected nullable after #pragma warning safeonly Expected nullable after #pragma warning safeonly

The name '_' refers to the type '{0}', not the discard pattern. Use '@_' for the type, or 'var _' to discard. O nome '_' refere-se ao tipo '{0}', não ao padrão de descarte. Use '@_' para o tipo ou 'var _' para descarte.

Do not use '_' to refer to the type in an is-type expression. Não use '_' para referir-se ao tipo em uma expressão is-type.

The annotation for nullable reference types should only be used in code within a '#nullable' context. A anotação para tipos de referência que permitem valor nulo deve ser usada apenas em código dentro de um contexto '#nullable'.

Cannot convert null literal to non-nullable reference or unconstrained type parameter. Não é possível converter uma literal nula em referência não nula ou em parâmetro de tipo irrestrito.

Possible null reference argument for parameter '{0}' in '{1}'. Possível argumento de referência nula para o parâmetro '{0}' em '{1}'.

Possible null reference argument. Possível argumento de referência nula.

Possible null reference assignment. Possível atribuição de referência nula.

Possible dereference of a null reference. Possível desreferência de uma referência nula.

Possible null reference return. Possível retorno de referência nula.

Argument of type '{0}' cannot be used as an input of type '{1}' for parameter '{2}' in '{3}' due to differences in the nullability of reference types. A anulabilidade de tipos de referência em um argumento do tipo '{0}' não coincide com o tipo de destino '{1}' para o parâmetro '{2}' em '{3}'.

Argument of type '{0}' cannot be used as an output of type '{1}' for parameter '{2}' in '{3}' due to differences in the nullability of reference types. Argument of type '{0}' cannot be used as an output of type '{1}' for parameter '{2}' in '{3}' due to differences in the nullability of reference types.

Argument cannot be used as an output for parameter due to differences in the nullability of reference types. Argument cannot be used as an output for parameter due to differences in the nullability of reference types.

Argument cannot be used as an input for parameter due to differences in the nullability of reference types. A anulabilidade de tipos de referência no argumento não corresponde ao tipo de destino.

Nullability of reference types in value of type '{0}' doesn't match target type '{1}'. A anulabilidade de tipos de referência no valor do tipo '{0}' não corresponde ao tipo de destino '{1}'.

Nullability of reference types in value doesn't match target type. A anulabilidade de tipos de referência no valor não corresponde ao tipo de destino.

Nullability in constraints for type parameter '{0}' of method '{1}' doesn't match the constraints for type parameter '{2}' of interface method '{3}'. Consider using an explicit interface implementation instead. A anulabilidade em restrições para parâmetro de tipo '{0}' do método '{1}' não corresponde às restrições para o parâmetro de tipo '{2}' do método de interface '{3}'. Em vez disso, considere a possibilidade de usar uma implementação de interface explícita.

Nullability in constraints for type parameter doesn't match the constraints for type parameter in implicitly implemented interface method'. A anulabilidade em restrições para parâmetro de tipo não corresponde às restrições para parâmetro de tipo em método de interface implicitamente implementado.

Nullability of reference types in explicit interface specifier doesn't match interface implemented by the type. A nulidade dos tipos de referência no especificador de interface explícito não corresponde à interface implementada pelo tipo.

'{0}' does not implement interface member '{1}'. Nullability of reference types in interface implemented by the base type doesn't match. '{0}' não implementa o membro da interface '{1}'. A nulidade dos tipos de referência na interface implementados pelo tipo base não corresponde.

Type does not implement interface member. Nullability of reference types in interface implemented by the base type doesn't match. O tipo não implementa o membro da interface. A nulidade dos tipos de referência na interface implementados pelo tipo base não corresponde.

Nullability of reference types in type of parameter '{0}' of '{1}' doesn't match the target delegate '{2}'. A anulabilidade de tipos de referência em tipo de parâmetro '{0}' de '{1}' não corresponde ao delegado de destino '{2}'.

Nullability of reference types in type of parameter doesn't match the target delegate. A anulabilidade de tipos de referência em tipo de parâmetro não corresponde ao delegado de destino.

Nullability of reference types in type of parameter '{0}' doesn't match implemented member '{1}'. A anulabilidade de tipos de referência em tipo de parâmetro '{0}' não corresponde ao membro implementado '{1}'.

Nullability of reference types in type of parameter doesn't match implemented member. A anulabilidade de tipos de referência em tipo de parâmetro não corresponde ao membro implementado.

Nullability of reference types in type of parameter '{0}' doesn't match implicitly implemented member '{1}'. A anulabilidade de tipos de referência em tipo de parâmetro '{0}' não corresponde ao membro implicitamente implementado '{1}'.

Nullability of reference types in type of parameter doesn't match implicitly implemented member. A anulabilidade de tipos de referência em tipo de parâmetro não corresponde ao membro implicitamente implementado.

Nullability of reference types in type of parameter '{0}' doesn't match overridden member. A anulabilidade de tipos de referência em tipo de parâmetro '{0}' não corresponde ao membro substituído.

Nullability of reference types in type of parameter doesn't match overridden member. A anulabilidade de tipos de referência em tipo de parâmetro não corresponde ao membro substituído.

Nullability of reference types in type of parameter '{0}' doesn't match partial method declaration. A anulabilidade de tipos de referência em tipo de parâmetro '{0}' não corresponde à declaração de método parcial.

Nullability of reference types in type of parameter doesn't match partial method declaration. A anulabilidade de tipos de referência em tipo de parâmetro não corresponde à declaração de método parcial.

Nullability of reference types in return type of '{0}' doesn't match the target delegate '{1}'. A anulabilidade de tipos de referência em tipo de retorno '{0}' não corresponde ao delegado de destino '{1}'.

Nullability of reference types in return type doesn't match the target delegate. A anulabilidade de tipos de referência em tipo de retorno não corresponde ao delegado de destino.

Nullability of reference types in return type doesn't match implemented member '{0}'. A anulabilidade de tipos de referência em tipo de retorno não corresponde ao membro implementado '{0}'.

Nullability of reference types in return type doesn't match implemented member. A anulabilidade de tipos de referência em tipo de retorno não corresponde ao membro implementado.

Nullability of reference types in return type doesn't match implicitly implemented member '{0}'. A anulabilidade de tipos de referência em tipo de retorno não corresponde ao membro implicitamente implementado '{0}'.

Nullability of reference types in return type doesn't match implicitly implemented member. A anulabilidade de tipos de referência em tipo de retorno não corresponde ao membro implicitamente implementado.

Nullability of reference types in return type doesn't match overridden member. A anulabilidade de tipos de referência em tipo de retorno não corresponde ao membro substituído.

Nullability of reference types in type doesn't match implemented member '{0}'. A anulabilidade de tipos de referência em tipo não corresponde ao membro implementado '{0}'.

Nullability of reference types in type doesn't match implemented member. A anulabilidade de tipos de referência em tipo não corresponde ao membro implementado.

Nullability of reference types in type doesn't match implicitly implemented member '{0}'. A anulabilidade de tipos de referência em tipo não corresponde ao membro implicitamente implementado '{0}'.

Nullability of reference types in type doesn't match implicitly implemented member. A anulabilidade de tipos de referência em tipo não corresponde ao membro implicitamente implementado.

Nullability of reference types in type doesn't match overridden member. A anulabilidade de tipos de referência em tipo não corresponde ao membro substituído.

The type '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. Nullability of type argument '{3}' doesn't match constraint type '{1}'. O tipo '{3}' não pode ser usado como parâmetro de tipo '{2}' no tipo ou método genérico '{0}'. A anulabilidade do argumento de tipo '{3}' não corresponde ao tipo de restrição '{1}'.

The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match constraint type. O tipo não pode ser usado como parâmetro de tipo no tipo ou método genérico. A anulabilidade do argumento de tipo não corresponde ao tipo de restrição.

The type '{2}' cannot be used as type parameter '{1}' in the generic type or method '{0}'. Nullability of type argument '{2}' doesn't match 'class' constraint. O tipo '{2}' não pode ser usado como parâmetro de tipo '{1}' no tipo ou método genérico '{0}'. A anulabilidade do argumento de tipo '{2}' não corresponde à restrição 'class'.

The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'class' constraint. O tipo não pode ser usado como parâmetro de tipo no tipo ou método genérico. A anulabilidade do argumento de tipo não corresponde à restrição 'class'.

Nullable value type may be null. O tipo de valor de nulidade pode ser nulo.

Possible null value. Possible null value.

The switch expression does not handle all possible inputs (it is not exhaustive). A expressão switch não manipula todas as entradas possíveis (não é finita).

The tuple element name '{0}' is ignored because a different name or no name is specified on the other side of the tuple == or != operator. O nome do elemento da tupla '{0}' foi ignorado porque um nome diferente ou nenhum nome foi especificado no outro lado do operador == ou != de tupla.

The tuple element name is ignored because a different name or no name is specified on the other side of the tuple == or != operator. O nome do elemento da tupla foi ignorado porque um nome diferente ou nenhum nome foi especificado no outro lado do operador == ou != de tupla.

Type parameter '{0}' has the same name as the type parameter from outer method '{1}' O parâmetro de tipo ‘{0}’ tem o mesmo nome que o parâmetro de tipo do método externo '{1}'

Type parameter has the same type as the type parameter from outer method. O parâmetro de tipo tem o mesmo tipo que o parâmetro de tipo do método externo.

Non-nullable {0} '{1}' is uninitialized. O {0} não nulo '{1}' é não inicializado.

Non-nullable field is uninitialized. O campo não nulo é não inicializado.

The character(s) '{0}' cannot be used at this location. O(s) caractere(s) "{0}" não pode(m) ser usado(s) neste local.

Incorrect syntax was used in a comment. Foi usada uma sintaxe incorreta em um comentário.

An invalid character was found inside an entity reference. Um caractere inválido foi encontrado dentro de uma referência de entidade.

Expected '>' or '/>' to close tag '{0}'. ">" ou "/>" está faltando para fechar a marca "{0}".

An identifier was expected. Um identificador era esperado.

Invalid unicode character. Caractere unicode inválido.

Whitespace is not allowed at this location. Espaço em branco não é permitido neste local.

The character '<' cannot be used in an attribute value. O caractere "<" não pode ser usado em um valor de atributo.

Missing equals sign between attribute and attribute value. Ausência de sinal de igual entre atributo e o valor de atributo.

Reference to undefined entity '{0}'. Referência à entidade indefinida "{0}".

A string literal was expected, but no opening quotation mark was found. Um literal de cadeia de caracteres era esperado, mas nenhuma aspa de abertura foi encontrada.

Missing closing quotation mark for string literal. Aspa de fechamento ausente para o literal da cadeia de caracteres.

Non-ASCII quotations marks may not be used around string literals. Aspas não ASCII não podem ser usadas em literais de cadeia de caracteres.

End tag was not expected at this location. Marca de fim não era esperada neste local.

End tag '{0}' does not match the start tag '{1}'. Marca de fim "{0}" não corresponde à marca de início "{1}".

Expected an end tag for element '{0}'. Espera-se uma marca de fim para o elemento "{0}".

Required white space was missing. Espaço em branco necessário estava ausente.

Unexpected character at this location. Caractere inesperado neste local.

The literal string ']]>' is not allowed in element content. A cadeia de caracteres literal "]]>" não é permitida no conteúdo do elemento.

Duplicate '{0}' attribute Duplicar atributo "{0}"

Metadata file '{0}' could not be found Arquivo de origem "{0}" não pode ser encontrado

Metadata references are not supported. Não há suporte a referências de metadados.

Metadata file '{0}' could not be opened -- {1} Arquivo de metadados "{0}" não pode ser aberto -- {1}

The type '{0}' is defined in an assembly that is not referenced. You must add a reference to assembly '{1}'. O tipo "{0}" está definido em um assembly que não é referenciado. Você deve adicionar uma referência ao assembly "{1}".

The type '{0}' is defined in a module that has not been added. You must add the module '{1}'. O tipo "{0}" está definido em um módulo não foi adicionado. Você deve adicionar o módulo "{1}".

Could not write to output file '{0}' -- '{1}' Não foi possível gravar no arquivo de saída "{0}" -- "{1}"

Program has more than one entry point defined. Compile with /main to specify the type that contains the entry point. Programa tem mais de um ponto de entrada definido. Compilar com /main para especificar o tipo que contém o ponto de entrada.

Operator '{0}' cannot be applied to operands of type '{1}' and '{2}' O operador "{0}" não pode ser aplicado a operandos dos tipos "{1}" e "{2}"

Division by constant zero Divisão por zero constante

Cannot apply indexing with [] to an expression of type '{0}' Não é possível aplicar a indexação com [] a uma expressão do tipo "{0}"

Wrong number of indices inside []; expected {0} Número incorreto de índices dentro de []; esperado {0}

Operator '{0}' cannot be applied to operand of type '{1}' O operador "{0}" não pode ser aplicado ao operando do tipo "{1}"

Operator '{0}' cannot be applied to operand '{1}' O operador '{0}' não pode ser aplicado ao operando '{1}'

Keyword 'this' is not valid in a static property, static method, or static field initializer A palavra-chave 'this' não é válida em uma propriedade, um método ou um inicializador de campo estático

Keyword 'this' is not available in the current context A palavra-chave 'this' não está disponível no contexto atual

'{0}' has the wrong signature to be an entry point '"{0}" tem a assinatura incorreta para ser um ponto de entrada

Method has the wrong signature to be an entry point O método tem a assinatura incorreta para ser um ponto de entrada

Cannot implicitly convert type '{0}' to '{1}' Não é possível converter implicitamente tipo "{0}" em "{1}"

Cannot convert type '{0}' to '{1}' Não é possível converter tipo "{0}" em "{1}"

Constant value '{0}' cannot be converted to a '{1}' O valor de constante "{0}" não pode ser convertido em "{1}"

Operator '{0}' is ambiguous on operands of type '{1}' and '{2}' O operador "{0}" é ambíguo em operandos dos tipos "{1}" e "{2}"

Operator '{0}' is ambiguous on operands 'default' and 'default' O operador '{0}' é ambíguo nos operandos 'default' e 'default'

Operator '{0}' is ambiguous on an operand of type '{1}' O operador "{0}" é ambíguo em um operando do tipo "{1}"

An out parameter cannot have the In attribute Um parâmetro out não pode ter atributo In

Cannot convert null to '{0}' because it is a non-nullable value type Não é possível converter o valor nulo em '{0}' porque ele não é um tipo de valor não nulo

Cannot convert type '{0}' to '{1}' via a reference conversion, boxing conversion, unboxing conversion, wrapping conversion, or null type conversion Não é possível converter tipo "{0}" para "{1}" por meio de uma conversão de referência, conversão boxing, conversão unboxing ou conversão de tipo nulo

Unexpected error writing debug information -- '{0}' Erro inesperado ao gravar informações de depuração -- "{0}"

Inconsistent accessibility: return type '{1}' is less accessible than method '{0}' Acessibilidade inconsistente: tipo de retorno "{1}" é menos acessível do que o método "{0}"

Inconsistent accessibility: parameter type '{1}' is less accessible than method '{0}' Acessibilidade inconsistente: tipo de parâmetro "{1}" é menos acessível do que o método "{0}"

Inconsistent accessibility: field type '{1}' is less accessible than field '{0}' Acessibilidade inconsistente: tipo de campo "{1}" é menos acessível do que o campo "{0}"

Inconsistent accessibility: property type '{1}' is less accessible than property '{0}' Acessibilidade inconsistente: tipo de propriedade "{1}" é menos acessível do que a propriedade "{0}"

Inconsistent accessibility: indexer return type '{1}' is less accessible than indexer '{0}' Acessibilidade inconsistente: tipo de retorno do indexador "{1}" é menos acessível do que o indexador "{0}"

Inconsistent accessibility: parameter type '{1}' is less accessible than indexer '{0}' Acessibilidade inconsistente: tipo de parâmetro "{1}" é menos acessível do que o indexador "{0}"

Inconsistent accessibility: return type '{1}' is less accessible than operator '{0}' Acessibilidade inconsistente: tipo de retorno "{1}" é menos acessível do que o operador "{0}"

Inconsistent accessibility: parameter type '{1}' is less accessible than operator '{0}' Acessibilidade inconsistente: tipo de parâmetro "{1}" é menos acessível do que o operador "{0}"

Inconsistent accessibility: return type '{1}' is less accessible than delegate '{0}' Acessibilidade inconsistente: tipo de retorno "{1}" é menos acessível do que "{0}" delegado

Inconsistent accessibility: parameter type '{1}' is less accessible than delegate '{0}' Acessibilidade inconsistente: tipo de parâmetro "{1}" é menos acessível do que o delegado "{0}"

Inconsistent accessibility: base class '{1}' is less accessible than class '{0}' Acessibilidade inconsistente: classe base "{1}" é menos acessível do que a classe "{0}"

Inconsistent accessibility: base interface '{1}' is less accessible than interface '{0}' Acessibilidade inconsistente: interface base "{1}" é menos acessível do que interface "{0}"

'{0}': event property must have both add and remove accessors '"{0}": propriedade de evento deve ter acessadores adicionar e remover

'{0}': event must be of a delegate type '"{0}": evento deve ser de um tipo delegado

The event '{0}' is never used O evento "{0}" nunca é usado

Event is never used O evento nunca é usado

'{0}': event in interface cannot have initializer '"{0}": evento na interface não pode ter inicializador

An event in an interface cannot have add or remove accessors O evento em uma interface não pode ter acessadores add e remove

The event '{0}' can only appear on the left hand side of += or -= (except when used from within the type '{1}') O evento "{0}" pode apenas aparecer à esquerda de + = ou -= (exceto quando usado de dentro do tipo "{1}")

An explicit interface implementation of an event must use event accessor syntax Uma implementação de interface explícita de um evento deve usar a sintaxe de acessador do evento

'{0}': cannot override; '{1}' is not an event '"{0}": não é possível substituir; "{1}" não é um evento

An add or remove accessor must have a body Um acessador add ou remove deve ter corpo

'{0}': abstract event cannot have initializer '"{0}": evento abstract não pode ter inicializador

The assembly name '{0}' is reserved and cannot be used as a reference in an interactive session O nome do assembly "{0}" é reservado e não pode ser usado como uma referência em uma sessão interativa

The enumerator name '{0}' is reserved and cannot be used O nome de enumerador "{0}" é reservado e não pode ser usado

The as operator must be used with a reference type or nullable type ('{0}' is a non-nullable value type) O operador as deve ser usado com um tipo de referência ou tipo anulável ("{0}" é um tipo de valor não-anulável)

The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity O sufixo 'l' é facilmente confundido com o dígito '1' -- use 'L' para diferenciar

The 'l' suffix is easily confused with the digit '1' O sufixo 'l'é facilmente confundido com o dígito '1'

The event '{0}' can only appear on the left hand side of += or -= O evento "{0}" só pode aparecer no lado esquerdo de += ou -=

Constraints are not allowed on non-generic declarations Não são permitidas restrições em declarações não genéricas

Type parameter declaration must be an identifier not a type A declaração de parâmetro de tipo deve ser um identificador, e não um tipo

Type '{1}' already reserves a member called '{0}' with the same parameter types Tipo "{1}" já reserva um membro chamado "{0}" com os mesmos tipos de parâmetro

The parameter name '{0}' is a duplicate O nome do parâmetro "{0}" é uma duplicata

The namespace '{1}' already contains a definition for '{0}' O namespace "{1}" já contém uma definição para "{0}"

The type '{0}' already contains a definition for '{1}' O tipo "{0}" já contém uma definição para "{1}"

The name '{0}' does not exist in the current context O nome "{0}" não existe no contexto atual

The name '{0}' does not exist in the current context (are you missing a reference to assembly '{1}'?) O nome "{0}" não existe no contexto atual (está sem uma referência para o assembly "{1}"?)

'{0}' is an ambiguous reference between '{1}' and '{2}' '"{0}" é uma referência ambígua entre "{1}" e "{2}"

The using directive for '{0}' appeared previously in this namespace A diretiva using para "{0}" apareceu anteriormente neste namespace

Using directive appeared previously in this namespace Usando diretiva exibida anteriormente neste namespace

The modifier '{0}' is not valid for this item O modificador "{0}" não é válido para este item

More than one protection modifier Mais de um modificador de proteção

'{0}' hides inherited member '{1}'. Use the new keyword if hiding was intended. '"{0}" oculta o membro herdado "{1}". Use a nova palavra-chave se foi pretendido ocultar.

Member hides inherited member; missing new keyword O membro oculta o membro herdado; nova palavra-chave ausente

A variable was declared with the same name as a variable in a base class. However, the new keyword was not used. This warning informs you that you should use new; the variable is declared as if new had been used in the declaration. Uma variável foi declarada com o mesmo nome de uma variável na classe base. No entanto, a nova palavra-chave não foi usada. Este aviso informa que você deve usar um novo; a variável é declarada como se novo tivesse sido usada na declaração.

The member '{0}' does not hide an accessible member. The new keyword is not required. O membro "{0}" não oculta um membro acessível. A palavra-chave new não é necessária.

Member does not hide an inherited member; new keyword is not required O membro não oculta um membro herdado; não é necessária uma nova palavra-chave

The evaluation of the constant value for '{0}' involves a circular definition A avaliação do valor de constante para "{0}" envolve uma definição circular

Type '{1}' already defines a member called '{0}' with the same parameter types Tipo "{1}" já define um membro chamado "{0}" com os mesmos tipos de parâmetro

A static member '{0}' cannot be marked as override, virtual, or abstract Um membro estático "{0}" não pode ser marcado como override, virtual ou abstract

A member '{0}' marked as override cannot be marked as new or virtual Um membro "{0}" marcado como override não pode ser marcado como new ou virtual

'{0}' hides inherited member '{1}'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword. '"{0}" oculta o membro herdado "{1}". Para que o membro atual substitua essa implementação, adicione a palavra-chave override. Caso contrário, adicione a palavra-chave new.

Member hides inherited member; missing override keyword O membro oculta o membro herdado; palavra-chave substituta ausente

'{0}': no suitable method found to override '"{0}": não encontrado nenhum método adequado para substituição

A namespace cannot directly contain members such as fields or methods Um namespace não pode conter diretamente membros, como campos ou métodos

'{0}' does not contain a definition for '{1}' '"{0}" não contém uma definição para "{1}"

'{0}' is a {1} but is used like a {2} '"{0}" é um {1}, mas é usado como um {2}

'{0}' is a {1}, which is not valid in the given context '"{0}" é um {1}, que não é válido no contexto fornecido

An object reference is required for the non-static field, method, or property '{0}' Uma referência de objeto é necessária para o campo, o método ou a propriedade "{0}" não estática

The call is ambiguous between the following methods or properties: '{0}' and '{1}' A chamada é ambígua entre os seguintes métodos ou propriedades: "{0}" e "{1}"

'{0}' is inaccessible due to its protection level '"{0}" é inacessível devido ao seu nível de proteção

No overload for '{0}' matches delegate '{1}' Nenhuma sobrecarga de "{0}" corresponde ao representante "{1}"

An object of a type convertible to '{0}' is required Um objeto de tipo conversível em "{0}" é necessário

Since '{0}' returns void, a return keyword must not be followed by an object expression Como "{0}" retorna void, uma palavra-chave return não deve ser seguida por uma expressão de objeto

A local variable or function named '{0}' is already defined in this scope Uma variável de local ou função denominada '{0}' já está definida neste escopo

The left-hand side of an assignment must be a variable, property or indexer O lado esquerdo de uma atribuição deve ser uma variável, uma propriedade ou um indexador

'{0}': a static constructor must be parameterless '"{0}": um construtor estático não deve ter parâmetros

The expression being assigned to '{0}' must be constant A expressão que está sendo atribuída a "{0}" deve ser constante

'{0}' is of type '{1}'. A const field of a reference type other than string can only be initialized with null. '"{0}" é do tipo "{1}". Um campo const de um tipo de referência diferente de cadeia de caracteres pode somente ser inicializado com null.

A local or parameter named '{0}' cannot be declared in this scope because that name is used in an enclosing local scope to define a local or parameter Um local ou um parâmetro denominado "{0}" não pode ser declarado neste escopo porque esse nome é usado em um escopo delimitador de local para definir um local ou parâmetro

A 'using namespace' directive can only be applied to namespaces; '{0}' is a type not a namespace. Consider a 'using static' directive instead Uma diretiva de 'usando namespace' pode apenas ser aplicada a namespaces; '{0}' é um tipo, não um namespace. Considere uma diretiva 'usando estático'

A 'using static' directive can only be applied to types; '{0}' is a namespace not a type. Consider a 'using namespace' directive instead Uma diretiva de 'usando estático' pode apenas ser aplicada a tipos; '{0}' é um namespace, não um tipo. Considere uma diretiva 'usando namespace'

A 'using static' directive cannot be used to declare an alias Uma diretiva 'usando estático' não pode ser usada para declarar um alias

No enclosing loop out of which to break or continue Nenhum loop delimitador a partir do qual quebrar ou continuar

The label '{0}' is a duplicate O rótulo "{0}" é uma duplicata

The type '{0}' has no constructors defined O tipo "{0}" não tem construtores definidos

Cannot create an instance of the abstract class or interface '{0}' Não é possível criar uma instância da classe abstract ou interface "{0}"

A const field requires a value to be provided O campo const requer um valor a ser fornecido

Circular base class dependency involving '{0}' and '{1}' Dependência de classe base circular envolvendo "{0}" e "{1}"

The delegate '{0}' does not have a valid constructor O representante "{0}" não tem um construtor válido

Method name expected Nome de método esperado

A constant value is expected Um valor constante é esperado

A switch expression or case label must be a bool, char, string, integral, enum, or corresponding nullable type in C# 6 and earlier. Uma expressão de switch ou um rótulo case deve ser um bool, char, cadeia, integral ou um tipo que permite valor nulo correspondente em C# 6 e anterior.

A value of an integral type expected Um valor de tipo integral é esperado

The switch statement contains multiple cases with the label value '{0}' A instrução switch contém vários casos com o valor de rótulo "{0}"

A goto case is only valid inside a switch statement Um goto case só é válido dentro de uma instrução switch

The property or indexer '{0}' cannot be used in this context because it lacks the get accessor A propriedade ou o indexador "{0}" não pode ser usado neste contexto porque não possui o acessador get

The type caught or thrown must be derived from System.Exception O tipo caught ou thrown deve ser derivado de System.Exception

A throw statement with no arguments is not allowed outside of a catch clause Uma instrução throw sem argumentos não é permitida fora de uma cláusula catch

Control cannot leave the body of a finally clause O controle não pode sair do corpo de uma cláusula finally

The label '{0}' shadows another label by the same name in a contained scope O rótulo "{0}" é sombra de outro rótulo com o mesmo nome em um escopo contido

No such label '{0}' within the scope of the goto statement Nenhum rótulo "{0}" dentro do escopo da instrução goto

A previous catch clause already catches all exceptions of this or of a super type ('{0}') Cláusula catch anterior já captura todas as exceções desta ou de um super tipo ("{0}")

Filter expression is a constant 'true', consider removing the filter A expressão de filtro é uma constante ‘true’, considere remover o filtro

Filter expression is a constant 'true' A expressão de filtro é uma constante ‘true’

'{0}': not all code paths return a value '"{0}": nem todos os caminhos de código retornam um valor

Unreachable code detected Código inacessível detectado

Control cannot fall through from one case label ('{0}') to another Controle não pode passar através de um rótulo case ("{0}") para outro

This label has not been referenced Este rótulo não foi usado como referência

Use of unassigned local variable '{0}' Uso de variável local não atribuída "{0}"

The variable '{0}' is declared but never used A variável "{0}" está declarada, mas nunca é usada

Variable is declared but never used A variável foi declarada, mas nunca foi usada

The field '{0}' is never used O campo "{0}" nunca é usado

Field is never used O campo nunca é usado

Use of possibly unassigned field '{0}' Uso de campo possivelmente não atribuído "{0}"

Use of possibly unassigned auto-implemented property '{0}' Uso de propriedades autoimplementadas possivelmente não atribuídas '{0}'

Field '{0}' must be fully assigned before control is returned to the caller Campo "{0}" deve ser totalmente atribuído antes que o controle seja retornado ao chamador

Type of conditional expression cannot be determined because '{0}' and '{1}' implicitly convert to one another Tipo de expressão condicional não pode ser determinado porque "{0}" e "{1}" se convertem implicitamente um no outro

Type of conditional expression cannot be determined because there is no implicit conversion between '{0}' and '{1}' Tipo de expressão condicional não pode ser determinado porque não há conversão implícita entre "{0}" e "{1}"

A base class is required for a 'base' reference Uma classe base é necessária para uma referência "base"

Use of keyword 'base' is not valid in this context O uso da palavra-chave "base" não é válido neste contexto

Member '{0}' cannot be accessed with an instance reference; qualify it with a type name instead O membro "{0}" não pode ser acessado com uma referência de instância; qualifique-o com um nome de tipo

The out parameter '{0}' must be assigned to before control leaves the current method O parâmetro out "{0}" deve ser atribuído antes que o controle saia do método atual

Invalid rank specifier: expected ',' or ']' Especificador de classificação inválido: era esperado "," ou "]"

'{0}' cannot be extern and declare a body '"{0}" não pode ser externo e declarar um corpo

'{0}' cannot be extern and have a constructor initializer '{0}' não pode ser externo e possui um inicializador de construtor

'{0}' cannot be both extern and abstract '"{0}" não pode ser extern e abstract

Attribute constructor parameter '{0}' has type '{1}', which is not a valid attribute parameter type Parâmetro de construtor de atributo "{0}" tem tipo "{1}", o qual não é um tipo de parâmetro de atributo válido

An attribute argument must be a constant expression, typeof expression or array creation expression of an attribute parameter type Um argumento attribute deve ser uma expressão constant, typeof ou array creation de um tipo de parâmetro attribute

Attribute constructor parameter '{0}' is optional, but no default parameter value was specified. Parâmetro de construtor de atributo "{0}" é opcional, mas nenhum valor de parâmetro padrão foi especificado.

The given expression is always of the provided ('{0}') type A expressão fornecida sempre é do tipo ("{0}") fornecido

'is' expression's given expression is always of the provided type 'A expressão 'is' determinada sempre é do tipo fornecido

The given expression is never of the provided ('{0}') type A expressão fornecida nunca é do ("{0}") tipo fornecido

'is' expression's given expression is never of the provided type 'A expressão 'is' determinada nunca é do tipo fornecido

'{0}' is not a reference type as required by the lock statement '"{0}" não é um tipo de referência como necessário pela instrução lock

Use of null is not valid in this context O uso de null não é válido neste contexto

Use of default literal is not valid in this context O uso do literal padrão não é válido neste contexto

The 'this' object cannot be used before all of its fields are assigned to O objeto 'this' não pode ser usado antes que todos os seus campos sejam atribuídos a

The __arglist construct is valid only within a variable argument method O construtor __arglist só é válido dentro de um método de argumento variável

The * or -> operator must be applied to a pointer O operador * ou -> deve ser aplicado a um ponteiro

A pointer must be indexed by only one value Um ponteiro deve ser indexado somente por um valor

Using '{0}' as a ref or out value or taking its address may cause a runtime exception because it is a field of a marshal-by-reference class Usar '{0}' como um valor ref ou out ou obter seu endereço pode gerar uma exceção de tempo de execução porque ele é um campo de uma classe mashal por referência

Using a field of a marshal-by-reference class as a ref or out value or taking its address may cause a runtime exception Usar um campo de uma classe marshal por referência como um valor ref ou out ou obter seu endereço pode gerar uma exceção de tempo de execução

A static readonly field cannot be assigned to (except in a static constructor or a variable initializer) Um campo somente leitura estático não pode ser atribuído (exceto em um construtor estático ou inicializador de variável)

A static readonly field cannot be used as a ref or out value (except in a static constructor) Um campo somente leitura estático não pode ser usado como um valor ref ou out (exceto em um construtor estático)

Property or indexer '{0}' cannot be assigned to -- it is read only A propriedade ou o indexador "{0}" não pode ser atribuído, pois é somente leitura

Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement Somente as expressões de atribuição, chamada, incremento, diminuição, espera e novo objeto podem ser utilizadas como uma instrução

foreach requires that the return type '{0}' of '{1}' must have a suitable public 'MoveNext' method and public 'Current' property foreach requer que o tipo de retorno '{0}' de '{1}' tenha um método 'MoveNext' público adequado e a propriedade 'Current' pública

Only 65534 locals, including those generated by the compiler, are allowed São permitidos somente 65534 locais, incluindo os gerados pelo compilador

Cannot call an abstract base member: '{0}' Não é possível chamar o membro de base abstrata: '{0}'

A property or indexer may not be passed as an out or ref parameter Talvez uma propriedade ou um indexador não possa ser passado como um parâmetro out ou ref

Cannot take the address of, get the size of, or declare a pointer to a managed type ('{0}') Não é possível obter o endereço, obter o tamanho ou declarar um ponteiro para um tipo gerenciado ("{0}")

The type of a local declared in a fixed statement must be a pointer type O tipo de um local declarado em uma instrução fixed deve ser um tipo de ponteiro

You must provide an initializer in a fixed or using statement declaration Forneça um inicializador em uma declaração de instrução fixed ou using

Cannot take the address of the given expression Não é possível obter o endereço da expressão especificada

You can only take the address of an unfixed expression inside of a fixed statement initializer Só é possível obter o endereço de uma expressão unfixed dentro de um inicializador de instrução fixed

You cannot use the fixed statement to take the address of an already fixed expression A instrução fixed não pode ser usada para obter o endereço de uma expressão fixed

Pointers and fixed size buffers may only be used in an unsafe context Ponteiros e buffers de tamanho fixo só podem ser usados em um contexto sem segurança

The return type of operator True or False must be bool O tipo de retorno do operador True ou False deve ser bool

The operator '{0}' requires a matching operator '{1}' to also be defined O operador "{0}" requer que um operador correspondente "{1}" também seja definido

In order to be applicable as a short circuit operator a user-defined logical operator ('{0}') must have the same return type and parameter types Para ser aplicável como um operador de circuito pequeno, um operador lógico definido pelo usuário ("{0}") deve ter o mesmo tipo de retorno e tipos de parâmetro

In order for '{0}' to be applicable as a short circuit operator, its declaring type '{1}' must define operator true and operator false Para que "{0}" seja aplicável como um operador de circuito pequeno, seu tipo declarativo "{1}" deve definir o operador verdadeiro e operador falso

The variable '{0}' is assigned but its value is never used A variável "{0}" é atribuída, mas seu valor nunca é usado

Variable is assigned but its value is never used A variável é atribuída, mas seu valor nunca é usado

The operation overflows at compile time in checked mode A operação estoura o tempo de compilação no modo de ativação

Constant value '{0}' cannot be converted to a '{1}' (use 'unchecked' syntax to override) O valor de constante "{0}" não pode ser convertido em "{1}" (use a sintaxe "unchecked" para substituir)

A method with vararg cannot be generic, be in a generic type, or have a params parameter Um método com vararg não pode ser genérico, estar em um tipo genérico ou ter um parâmetro params

The params parameter must be a single dimensional array O parâmetro params deve ser uma matriz dimensional única

An __arglist expression may only appear inside of a call or new expression A expressão __arglist só pode aparecer dentro de uma expressão de chamada ou expressão new

Unsafe code may only appear if compiling with /unsafe Um código sem segurança só pode aparecer se a compilação for com /unsafe

Ambiguity between '{0}' and '{1}' Ambiguidade entre "{0}" e "{1}"

Type and identifier are both required in a foreach statement Um tipo e um identificador são necessários em uma instrução foreach

A params parameter must be the last parameter in a formal parameter list Um parâmetro params deve ser o último parâmetro na lista de parâmetros formal

'{0}' does not have a predefined size, therefore sizeof can only be used in an unsafe context '"{0}" não tem um tamanho pré-definido; portanto, sizeof só pode ser usado em um contexto desprotegido (considere o uso de System.Runtime.InteropServices.Marshal.SizeOf)

The type or namespace name '{0}' does not exist in the namespace '{1}' (are you missing an assembly reference?) O nome de tipo ou namespace "{0}" não existe no namespace "{1}" (você está sem uma referência de assembly?)

A field initializer cannot reference the non-static field, method, or property '{0}' Um inicializador de campo não pode referenciar o campo, o método ou a propriedade não estática "{0}"

'{0}' cannot be sealed because it is not an override '"{0}" não pode ser sealed porque não é uma substituição

'{0}': cannot override inherited member '{1}' because it is sealed '"{0}": não é possível substituir o membro herdado "{1}" porque ele é sealed

The operation in question is undefined on void pointers A operação em questão não está definida nos ponteiros void

The Conditional attribute is not valid on '{0}' because it is an override method O atributo Conditional não é válido em "{0}" porque é um método override

Neither 'is' nor 'as' is valid on pointer types is' e 'as' não são válidos em tipos de ponteiro

Destructors and object.Finalize cannot be called directly. Consider calling IDisposable.Dispose if available. Destruidores e object.Finalize não podem ser chamados diretamente. Chame IDisposable.Dispose, se disponível.

The type or namespace name '{0}' could not be found (are you missing a using directive or an assembly reference?) O nome do tipo ou do namespace "{0}" não pode ser encontrado (está faltando uma diretiva using ou uma referência de assembly?)

Cannot use a negative size with stackalloc Não é possível usar um tamanho negativo com stackalloc

Cannot create an array with a negative size Não é possível criar uma matriz com um tamanho negativo

Do not override object.Finalize. Instead, provide a destructor. Em vez de substituir object.Finalize, forneça um destruidor.

Do not directly call your base class Finalize method. It is called automatically from your destructor. Não chame diretamente o método Finalize de classe base. Ele é chamado automaticamente do destruidor.

Indexing an array with a negative index (array indices always start at zero) Indexando uma matriz com um índice negativo. (Índices de matriz sempre começam em zero)

Indexing an array with a negative index Indexando uma matriz com um índice negativo

Possible unintended reference comparison; to get a value comparison, cast the left hand side to type '{0}' Comparação de referência não intencional possível; para obter uma comparação de valor, converta o lado esquerdo para o tipo "{0}"

Possible unintended reference comparison; left hand side needs cast Possível comparação de referência inesperada; o lado esquerdo precisa de conversão

Possible unintended reference comparison; to get a value comparison, cast the right hand side to type '{0}' Comparação de referência não intencional possível; para obter uma comparação de valor, converta o lado direito no tipo "{0}"

Possible unintended reference comparison; right hand side needs cast Possível comparação de referência inesperada; o lado direito precisa de conversão

The right hand side of a fixed statement assignment may not be a cast expression É possível que o lado direito de uma atribuição de instrução fixed não seja uma expressão de conversão

stackalloc may not be used in a catch or finally block stackalloc não pode ser usado em um bloco catch ou finally

An __arglist parameter must be the last parameter in a formal parameter list Um parâmetro __arglist deve ser o último em uma lista formal de parâmetros

Missing partial modifier on declaration of type '{0}'; another partial declaration of this type exists Modificador parcial ausente na declaração do tipo "{0}"; existe outra declaração parcial deste tipo

Partial declarations of '{0}' must be all classes, all structs, or all interfaces Declarações parciais de "{0}" devem ser todas classes, todas as estruturas ou todas as interfaces

Partial declarations of '{0}' have conflicting accessibility modifiers Declarações parciais de "{0}" têm modificadores de acessibilidade conflitantes

Partial declarations of '{0}' must not specify different base classes Declarações parciais de "{0}" não devem especificar classes base diferentes

Partial declarations of '{0}' must have the same type parameter names in the same order Declarações parciais de "{0}" devem ter os mesmos nomes de parâmetro de tipo na mesma ordem

Partial declarations of '{0}' have inconsistent constraints for type parameter '{1}' Declarações parciais de "{0}" têm restrições inconsistentes para o parâmetro de tipo "{1}"

Cannot implicitly convert type '{0}' to '{1}'. An explicit conversion exists (are you missing a cast?) Não é possível converter implicitamente tipo "{0}" em "{1}". Existe uma conversão explícita (há uma conversão ausente?)

The 'partial' modifier can only appear immediately before 'class', 'struct', 'interface', or 'void' O modificador 'partial' só pode aparecer imediatamente antes de 'class', 'struct', 'interface' ou 'void'

Imported type '{0}' is invalid. It contains a circular base class dependency. Tipo importado "{0}" é inválido. Ele contém uma dependência de classe de base circular.

Use of unassigned out parameter '{0}' Uso do parâmetro out não atribuído "{0}"

Array size cannot be specified in a variable declaration (try initializing with a 'new' expression) O tamanho de matriz não pode ser especificado em uma declaração de variável (tente inicializar com uma expressão 'new')

The property or indexer '{0}' cannot be used in this context because the get accessor is inaccessible A propriedade ou o indexador "{0}" não pode ser usado neste contexto porque o acessador get é inacessível

The property or indexer '{0}' cannot be used in this context because the set accessor is inaccessible A propriedade ou o indexador "{0}" não pode ser usado neste contexto porque o acessador set é inacessível

The accessibility modifier of the '{0}' accessor must be more restrictive than the property or indexer '{1}' O modificador de acessibilidade do "{0}" acessador deve ser mais restritivo que a propriedade ou o indexador "{1}"

Cannot specify accessibility modifiers for both accessors of the property or indexer '{0}' Não é possível especificar modificadores de acessibilidade para os acessores da propriedade ou indexador "{0}"

'{0}': accessibility modifiers may not be used on accessors in an interface '"{0}": modificadores de acessibilidade não podem ser usados em aceessadores em uma interface

'{0}': accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor '"{0}": modificadores de acessibilidade nos assessores podem somente ser usados se a propriedade ou o indexador tiver um acessador get e um accessador set

'{0}' does not implement interface member '{1}'. '{2}' is not public. '"{0}" não implementa membro de interface "{1}". "{2}" não é público.

'{0}' does not implement the '{1}' pattern. '{2}' is ambiguous with '{3}'. '"{0}" não implementa o padrão "{1}". "{2}" é ambíguo com "{3}".

Type does not implement the collection pattern; members are ambiguous O tipo não implementa o padrão de coleção; os membros são ambíguos

'{0}' does not implement the '{1}' pattern. '{2}' is either static or not public. '"{0}" não implementa o padrão "{1}". "{2}" é estático ou não público.

Type does not implement the collection pattern; member is either static or not public O tipo não implementa o padrão de coleção; o membro é estático ou não é público

'{0}' does not implement the '{1}' pattern. '{2}' has the wrong signature. '"{0}" não implementa o padrão "{1}". "{2}" tem a assinatura errada.

Type does not implement the collection pattern; member has the wrong signature O tipo não implementa o padrão de coleção; o membro possui a assinatura incorreta

Friend access was granted by '{0}', but the public key of the output assembly ('{1}') does not match that specified by the InternalsVisibleTo attribute in the granting assembly. O acesso Friend foi concedido por '{0}', mas a chave pública do assembly de saída ('{1}') não corresponde àquela especificada pelo atributo InternalsVisibleTo no assembly de concessão.

Friend access was granted by '{0}', but the strong name signing state of the output assembly does not match that of the granting assembly. O acesso Friend foi concedido por "{0}", mas o estado de assinatura de nome forte do assembly de saída não corresponde àquele do assembly de concessão.

There is no defined ordering between fields in multiple declarations of partial struct '{0}'. To specify an ordering, all instance fields must be in the same declaration. Não há ordenação definida entre os campos em várias declarações de estrutura partial "{0}". Para especificar uma ordenação, todos os campos de instância devem estar na mesma declaração.

There is no defined ordering between fields in multiple declarations of partial struct Não há nenhuma ordem definida entre os campos em várias declarações de estrutura parcial

The type '{0}' cannot be declared const O tipo "{0}" não pode ser declarado const

Cannot create an instance of the variable type '{0}' because it does not have the new() constraint Não é possível criar uma instância do tipo de variável "{0}" porque ela não tem a restrição new()

Using the generic {1} '{0}' requires {2} type arguments Usar o genérico {1} "{0}" requer {2} argumentos de tipo

The type '{0}' may not be used as a type argument O tipo "{0}" não pode ser usado como um argumento de tipo

The {1} '{0}' cannot be used with type arguments O {1} "{0}" não pode ser usado com argumentos de tipo

The non-generic {1} '{0}' cannot be used with type arguments O {1} não genérico "{0}" não pode ser usado como argumentos de tipo

'{2}' must be a non-abstract type with a public parameterless constructor in order to use it as parameter '{1}' in the generic type or method '{0}' '"{2}" deve ser um tipo non-abstract com um construtor público sem-parâmetros para que possa ser usado como parâmetro "{1}" no tipo ou método genérico "{0}"

The type '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. There is no implicit reference conversion from '{3}' to '{1}'. O tipo "{3}" não pode ser usado como parâmetro de tipo "{2}" no tipo ou método genérico "{0}". Não há conversão de referência implícita de "{3}" em "{1}".

The type '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The nullable type '{3}' does not satisfy the constraint of '{1}'. O tipo "{3}" não pode ser usado como parâmetro de tipo "{2}" no tipo ou método genérico "{0}". O tipo "{3}" que permite valores nulos não satisfaz a restrição de "{1}".

The type '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. The nullable type '{3}' does not satisfy the constraint of '{1}'. Nullable types can not satisfy any interface constraints. O tipo "{3}" não pode ser usado como parâmetro de tipo "{2}" no tipo ou método genérico "{0}". O tipo "{3}" que permite valores nulos não satisfaz a restrição de "{1}". Os tipos que permitem valores nulos não satisfazem as restrições de interface.

The type '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. There is no boxing conversion or type parameter conversion from '{3}' to '{1}'. O tipo "{3}" não pode ser usado como parâmetro de tipo "{2}" no tipo ou método genérico "{0}". Não há conversão boxing ou conversão de parâmetro de tipo de "{3}" em "{1}".

The type '{3}' cannot be used as type parameter '{2}' in the generic type or method '{0}'. There is no boxing conversion from '{3}' to '{1}'. O tipo "{3}" não pode ser usado como parâmetro de tipo "{2}" no tipo ou método genérico "{0}". Não há conversão boxing de "{3}" em "{1}".

The parameter name '{0}' conflicts with an automatically-generated parameter name O nome de parâmetro "{0}" está em conflito com um nome de parâmetro gerado automaticamente

The type or namespace name '{0}' could not be found in the global namespace (are you missing an assembly reference?) O tipo ou nome do namespace "{0}" não pode ser encontrado no namespace global (uma referência de assembly está faltando?)

The new() constraint must be the last constraint specified A restrição new() deve ser a última especificada

'{0}': an entry point cannot be generic or in a generic type '"{0}": um ponto de entrada não pode ser genérico ou estar em um tipo genérico

An entry point cannot be generic or in a generic type Um ponto de entrada não pode ser genérico ou estar em um tipo genérico

Cannot convert null to type parameter '{0}' because it could be a non-nullable value type. Consider using 'default({0})' instead. Não é possível converter um valor nulo no parâmetro de tipo "{0}" porque ele poderia ser um tipo de valor não nulo. É recomendável o uso de "default({0})".

Cannot apply attribute class '{0}' because it is generic Não é possível aplicar classe de atributo "{0}" porque ela é genérica

Duplicate constraint '{0}' for type parameter '{1}' Duplicar restrição "{0}" para o parâmetro de tipo "{1}"

The class type constraint '{0}' must come before any other constraints A restrição de tipo de classe "{0}" deve vir antes de qualquer outra restrição

'{1} {0}' has the wrong return type '"{1} {0}" tem o tipo de retorno incorreto

Ref mismatch between '{0}' and delegate '{1}' Incompatibilidade de referência entre '{0}' e o delegado '{1}'

A constraint clause has already been specified for type parameter '{0}'. All of the constraints for a type parameter must be specified in a single where clause. Uma cláusula de restrição já foi especificada para parâmetro de tipo "{0}". Todas as restrições de parâmetro de tipo devem ser especificadas em uma única cláusula where.

The type arguments for method '{0}' cannot be inferred from the usage. Try specifying the type arguments explicitly. Os argumentos de tipo do método "{0}" não podem ser inferidos com base no uso. Tente especificar explicitamente os argumentos de tipo.

'{0}': a parameter, local variable, or local function cannot have the same name as a method type parameter '{0}': um parâmetro, variável de local ou função de local não pode ter o mesmo nome que um parâmetro de tipo de método

The type parameter '{0}' cannot be used with the 'as' operator because it does not have a class type constraint nor a 'class' constraint O parâmetro do tipo "{0}" não pode ser usado com o operador "as" porque não tem uma restrição de tipo de classe nem uma restrição "class"

The field '{0}' is assigned but its value is never used O campo "{0}" é atribuído, mas seu valor nunca é usado

Field is assigned but its value is never used O campo é atribuído, mas seu valor nunca é usado

The '{0}' attribute is valid only on an indexer that is not an explicit interface member declaration O "{0}" atributo é válido somente em um indexador que não seja uma declaração de membro de interface explícita

'{0}': an attribute argument cannot use type parameters '"{0}": um argumento de atributo não pode usar parâmetros de tipo

'{0}': cannot provide arguments when creating an instance of a variable type '"{0}": não é possível fornecer argumentos ao criar uma instância de um tipo de variável

'{0}': an abstract class cannot be sealed or static '"{0}": uma classe abstract não pode ser sealed ou static

Ambiguous reference in cref attribute: '{0}'. Assuming '{1}', but could have also matched other overloads including '{2}'. Referência ambígua no atributo cref: "{0}". Supondo "{1}", mas também poderia ter correspondido a outras sobrecargas, incluindo "{2}".

Ambiguous reference in cref attribute Referência ambígua no atributo cref

'{0}': a reference to a volatile field will not be treated as volatile '"{0}": uma referência a um campo volátil não será tratada como volátil

A reference to a volatile field will not be treated as volatile Uma referência a um campo volátil não será tratada como volátil

A volatile field should not normally be used as a ref or out value, since it will not be treated as volatile. There are exceptions to this, such as when calling an interlocked API. Um campo volátil não deve normalmente ser usado como um valor ref ou out, uma vez que ele não é tratado como volátil. Há exceções, como ao chamar uma API interligada.

Since '{1}' has the ComImport attribute, '{0}' must be extern or abstract Como "{1}" tem o atributo ComImport, "{0}" deve ser extern ou abstract

'{0}': a class with the ComImport attribute cannot specify a base class '"{0}": uma classe com o atributo ComImport não pode especificar uma classe básica

The constraints for type parameter '{0}' of method '{1}' must match the constraints for type parameter '{2}' of interface method '{3}'. Consider using an explicit interface implementation instead. As restrições para parâmetro de tipo "{0}" do método "{1}" deve coincidir com as restrições para o parâmetro de tipo "{2}" do método de interface "{3}". Ao invés disso, considere usar uma implementação de interface explícita.

The tuple element names in the signature of method '{0}' must match the tuple element names of interface method '{1}' (including on the return type). Os nomes de elemento de tupla na assinatura do método '{0}' devem corresponder aos nomes de elemento de tupla do método de interface '{1}' (incluindo o tipo de retorno).

The type name '{0}' does not exist in the type '{1}' O nome de tipo "{0}" não existe no tipo "{1}"

Cannot convert method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method? Não é possível converter o grupo de métodos "{0}" no tipo "{1}" não delegado. Você pretendia invocar o método?

The extern alias '{0}' was not specified in a /reference option O alias extern "{0}" não foi especificado em uma opção /reference

Cannot use alias '{0}' with '::' since the alias references a type. Use '.' instead. Não é possível usar o alias "{0}" com "::" porque o alias faz referência a um tipo. Ao invés disso, use ".".

Alias '{0}' not found Alias "{0}" não encontrado

The type '{1}' exists in both '{0}' and '{2}' O tipo "{1}" existe em "{0}" e "{2}"

The namespace '{1}' in '{0}' conflicts with the type '{3}' in '{2}' O namespace "{1}" em "{0}" está em conflito com o tipo "{3}" em "{2}"

The namespace '{1}' in '{0}' conflicts with the imported type '{3}' in '{2}'. Using the namespace defined in '{0}'. O namespace "{1}" em "{0}" está em conflito com o tipo importado "{3}" em "{2}". Usar o namespace definido em "{0}".

Namespace conflicts with imported type Conflitos de namespace com o tipo importado

The type '{1}' in '{0}' conflicts with the imported type '{3}' in '{2}'. Using the type defined in '{0}'. O tipo "{1}" em "{0}" está em conflito com o tipo importado "{3}" em "{2}". Usar o tipo definido em "{0}".

Type conflicts with imported type Conflitos de tipo com o tipo importado

The type '{1}' in '{0}' conflicts with the imported namespace '{3}' in '{2}'. Using the type defined in '{0}'. O tipo "{1}" em "{0}" está em conflito com o namespace importado "{3}" em "{2}". Usar o tipo definido em "{0}".

Type conflicts with imported namespace Conflitos de tipo com o namespace importado

The type '{1}' in '{0}' conflicts with the namespace '{3}' in '{2}' O tipo "{1}" em "{0}" está em conflito com o namespace "{3}" em "{2}"

An extern alias declaration must precede all other elements defined in the namespace Uma declaração de alias externa deve preceder todos os outros elementos definidos no namespace

Defining an alias named 'global' is ill-advised since 'global::' always references the global namespace and not an alias A definição de um alias denominado 'global' não é recomendável, pois 'global::' sempre faz referência ao namespace global, e não a um alias

Defining an alias named 'global' is ill-advised Não é recomendável definir um alias denominado 'global'

'{0}': a class cannot be both static and sealed '"{0}": uma classe não pode ser static e sealed

'{0}': abstract properties cannot have private accessors '"{0}": propriedades abstratas não podem ter acessadores particulares

Syntax error; value expected Erro de sintaxe, valor esperado

Cannot modify the result of an unboxing conversion Não é possível modificar o resultado de uma conversão unboxing

Foreach cannot operate on a '{0}'. Did you intend to invoke the '{0}'? Foreach não pode operar em um "{0}". Você pretendia invocar o "{0}"?

The return type for ++ or -- operator must match the parameter type or be derived from the parameter type O tipo de retorno para o operador ++ ou -- deve corresponder ao tipo de parâmetro ou ser derivado do tipo de parâmetro

The 'class' or 'struct' constraint must come before any other constraints A restrição 'class' ou 'struct' deve vir antes de qualquer outra restrição

'{0}': cannot specify both a constraint class and the 'class' or 'struct' constraint '"{0}": não é possível especificar uma classe de restrição e a restrição "class" ou "struct"

The 'new()' constraint cannot be used with the 'struct' constraint A restrição 'new()' não pode ser usada com a restrição 'struct'

The type '{2}' must be a reference type in order to use it as parameter '{1}' in the generic type or method '{0}' O tipo "{2}" deve ser um tipo de referência para que seja usado como parâmetro "{1}" no tipo ou método genérico "{0}"

The type '{2}' must be a non-nullable value type in order to use it as parameter '{1}' in the generic type or method '{0}' O tipo "{2}" deve ser um tipo de valor não nulo para que seja usado como parâmetro "{1}" no tipo ou método genérico "{0}"

Circular constraint dependency involving '{0}' and '{1}' Dependência de restrição circular envolvendo "{0}" e "{1}"

Type parameter '{0}' inherits conflicting constraints '{1}' and '{2}' O parâmetro de tipo "{0}" herda as restrições conflitantes "{1}" e "{2}"

Type parameter '{1}' has the 'struct' constraint so '{1}' cannot be used as a constraint for '{0}' O parâmetro de tipo "{1}" tem a restrição "struct" e, por isso, "{1}" não pode ser usado como uma restrição de "{0}"

Ambiguous user defined conversions '{0}' and '{1}' when converting from '{2}' to '{3}' Conversões ambíguas definidas por usuário "{0}" e "{1}" ao realizar a conversão de "{2}" em "{3}"

The result of the expression is always 'null' of type '{0}' O resultado da expressão sempre é "null" do tipo "{0}"

The result of the expression is always 'null' O resultado da expressão é sempre 'null'

Cannot return 'this' by reference. Não é possível retornar 'this' por referência.

Cannot use attribute constructor '{0}' because it is has 'in' parameters. Não é possível atribuir o construtor ‘{0}’ porque ele tem parâmetros ‘in’.

Constraints for override and explicit interface implementation methods are inherited from the base method, so they cannot be specified directly Restrições para métodos de substituição e implementação de interface explícita são herdadas do método base, por isso não podem ser especificadas diretamente

The inherited members '{0}' and '{1}' have the same signature in type '{2}', so they cannot be overridden Os membros herdados "{0}" e "{1}" têm a mesma assinatura no tipo "{2}", portanto, eles não podem ser substituídos

Evaluation of the decimal constant expression failed Falha na avaliação da expressão decimal constante

Comparing with null of type '{0}' always produces 'false' Comparação com null do tipo "{0}" sempre produz "false"

Comparing with null of struct type always produces 'false' Comparação com nulo do tipo struct sempre produz 'false'

Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor? A introdução de um método 'Finalize' pode interferir na invocação do destruidor. Você pretendia declarar um destruidor?

Introducing a 'Finalize' method can interfere with destructor invocation Apresentar um método 'Finalize' pode interferir na invocação do destruidor

This warning occurs when you create a class with a method whose signature is public virtual void Finalize. If such a class is used as a base class and if the deriving class defines a destructor, the destructor will override the base class Finalize method, not Finalize. Este aviso ocorre quando você cria uma classe com um método cuja assinatura é o vazio virtual Finalize público. Se tal classe for usada como uma classe base e se a classe derivada definir um destruidor, o destruidor substituirá o método Finalize da classe básica, não o Finalize.

'{0}' should not have a params parameter since '{1}' does not '"{0}" não deve ter um parâmetro params porque "{1}" não tem um

The 'goto case' value is not implicitly convertible to type '{0}' O valor "goto case" não é implicitamente conversível para o tipo "{0}"

The 'goto case' value is not implicitly convertible to the switch type O valor 'goto case' não é implicitamente conversível para o tipo da opção

Method '{0}' cannot implement interface accessor '{1}' for type '{2}'. Use an explicit interface implementation. Método "{0}" não pode implementar o acessador de interface "{1}" para o tipo "{2}". Use uma implementação de interface explícita.

The result of the expression is always '{0}' since a value of type '{1}' is never equal to 'null' of type '{2}' O resultado da expressão é sempre '{0}', pois um valor do tipo '{1}' nunca é igual a "null" do tipo '{2}'

The result of the expression is always the same since a value of this type is never equal to 'null' O resultado da expressão é sempre o mesmo, pois um valor deste tipo nunca é 'null'

Explicit interface implementation '{0}' matches more than one interface member. Which interface member is actually chosen is implementation-dependent. Consider using a non-explicit implementation instead. Implementação de interface explícita "{0}" corresponde a mais de um membro de interface. Qual membro de interface é na verdade escolhido é dependente de implementação. Ao invés, considere o uso de uma implementação não explícita.

Explicit interface implementation matches more than one interface member A implementação de interface explícita corresponde a mais de um membro de interface

'{0}' cannot declare a body because it is marked abstract '"{0}" não pode declarar um corpo porque não está marcado como abstract

'{0}' must declare a body because it is not marked abstract, extern, or partial '"{0}" deve declarar um corpo porque não está marcado como abstract, extern ou partial

'{0}' cannot be both abstract and sealed '"{0}" não pode ser ambos abstract e sealed

The abstract {0} '{1}' cannot be marked virtual O abstract {0} '{1}' não pode ser marcado como virtual

The constant '{0}' cannot be marked static A constante "{0}" não pode ser marcada como static

'{0}': cannot override because '{1}' is not a function '"{0}": não é possível substituir porque "{1}" não é uma função

'{0}': cannot override inherited member '{1}' because it is not marked virtual, abstract, or override '"{0}": não é possível substituir o membro herdado "{1}" porque ele não está marcado como virtual, abstract ou override

'{0}': cannot change access modifiers when overriding '{1}' inherited member '{2}' '"{0}": não é possível alterar modificadores de acesso ao substituir "{1}" membro herdado "{2}"

'{0}': cannot change tuple element names when overriding inherited member '{1}' '{0}': não pode alterar os nomes de elemento de tupla ao substituir o membro herdado '{1}'

'{0}': return type must be '{2}' to match overridden member '{1}' '"{0}": tipo de retorno deve ser "{2}" para corresponder ao membro substituído "{1}"

'{0}': cannot derive from sealed type '{1}' '"{0}": não é possível derivar do tipo sealed "{1}"

'{0}' is abstract but it is contained in non-abstract class '{1}' '"{0}" é abstract, mas está contido na classe non-abstract "{1}"

'{0}': static constructor cannot have an explicit 'this' or 'base' constructor call '"{0}": construtor estático não pode ter uma chamada de construtor "this" ou "base" explícita

'{0}': access modifiers are not allowed on static constructors '"{0}": modificadores de acesso não são permitidos em construtores estáticos

Constructor '{0}' cannot call itself Construtor "{0}" não pode chamar a si mesmo

Constructor '{0}' cannot call itself through another constructor O construtor '{0}' não pode chamar a si mesmo por meio de outro construtor

'{0}' has no base class and cannot call a base constructor '"{0}" não tem classe base e não pode chamar um construtor base

Predefined type '{0}' is not defined or imported O tipo pré-definido "{0}" não foi definido ou importado

Predefined type '{0}' is declared in multiple referenced assemblies: '{1}' and '{2}' O tipo predefinido ‘{0}’ é declarado em vários assemblies referenciados: ‘{1}’ e ‘{2}’

'{0}': structs cannot call base class constructors '"{0}": structs não podem chamar construtores de classe base

Struct member '{0}' of type '{1}' causes a cycle in the struct layout Membro struct "{0}" do tipo "{1}" gera um ciclo no layout de struct

'{0}': interfaces cannot declare types '"{0}": interfaces não podem declarar tipos

Interfaces cannot contain fields Interfaces não podem conter campos

Interfaces cannot contain constructors Interfaces não podem conter construtores

Type '{0}' in interface list is not an interface Tipo "{0}" na lista de interfaces não é uma interface

'{0}' is already listed in interface list '"{0}" já está listado na lista de interfaces

'{0}' is already listed in the interface list on type '{2}' with different tuple element names, as '{1}'. '{0}' já está listado na lista de interface no tipo '{2}' com nomes de elemento de tupla diferentes, como '{1}'.

Inherited interface '{1}' causes a cycle in the interface hierarchy of '{0}' Interface herdada "{1}" gera um ciclo na hierarquia de interface de "{0}"

'{0}': interface members cannot have a definition '"{0}": membros de interface não podem ter uma definição

'{0}' hides inherited abstract member '{1}' '"{0}" oculta membro abstrato herdado "{1}"

'{0}' does not implement inherited abstract member '{1}' '"{0}" não implementa membro abstrato herdado "{1}"

'{0}' does not implement interface member '{1}' '"{0}" não implementa membro de interface "{1}"

The class System.Object cannot have a base class or implement an interface Classe System.Object não pode ter uma classe base nem implementar uma interface

'{0}' in explicit interface declaration is not an interface '"{0}" na declaração de interface explícita não é uma interface

'{0}' in explicit interface declaration is not a member of interface '"{0}" na declaração de interface explícita não é um membro de interface

'{0}': containing type does not implement interface '{1}' '"{0}": tipo recipiente não implementa interface "{1}"

'{0}': explicit interface declaration can only be declared in a class or struct '"{0}": declaração de interface explícita pode somente ser declarada em uma classe ou estrutura

'{0}': member names cannot be the same as their enclosing type '"{0}": nomes de membro não podem ser os mesmos do seu tipo delimitador

'{0}': the enumerator value is too large to fit in its type '"{0}": o valor do enumerador é muito grande para se ajustar ao seu tipo

'{0}': cannot override because '{1}' is not a property '"{0}": não é possível substituir porque "{1}" não é uma propriedade

'{0}': cannot override because '{1}' does not have an overridable get accessor '"{0}": não pode substituir porque "{1}" não tem um acessador get substituível

'{0}': cannot override because '{1}' does not have an overridable set accessor '"{0}": não pode substituir porque "{1}" não tem um acessador set substituível

'{0}': property or indexer cannot have void type '"{0}": propriedade ou indexador não pode ter tipo void

'{0}': property or indexer must have at least one accessor '"{0}": propriedade ou indexador deve ter no mínimo um acessador

'{0}' is a new virtual member in sealed class '{1}' '"{0}" é um novo membro virtual na classe sealed "{1}"

'{0}' adds an accessor not found in interface member '{1}' '"{0}" adiciona um assessor não encontrado no membro de interface "{1}"

Explicit interface implementation '{0}' is missing accessor '{1}' Implementação de interface explícita "{0}" está sem o acessador "{1}"

'{0}': user-defined conversions to or from an interface are not allowed '"{0}": conversões definidas pelo usuário para ou de uma interface não são permitidas

'{0}': user-defined conversions to or from a base class are not allowed '"{0}": conversões definidas pelo usuário para ou de uma classe básica não são permitidas

'{0}': user-defined conversions to or from a derived class are not allowed '"{0}": conversões definidas pelo usuário para ou de uma classe derivada não são permitidas

User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type O operador definido pelo usuário não pode obter um objeto do tipo delimitador e se converter em um objeto do tipo delimitador

User-defined conversion must convert to or from the enclosing type A conversão definida pelo usuário deve ser convertida a partir de ou em um tipo de delimitador

Duplicate user-defined conversion in type '{0}' Duplicar convenção definida pelo usuário no tipo "{0}"

User-defined operator '{0}' must be declared static and public O operador definido pelo usuário "{0}" deve ser declarado como static e public

The parameter type for ++ or -- operator must be the containing type O tipo de parâmetro para o operador ++ ou -- deve ser do tipo recipiente

The parameter of a unary operator must be the containing type O parâmetro de um operador unário deve ser do tipo recipiente

One of the parameters of a binary operator must be the containing type Um dos parâmetros de um operador binário deve ser do tipo recipiente

The first operand of an overloaded shift operator must have the same type as the containing type, and the type of the second operand must be int O primeiro operando de um operador de deslocamento sobrecarregado deve ser do tipo recipiente, enquanto o do segundo deve ser int

Interfaces cannot contain operators Interfaces não podem conter operadores

Structs cannot contain explicit parameterless constructors Structs não podem conter construtores explícitos sem parâmetro

Enums cannot contain explicit parameterless constructors Enums não podem conter construtores explícitos sem parâmetros

'{0}': cannot override '{1}' because it is not supported by the language '"{0}": não é possível substituir "{1}" porque não é suportado pelo idioma

'{0}' is not supported by the language 'O idioma não dá suporte a "{0}"

'{0}': cannot explicitly call operator or accessor '"{0}": não é possível chamar explicitamente o operador ou acessador

'{0}': cannot reference a type through an expression; try '{1}' instead '"{0}": não é possível fazer referência a um tipo por meio de uma expressão; ao invés disso, tente "{1}"

'{0}': cannot have instance property or field initializers in structs '{0}': não é possível ter propriedade de instância ou inicializadores de campo em estruturas

Name of destructor must match name of class O nome do destruidor deve corresponder ao nome da classe

Only class types can contain destructors Somente tipos de classe podem conter destruidores

Namespace '{1}' contains a definition conflicting with alias '{0}' Namespace "{1}" contém uma definição em conflito com o alias "{0}"

Alias '{0}' conflicts with {1} definition Alias "{0}" está em conflito com {1} definição

The Conditional attribute is not valid on '{0}' because it is a constructor, destructor, operator, or explicit interface implementation O atributo Conditional não é válido em "{0}" porque é um construtor, destruidor, operador ou implementação de interface implícita

The Conditional attribute is not valid on '{0}' because its return type is not void O atributo Conditional não é válido em "{0}" porque seu tipo de retorno não é nulo

Duplicate '{0}' attribute Duplicar atributo "{0}"

Duplicate '{0}' attribute in '{1}' Duplicar atributo "{0}" em "{1}"

The Conditional attribute is not valid on interface members O atributo Conditional não é válido em membros de interface

User-defined operators cannot return void Operadores definidos pelo usuário não podem retornar void

'{0}': user-defined conversions to or from the dynamic type are not allowed '"{0}": conversões definidas pelo usuário para ou do tipo dinâmico não são permitidas

Invalid value for argument to '{0}' attribute Valor inválido para o argumento ao atributo "{0}"

Parameter not valid for the specified unmanaged type. Parâmetro não é válido para o tipo não gerenciado especificado.

Attribute parameter '{0}' must be specified. Parâmetro do atributo "{0}" deve ser especificado.

Attribute parameter '{0}' or '{1}' must be specified. Parâmetro do atributo "{0}" ou "{1}" deve ser especificado.

Unmanaged type '{0}' not valid for fields. Tipo não gerenciado "{0}" não é válido para campos.

Unmanaged type '{0}' is only valid for fields. Tipo não gerenciado "{0}" é válido somente para campos.

Attribute '{0}' is not valid on this declaration type. It is only valid on '{1}' declarations. Atributo "{0}" não é válido neste tipo de declaração. Ele é válido somente em "{1}" declarações.

Floating-point constant is outside the range of type '{0}' Constante de ponto flutuante está fora do intervalo do tipo "{0}"

The Guid attribute must be specified with the ComImport attribute O atributo Guid deve ser especificado com o atributo ComImport

Invalid value for named attribute argument '{0}' Valor inválido para o argumento de atributo denominado "{0}"

The DllImport attribute must be specified on a method marked 'static' and 'extern' O atributo DllImport deve ser especificado em um método marcado como 'static' e 'extern'

Cannot update '{0}'; attribute '{1}' is missing. Não é possível atualizar '{0}'; o atributo '{1}' está ausente.

The DllImport attribute cannot be applied to a method that is generic or contained in a generic type. O atributo DllImport não pode ser aplicado a um método que seja genérico ou esteja contido em um tipo genérico.

Field or property cannot be of type '{0}' Campo ou propriedade não pode ser do tipo "{0}"

Field or auto-implemented property cannot be of type '{0}' unless it is an instance member of a ref struct. O campo ou a propriedade autoimplementada não pode ser do tipo '{0}', a menos que seja um membro de instância de uma struct de referência.

Array elements cannot be of type '{0}' Elementos de matriz não podem ser do tipo "{0}"

'{0}' is obsolete '"{0}" está obsoleto

Type or member is obsolete O tipo ou membro é obsoleto

'{0}' is not an attribute class '"{0}" não é uma classe de atributo

'{0}' is not a valid named attribute argument. Named attribute arguments must be fields which are not readonly, static, or const, or read-write properties which are public and not static. '"{0}" é não um argumento de atributo nomeado válido. Argumentos de atributo nomeado devem ser campos que não são propriedades readonly, static ou const ou read-write que são públicas e não estáticas.

'{0}' is obsolete: '{1}' '"{0}" é obsoleto: "{1}"

Type or member is obsolete O tipo ou membro é obsoleto

'{0}' is obsolete: '{1}' '"{0}" é obsoleto: "{1}"

Indexers cannot have void type Indexadores não podem ter o tipo void

'{0}': virtual or abstract members cannot be private '"{0}": membros virtuais ou abstratos não podem ser privados

Can only use array initializer expressions to assign to array types. Try using a new expression instead. Só é possível usar expressões de inicializador de matriz para atribuir a tipos de matriz. Tente usar uma expressão new.

Array initializers can only be used in a variable or field initializer. Try using a new expression instead. Inicializadores de matriz só podem ser usados em um inicializador de campo ou variável. Tente usar uma expressão new.

'{0}': instance field in types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute '{0}': campo de instância em tipos marcados com StructLayout(LayoutKind.Explicit) precisam ter um atributo FieldOffset

Method, operator, or accessor '{0}' is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation. Método, operador ou acessador "{0}" está marcado como externo e sem atributos. Considere a adição de um atributo DllImport para especificar a implementação externa.

Method, operator, or accessor is marked external and has no attributes on it O método, operador ou assessor está marcado como externo e sem atributos

'{0}': new protected member declared in sealed class '"{0}": novo membro protegido declarado na classe sealed

New protected member declared in sealed class Novo membro protegido declarado na classe bloqueada

Conditional member '{0}' cannot implement interface member '{1}' in type '{2}' Membro condicional "{0}" não pode implementar membro de interface "{1}" no tipo "{2}"

ref and out are not valid in this context ref e out não são válidos neste contexto

The argument to the '{0}' attribute must be a valid identifier O argumento para o atributo "{0}" atributo deve ser um identificador válido

The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit) O atributo FieldOffset só pode ser colocado em membros de tipos marcados com StructLayout(LayoutKind.Explicit)

The FieldOffset attribute is not allowed on static or const fields O atributo FieldOffset não é permitido em campos estáticos e const

Attribute '{0}' is only valid on classes derived from System.Attribute Atributo "{0}" é somente válido em classes derivadas de System.Attribute

Possible mistaken empty statement Instrução empty possivelmente incorreta

'{0}' duplicate named attribute argument '"{0}" duplicar argumento de atributo nomeado

'{0}' cannot derive from special class '{1}' '"{0}" não pode derivar de classe especial "{1}"

Cannot specify the DefaultMember attribute on a type containing an indexer Não é possível especificar o atributo DefaultMember em um tipo que contém um indexador

'{0}' is a type not supported by the language '"{0}" é um tipo sem suporte no idioma

Field '{0}' is never assigned to, and will always have its default value {1} Campo "{0}" nunca é atribuído e sempre terá seu valor padrão {1}

Field is never assigned to, and will always have its default value O campo nunca é atribuído e sempre terá seu valor padrão

Bad array declarator: To declare a managed array the rank specifier precedes the variable's identifier. To declare a fixed size buffer field, use the fixed keyword before the field type. Declarador de matriz incorreto: para declarar uma matriz gerenciada, o especificador de classificação antecede o identificador de variável. Para declarar um campo de buffer de tamanho fixo, use a palavra-chave fixed antes do tipo de campo.

Comparison to integral constant is useless; the constant is outside the range of type '{0}' Comparação com constante integral é inútil; a constante está fora do intervalo do tipo "{0}"

Comparison to integral constant is useless; the constant is outside the range of the type A comparação com constante integral é inútil. A constante está fora do intervalo do tipo

Cannot apply attribute class '{0}' because it is abstract Não é possível aplicar classe de atributo "{0}" porque ela é abstract

'{0}' is not a valid named attribute argument because it is not a valid attribute parameter type '"{0}" não é um argumento de atributo nomeado válido porque não é um tipo de parâmetro de atributo válido

Missing compiler required member '{0}.{1}' Membro "{0}.{1}" necessário ao compilador ausente

'{0}' is not a valid attribute location for this declaration. Valid attribute locations for this declaration are '{1}'. All attributes in this block will be ignored. '"{0}" não é um local de atributo válido para esta declaração. Locais de atributo válidos para esta declaração são "{1}". Todos os atributos neste bloco serão ignorados.

Not a valid attribute location for this declaration Este não é um local de atributo para esta declaração

'{0}' is not a recognized attribute location. Valid attribute locations for this declaration are '{1}'. All attributes in this block will be ignored. '"{0}" não é um local de atributo reconhecido. Locais de atributo válidso para essa declaração são '{1}'. Todos os atributos neste bloco serão ignorados.

Not a recognized attribute location Este não é um local de atributo reconhecido

'{0}' overrides Object.Equals(object o) but does not override Object.GetHashCode() '"{0}" substitui Object.Equals(object o), mas não substitui Object.GetHashCode()

Type overrides Object.Equals(object o) but does not override Object.GetHashCode() O tipo substitui Object. Equals (objeto o), mas não substitui o Object.GetHashCode()

'{0}' defines operator == or operator != but does not override Object.Equals(object o) '"{0}" define o operador = = ou operador !=, mas não substitui Object.Equals(object o)

Type defines operator == or operator != but does not override Object.Equals(object o) O tipo define os operadores == ou !=, mas não substitui o Object.Equals(object o)

'{0}' defines operator == or operator != but does not override Object.GetHashCode() '"{0}" define o operador = = ou operador !=, mas não substitui Object.GetHashCode()

Type defines operator == or operator != but does not override Object.GetHashCode() O tipo define os operadores == ou !=, mas não substitui o Object.GetHashCode()

Cannot specify the Out attribute on a ref parameter without also specifying the In attribute. Não é possível especificar o atributo Out em um parâmetro de referência sem também especificar o atributo In.

'{0}' cannot define an overloaded {1} that differs only on parameter modifiers '{2}' and '{3}' '{0}' não pode definir uma sobrecarga {1} que difere somente nos modificadores de parâmetro '{2}' e '{3}'

Literal of type double cannot be implicitly converted to type '{1}'; use an '{0}' suffix to create a literal of this type Literal do tipo double não pode ser convertido implicitamente no tipo "{1}"; use um sufixo "{0}" para criar um literal desse tipo

Assignment in conditional expression is always constant; did you mean to use == instead of = ? Atribuição em expressão condicional é sempre constante. Deseja usar == em vez de = ?

Assignment in conditional expression is always constant A atribuição em expressão condicional é sempre constante

'{0}': new protected member declared in struct '"{0}": novo membro protegido declarado em struct

Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type Dois indexadores têm nomes diferentes. O atributo IndexerName deve ser usado com o mesmo nome em cada indexador dentro de um tipo

A class with the ComImport attribute cannot have a user-defined constructor A classe com o atributo ComImport não pode ter um construtor definido pelo usuário

Field cannot have void type O campo não pode ter tipo void

Member '{0}' overrides obsolete member '{1}'. Add the Obsolete attribute to '{0}'. Membro "{0}" substitui o membro obsoleto "{1}". Adicione o atributo Obsolete a "{0}".

Member overrides obsolete member O membro substitui o membro obsoleto

System.Void cannot be used from C# -- use typeof(void) to get the void type object System.Void não pode ser usado no C# -- use typeof(void) para obter o objeto de tipo void

Do not use 'System.ParamArrayAttribute'. Use the 'params' keyword instead. Não use 'System.ParamArrayAttribute'. Use a palavra-chave 'params'.

Bitwise-or operator used on a sign-extended operand; consider casting to a smaller unsigned type first Operador OR bit a bit usado em um operando de assinatura estendida; é recomendável realizar a conversão em um tipo menor sem assinatura primeiro

Bitwise-or operator used on a sign-extended operand Bit a bit ou operador usado em um operando de assinatura estendida

The compiler implicitly widened and sign-extended a variable, and then used the resulting value in a bitwise OR operation. This can result in unexpected behavior. O compilador ampliou e estendeu a assinatura de uma variável implicitamente, usando posteriormente o valor resultante em uma operação ou bit a bit. Isso pode resultar em um comportamento inesperado.

'{0}': a volatile field cannot be of the type '{1}' '"{0}": um campo volátil não pode ser do tipo "{1}"

'{0}': a field cannot be both volatile and readonly '"{0}": um campo não pode ser volátil e somente leitura

The modifier 'abstract' is not valid on fields. Try using a property instead. O modificador 'abstract' não é válido em campos. Em vez disso, tente usar uma propriedade.

'{0}' cannot implement '{1}' because it is not supported by the language '"{0}" não pode implementar "{1}" porque o idioma não dá suporte a ele

'{0}' explicit method implementation cannot implement '{1}' because it is an accessor 'A implementação de método explícito "{0}" não pode implementar "{1}" porque é um acessador

'{0}' interface marked with 'CoClassAttribute' not marked with 'ComImportAttribute' '"{0}" interface marcada com "CoClassAttribute" não marcada com "ComImportAttribute"

Interface marked with 'CoClassAttribute' not marked with 'ComImportAttribute' Interface marcada com 'CoClassAttribute', não com 'ComImportAttribute'

Conditional member '{0}' cannot have an out parameter Membro condicional "{0}" não pode ter um parâmetro out

Accessor '{0}' cannot implement interface member '{1}' for type '{2}'. Use an explicit interface implementation. O acessador "{0}" não pode implementar membro de interface "{1}" para o tipo "{2}". Use uma implementação de interface explícita.

The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead. O qualificador alias de namespace '::' sempre é resolvido em um tipo ou namespace, por isso é inválido aqui. Use '.' em seu lugar.

Cannot derive from '{0}' because it is a type parameter Não é possível derivar de "{0}" porque ele é um parâmetro de tipo

Duplicate type parameter '{0}' Duplicar atributo de tipo "{0}"

Type parameter '{0}' has the same name as the type parameter from outer type '{1}' Parâmetro de tipo "{0}" tem o mesmo nome do parâmetro de tipo de tipo externo "{1}"

Type parameter has the same name as the type parameter from outer type O parâmetro de tipo tem o mesmo nome que o parâmetro de tipo do tipo externo

Type parameter '{0}' has the same name as the containing type, or method Parâmetro de tipo "{0}" tem o mesmo nome do tipo recipiente ou do método

'{0}' cannot implement both '{1}' and '{2}' because they may unify for some type parameter substitutions '"{0}" não pode implementar "{1}" e "{2}" porque eles podem se unificar em algumas substituições de parâmetro de tipo

A generic type cannot derive from '{0}' because it is an attribute class Um tipo genérico não pode derivar de "{0}" porque ele é uma classe de atributo

'{1}' does not define type parameter '{0}' '"{1}" não define parâmetro de tipo "{0}"

'{0}' is not a valid constraint. A type used as a constraint must be an interface, a non-sealed class or a type parameter. '"{0}" não é uma restrição válida. Um tipo usado como uma restrição deve ser uma interface, uma classe não selada ou um parâmetro de tipo.

Constraint cannot be special class '{0}' Restrição não pode ser classe especial "{0}"

Inconsistent accessibility: constraint type '{1}' is less accessible than '{0}' Acessibilidade inconsistente: tipo de restrição "{1}" é menos acessível do que "{0}"

Cannot do member lookup in '{0}' because it is a type parameter Não é possível fazer pesquisa de membro em "{0}" porque ele é um parâmetro de tipo

Invalid constraint type. A type used as a constraint must be an interface, a non-sealed class or a type parameter. Tipo de restrição inválido. Um tipo usado como restrição deve ser uma interface, uma classe não sealed ou um parâmetro de tipo.

'{0}': cannot declare instance members in a static class '"{0}": não pode declarar membros de instância em uma classe estática

'{1}': cannot derive from static class '{0}' '"{1}": não pode derivar da classe static "{0}"

Static classes cannot have instance constructors Classes static não podem ter construtores de instância

Static classes cannot contain destructors Classes static não podem conter destruidores

Cannot create an instance of the static class '{0}' Não é possível criar uma instância da classe estática "{0}"

Static class '{0}' cannot derive from type '{1}'. Static classes must derive from object. Classe static "{0}" não pode derivar do tipo "{1}". Classes static devem derivar do objeto.

'{0}': static classes cannot implement interfaces '"{0}": classes static não podem implementar interfaces

'{0}': ref structs cannot implement interfaces '{0}': structs de referência não podem implementar interfaces

'{0}': static classes cannot contain user-defined operators '"{0}": classes static não podem conter operadores definidos pelo usuário

Cannot convert to static type '{0}' Não é possível converter em tipo estático "{0}"

'{0}': static classes cannot be used as constraints '"{0}": classes estáticas não podem ser utilizadas como restrições

'{0}': static types cannot be used as type arguments '"{0}": tipos estáticos não podem ser usados como argumentos de tipo

'{0}': array elements cannot be of static type '"{0}": elementos de matriz não podem ser do tipo static

'{0}': cannot declare indexers in a static class '"{0}": não pode declarar indexadores em uma classe estática

'{0}': static types cannot be used as parameters '"{0}": classes static não podem ser utilizadas como parâmetros

'{0}': static types cannot be used as return types '"{0}": tipos static não podem ser usados como tipos de retorno

Cannot declare a variable of static type '{0}' Não é possível declarar uma variável de tipo static "{0}"

A throw statement with no arguments is not allowed in a finally clause that is nested inside the nearest enclosing catch clause Não é permitida uma instrução throw sem argumentos em uma cláusula finally que está aninhada dentro da cláusula catch delimitadora mais próxima

'{0}' is not a valid format specifier '"{0}" não é um especificador de formato válido

Possibly incorrect assignment to local '{0}' which is the argument to a using or lock statement. The Dispose call or unlocking will happen on the original value of the local. Atribuição possivelmente incorreta ao local "{0}" que é o argumento para uma instrução using ou lock. A chamada Dispose desbloqueio ou acontecerá no valor original do local.

Possibly incorrect assignment to local which is the argument to a using or lock statement Atribuição possivelmente incorreta ao local que é o argumento para uma instrução using ou lock

Type '{0}' is defined in this assembly, but a type forwarder is specified for it Tipo "{0}" está definido neste assembly, mas um encaminhador de tipo está especificado para ele

Cannot forward type '{0}' because it is a nested type of '{1}' Não é possível encaminhar o tipo "{0}" porque ele é um tipo aninhado de "{1}"

The type forwarder for type '{0}' in assembly '{1}' causes a cycle O encaminhador de tipo para o tipo "{0}" no assembly "{1}" gera um ciclo

The /moduleassemblyname option may only be specified when building a target type of 'module' A opção /moduleassemblyname só pode ser especificada ao criar um tipo de destino de 'module'

Assembly reference '{0}' is invalid and cannot be resolved Referência do assembly "{0}" é inválida e não pode ser resolvida

Invalid type specified as an argument for TypeForwardedTo attribute Tipo inválido especificado como argumento para o atributo TypeForwardedTo

'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static. '"{0}" não implementa membro de interface "{1}". "{2}" não pode implementar um membro de interface, pois é estático.

'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is not public. '"{0}" não implementa membro de interface "{1}". "{2}" não pode implementar um membro de interface, pois não é público.

'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}' because it does not have the matching return type of '{3}'. '"{0}" não implementa membro de interface "{1}". "{2}" não pode implementar "{1}" porqu não tem o tipo de retorno correspondente de "{3}".

'{0}' duplicate TypeForwardedToAttribute '"{0}" duplicar TypeForwardedToAttribute

A query body must end with a select clause or a group clause O corpo de uma consulta deve terminar com uma cláusula select ou group

Expected contextual keyword 'on' Palavra-chave contextual esperada 'on'

Expected contextual keyword 'equals' Palavra-chave contextual esperada 'equals'

Expected contextual keyword 'by' Palavra-chave contextual esperada 'by'

Invalid anonymous type member declarator. Anonymous type members must be declared with a member assignment, simple name or member access. Declarador de membro de tipo anônimo inválido. Membros de tipo anônimo devem ser declarados com uma atribuição de membro, nome simples ou acesso de membro.

Invalid initializer member declarator Declarador de membro de inicializador inválido

Inconsistent lambda parameter usage; parameter types must be all explicit or all implicit Utilização inconsistente do parâmetro lambda; todos os tipos de parâmetros devem ser explícitos ou implícitos.

A partial method cannot have access modifiers or the virtual, abstract, override, new, sealed, or extern modifiers Um método parcial não pode ter modificadores de acesso ou modificadores do tipo virtual, abstract, override, new, sealed ou extern

A partial method must be declared within a partial class or partial struct Um método parcial deve ser declarado em uma classe parcial ou estrutura parcial

A partial method cannot have out parameters Um método parcial não pode ter parâmetros out

A partial method may not explicitly implement an interface method Um método parcial não pode implementar explicitamente um método de interface

Both partial method declarations must be extension methods or neither may be an extension method As duas declarações de métodos parciais devem ser métodos de extensão ou nenhuma delas poderá ser desse tipo

A partial method may not have multiple defining declarations Um método parcial não pode ter várias declarações de definição

A partial method may not have multiple implementing declarations Um método parcial não pode ter várias declarações de implementação

Both partial method declarations must use a params parameter or neither may use a params parameter As duas declarações do método parcial devem usar um parâmetro params ou nenhuma delas pode usar um parâmetro params

No defining declaration found for implementing declaration of partial method '{0}' Nenhuma declaração de definição encontrada para implementar a declaração de método parcial "{0}"

Both partial method declarations, '{0}' and '{1}', must use the same tuple element names. Ambas as declarações de método parciais, '{0}' e '{1}', devem usar os mesmos elementos de nome de tupla.

Partial method declarations of '{0}' have inconsistent type parameter constraints As declarações de método parcial "{0}" têm restrições de parâmetro de tipo inconsistentes

Cannot create delegate from method '{0}' because it is a partial method without an implementing declaration Não é possível criar representante do método "{0}" porque ele é um método parcial sem declaração de implementação

Both partial method declarations must be static or neither may be static As duas declarações de métodos parciais devem ser estáticas ou nenhuma delas deve ser desse tipo

Both partial method declarations must be unsafe or neither may be unsafe As duas declarações de métodos parciais devem ser inseguras ou nenhuma delas deve ser desse tipo

Partial methods with only a defining declaration or removed conditional methods cannot be used in expression trees Os métodos parciais com apenas uma declaração de definição ou métodos condicionais removidos não podem ser usados em árvores de expressão

Partial methods must have a void return type Os métodos parciais devem ter um tipo de retorno void

Obsolete member '{0}' overrides non-obsolete member '{1}' O membro obsoleto "{0}" substitui o membro não obsoleto "{1}"

Obsolete member overrides non-obsolete member O membro obsoleto substitui o membro não obsoleto

The fully qualified name for '{0}' is too long for debug information. Compile without '/debug' option. O nome totalmente qualificado para "{0}" é muito longo para informações de depuração. Compile sem a opção "/debug".

Fully qualified name is too long for debug information O nome totalmente qualificado é muito longo para as informações de depuração

Cannot assign {0} to an implicitly-typed variable Não é possível atribuir {0} a uma variável de tipo implícito

Implicitly-typed variables must be initialized Variáveis de tipo implícito devem ser inicializadas

Implicitly-typed variables cannot have multiple declarators Variáveis de tipo implícito não podem ter vários declaradores

Cannot initialize an implicitly-typed variable with an array initializer Não é possível inicializar uma variável de tipo implícito com um inicializador de matriz

Implicitly-typed local variables cannot be fixed Variáveis locais do tipo implícito não podem ser fixas

Implicitly-typed variables cannot be constant Variáveis de tipo implícito não podem ser constantes

Constructor '{0}' is marked external Construtor "{0}" está marcado como externo

Constructor is marked external O construtor está marcado como externo

The contextual keyword 'var' may only appear within a local variable declaration or in script code A palavra-chave contextual "var" pode somente aparecer dentro de uma declaração de variável local ou no código de script

No best type found for implicitly-typed array Não foi encontrado nenhum tipo melhor para a matriz do tipo implícita

Cannot assign '{0}' to anonymous type property Não é possível atribuir '{0}' à propriedade de tipo anônimo

An expression tree may not contain a base access Uma árvore de expressões não pode conter um acesso de base

An expression tree may not contain an assignment operator Uma árvore de expressões não pode conter um operador de atribuição

An anonymous type cannot have multiple properties with the same name Um tipo anônimo não pode ter várias propriedades com o mesmo nome

A lambda expression with a statement body cannot be converted to an expression tree Uma expressão lambda com um corpo de instrução não pode ser convertida em uma árvore de expressões

Cannot convert lambda to an expression tree whose type argument '{0}' is not a delegate type Não é possível converter lambda em uma árvore de expressões cujo argumento de tipo "{0}" não é um tipo delegado

Cannot use anonymous type in a constant expression Não é possível usar o tipo anônimo em uma expressão constante

The first operand of an 'is' or 'as' operator may not be a lambda expression, anonymous method, or method group. O primeiro operando de um operador "is" ou "as" não pode ser uma expressão lambda, um método anônimo ou um grupo de métodos.

The first operand of an 'as' operator may not be a tuple literal without a natural type. O primeiro operando de um operador 'as' não pode ser uma literal de tupla sem nenhum tipo natural.

An expression tree may not contain a multidimensional array initializer Uma árvore de expressões não pode conter um inicializador de matriz multidimensional

Argument missing Argumento ausente

Cannot use local variable '{0}' before it is declared Não é possível usar a variável local "{0}" antes de declará-la

Type of '{0}' cannot be inferred since its initializer directly or indirectly refers to the definition. Tipo de "{0}" não pode ser inferido porque seu inicializador direta ou indiretamente refere-se à definição.

Auto-implemented property '{0}' must be fully assigned before control is returned to the caller. A propriedade '{0}' autoimplementada deve ser totalmente atribuída antes de o controle ser retornado ao chamador.

Cannot use local variable '{0}' before it is declared. The declaration of the local variable hides the field '{1}'. Não é possível usar a variável local "{0}" antes de declará-la. A declaração da variável local oculta o campo "{1}".

An expression tree lambda may not contain a coalescing operator with a null or default literal left-hand side Uma árvore de expressão da expressão lambda não pode conter um operador de união com um lado esquerdo literal padrão ou nulo

Identifier expected Identificador esperado

; expected ; esperado

Syntax error, '{0}' expected Erro de sintaxe, "{0}" esperado

Duplicate '{0}' modifier Duplicar modificador "{0}"

Property accessor already defined O acessador de propriedade já está definido

Type byte, sbyte, short, ushort, int, uint, long, or ulong expected Tipo byte, sbyte, short, ushort, int, uint, long ou ulong esperado

Unrecognized escape sequence Sequência de escape não reconhecida

Newline in constant Newline em constante

Empty character literal Literal de caractere vazio

Too many characters in character literal Número excessivo de caracteres no literal de caractere

Invalid number Número inválido

A get or set accessor expected Acessador get ou set esperado

An object, string, or class type expected Um objeto, cadeia de caracteres ou tipo de classe esperado

Named attribute argument expected Argumento de atributo nomeado esperado

Catch clauses cannot follow the general catch clause of a try statement As cláusulas catch não podem seguir a cláusula catch geral de uma instrução try

Keyword 'this' or 'base' expected Palavra-chave 'this' ou 'base' esperada

Overloadable unary operator expected Operador unário que pode ser sobrecarregado é esperado

Overloadable binary operator expected Operador binário que pode ser sobrecarregado é esperado

Integral constant is too large Constante de integral muito grande

Type or namespace definition, or end-of-file expected Definição de namespace ou tipo, ou final do arquivo esperado

Member definition, statement, or end-of-file expected Definição de membro, instrução ou final do arquivo esperado

Embedded statement cannot be a declaration or labeled statement A instrução inserida não pode ser uma declaração ou uma instrução rotulada

Preprocessor directive expected Diretiva de pré-processamento esperada

Single-line comment or end-of-line expected Comentário de linha única ou final de linha esperado

) expected ) esperado

#endif directive expected Diretiva #endif esperada

Unexpected preprocessor directive Diretiva de pré-processamento inesperada

#error: '{0}' #error: "{0}"

#warning: '{0}' #warning: "{0}"

#warning directive diretiva de #aviso

Type expected Tipo esperado

Cannot define/undefine preprocessor symbols after first token in file Não é possível definir nem remover os símbolos de pré-processamento após o primeiro token no arquivo

Cannot use #r after first token in file Não é possível usar #r após o primeiro token no arquivo

End-of-file found, '*/' expected Final do arquivo encontrado. '*/' esperado

Merge conflict marker encountered Marcador de conflito de mesclagem encontrado

Do not use refout when using refonly. Não use refout ao usar refonly.

Cannot compile net modules when using /refout or /refonly. Não é possível compilar módulos de rede ao usar /refout ou /refonly.

Overloadable operator expected Operador que pode ser sobrecarregado é esperado

#endregion directive expected Diretiva #endregion esperada

Unterminated string literal Literal de cadeia de caracteres não finalizado

Preprocessor directives must appear as the first non-whitespace character on a line As diretivas de pré-processamento devem aparecer como o primeiro caractere que não seja espaço em branco em uma linha

Identifier expected; '{1}' is a keyword Identificador esperado; "{1}" é uma palavra-chave

{ or ; expected { ou ; esperado

Cannot use more than one type in a for, using, fixed, or declaration statement Não é possível usar mais de um tipo em uma instrução for, using, fixed ou or de declaração

An add or remove accessor expected Acessador add ou remove esperado

Unexpected character '{0}' Caractere inesperado '{0}'

Unexpected token '{0}' Token inesperado '{0}'

'{0}': static classes cannot contain protected members '"{0}": classes static não podem conter membros protegidos

A previous catch clause already catches all exceptions. All non-exceptions thrown will be wrapped in a System.Runtime.CompilerServices.RuntimeWrappedException. Uma cláusula catch anterior já captura todas as exceções. Todas as não exceções lançadas serão ajustadas em uma System.Runtime.CompilerServices.RuntimeWrappedException.

A previous catch clause already catches all exceptions Uma cláusula catch anterior já captura todas as exceções

This warning is caused when a catch() block has no specified exception type after a catch (System.Exception e) block. The warning advises that the catch() block will not catch any exceptions. A catch() block after a catch (System.Exception e) block can catch non-CLS exceptions if the RuntimeCompatibilityAttribute is set to false in the AssemblyInfo.cs file: [assembly: RuntimeCompatibilityAttribute(WrapNonExceptionThrows = false)]. If this attribute is not set explicitly to false, all thrown non-CLS exceptions are wrapped as Exceptions and the catch (System.Exception e) block catches them. Este aviso ocorre quando um bloco catch() não tem nenhuma exceção de tipo especificada após um bloco catch (System.Exception e). O aviso indica que o bloco de catch() não capturará exceções. Um bloco catch() depois de um bloco catch (System.Exception e) poderá capturar exceções não CLS se o RuntimeCompatibilityAttribute estiver definido como false no arquivo AssemblyInfo.cs: [assembly: RuntimeCompatibilityAttribute(WrapNonExceptionThrows = false)]. Se esse atributo não for definido explicitamente como false, todas as exceções geradas não-CLS são encapsuladas como exceções e o bloco catch (System.Exception e) as captura.

The operand of an increment or decrement operator must be a variable, property or indexer O operando de aumento ou diminuição deve ser uma variável, propriedade ou indexador

'{0}' does not contain a definition for '{1}' and no accessible extension method '{1}' accepting a first argument of type '{0}' could be found (are you missing a using directive or an assembly reference?) ‘{0}’ não contém uma definição para "{1}" e não foi possível encontrar nenhum método de extensão "{1}" que aceite um primeiro argumento do tipo ‘{0}’ (você está se esquecendo de usar uma diretiva ou uma referência de assembly?)

'{0}' does not contain a definition for '{1}' and no extension method '{1}' accepting a first argument of type '{0}' could be found (are you missing a using directive for '{2}'?) '"{0}" não contém uma definição para "{1}" e nenhum método de extensão "{1}" aceitando um primeiro argumento do tipo "{0}" pode ser encontrado (está faltando uma diretiva using para "{2}"?)

Method '{0}' has a parameter modifier 'this' which is not on the first parameter Método "{0}" tem um modificador de parâmetro "this" que não está no primeiro parâmetro

The parameter modifier '{0}' cannot be used with '{1}' O modificador de parâmetro '{0}' não pode ser usado com '{1}'

The first parameter of an extension method cannot be of type '{0}' O primeiro parâmetro de um método de extensão não pode ser do tipo "{0}"

A parameter array cannot be used with 'this' modifier on an extension method Uma matriz de parâmetro não pode ser usada com o modificador 'this' em um método de extensão

Extension method must be static O método de extensão deve ser estático

Extension method must be defined in a non-generic static class O método de extensão deve ser definido em uma classe estática não genérica

A parameter can only have one '{0}' modifier Um parâmetro pode somente ter um modificador "{0}"

Extension methods must be defined in a top level static class; {0} is a nested class Métodos de extensão devem ser definidos em uma classe estática de nível superior; {0} é uma classe aninhada

Cannot define a new extension method because the compiler required type '{0}' cannot be found. Are you missing a reference to System.Core.dll? Não é possível definir um novo método de extensão porque o tipo necessário de compilador "{0}" não pode ser encontrado. Está faltando uma referência a System.Core.dll?

Do not use 'System.Runtime.CompilerServices.ExtensionAttribute'. Use the 'this' keyword instead. Não use "System.Runtime.CompilerServices.ExtensionAttribute". Em vez disso, use a palavra-chave "this".

Do not use 'System.Runtime.CompilerServices.DynamicAttribute'. Use the 'dynamic' keyword instead. Não use "System.Runtime.CompilerServices.ExtensionAttribute". Em vez disso, use a palavra-chave "dynamic".

The constructor call needs to be dynamically dispatched, but cannot be because it is part of a constructor initializer. Consider casting the dynamic arguments. A chamada de construtor deve ser expedida dinamicamente, mas isso não é possível porque ela faz parte de um inicializador de construtor. Converta os argumentos dinâmicos.

Extension method '{0}' defined on value type '{1}' cannot be used to create delegates Método de extensão "{0}" definido no tipo de valor "{1}" não pode ser usado para criar representantes

No overload for method '{0}' takes {1} arguments Nenhuma sobrecarga para o método "{0}" leva {1} argumentos

Argument {0}: cannot convert from '{1}' to '{2}' Argumento {0}: não é possível converter de "{1}" para "{2}"

Source file '{0}' could not be opened -- {1} Arquivo de origem "{0}" não pode ser aberto -- {1}

Cannot link resource files when building a module Não é possível vincular arquivos de recursos ao criar um módulo

Resource identifier '{0}' has already been used in this assembly Identificador de recurso "{0}" já foi usado neste assembly

Each linked resource and module must have a unique filename. Filename '{0}' is specified more than once in this assembly Cada módulo ou recurso vinculado devem ter um nome de arquivo exclusivo. Nome de arquivo "{0}" é especificado mais de uma vez neste assembly

The referenced file '{0}' is not an assembly O arquivo referenciado "{0}" não é um assembly

A ref or out value must be an assignable variable Um valor ref ou out deve ser uma variável que possa ser atribuída

Keyword 'base' is not available in a static method A palavra-chave 'base' não está disponível em um método estático

Keyword 'base' is not available in the current context A palavra-chave 'base' não está disponível no contexto atual

} expected } esperada

{ expected { esperado

'in' expected 'in' esperado

Invalid preprocessor expression Expressão de pré-processamento inválida

Invalid token '{0}' in class, struct, or interface member declaration Token inválido "{0}" na classe, estrutura ou declaração de membro de interface

Method must have a return type O método deve ter um tipo de retorno

Invalid base type Tipo base inválido

Empty switch block Bloco switch vazio

Expected catch or finally Catch ou finally esperado

Invalid expression term '{0}' Termo de expressão inválido "{0}"

A new expression requires (), [], or {} after type Uma expressão new requer (), [] ou {} após o tipo

Elements defined in a namespace cannot be explicitly declared as private, protected, protected internal, or private protected Os elementos definidos em um namespace não podem ser declarados explicitamente como privados, protegidos, protegidos internamente ou protegidos de forma privada

Expected ; or = (cannot specify constructor arguments in declaration) ; ou = esperado. (Não é possível especificar argumentos de construtor na declaração)

A using clause must precede all other elements defined in the namespace except extern alias declarations Uma cláusula using deve preceder todos os outros elementos definidos no namespace, exceto as declarações de alias externas

Overloaded binary operator '{0}' takes two parameters Operador binário sobrecarregado "{0}" obtém dois parâmetros

Overloaded unary operator '{0}' takes one parameter Operador unário sobrecarregado "{0}" obtém um parâmetro

Invalid parameter type 'void' Tipo de parâmetro 'void' inválido

The using alias '{0}' appeared previously in this namespace O alias using "{0}" exibido anteriormente neste namespace

Cannot access protected member '{0}' via a qualifier of type '{1}'; the qualifier must be of type '{2}' (or derived from it) Não é possível acessar membro protegido "{0}" através de um qualificador do tipo "{1}"; o qualificador deve ser do tipo "{2}" (ou derivado dele)

'{0}' cannot be added to this assembly because it already is an assembly '"{0}" não pode ser adicionado a este assembly porque já é um assembly

Property, indexer, or event '{0}' is not supported by the language; try directly calling accessor methods '{1}' or '{2}' O idioma não dá suporte à propriedade, ao indexador ou ao evento "{0}"; tente chamar diretamente o método de acessador "{1}" ou "{2}"

Property, indexer, or event '{0}' is not supported by the language; try directly calling accessor method '{1}' O idioma não dá suporte à propriedade, ao indexador ou ao evento "{0}"; tente chamar diretamente o método de acessador "{1}"

Keyword 'void' cannot be used in this context A palavra-chave 'void' não pode ser usada neste contexto

Indexers must have at least one parameter Indexadores devem ter no mínimo um parâmetro

Array type specifier, [], must appear before parameter name O especificador de tipo de matriz, [], deve aparecer antes do nome de parâmetro

Declaration is not valid; use '{0} operator <dest-type> (...' instead Declaração não é válida; ao invés disso, use "{0} operador <dest-type> (..."

Could not find '{0}' specified for Main method Não foi possível encontrar "{0}" especificado para o método Main

'{0}' specified for Main method must be a valid non-generic class or struct '"{0}" especificado para método Main deve ser uma classe ou estrutura não-genérica válida

'{0}' does not have a suitable static 'Main' method '{0}' não tem um método 'Main' estático adequado

Cannot use '{0}' for Main method because it is imported Não é possível usar "{0}" para o método Main porque ele é importado

Outputs without source must have the /out option specified Saídas sem origem devem ter a opção /out especificada

Conflicting options specified: Win32 resource file; Win32 manifest Opções de conflito especificadas: Arquivo de recurso Win32; manifesto Win32

Conflicting options specified: Win32 resource file; Win32 icon Opções conflitantes especificadas: arquivo de recursos do Win32; ícone do Win32

Error reading resource '{0}' -- '{1}' Erro ao ler o recurso "{0}" -- "{1}"

Error writing to XML documentation file: {0} Erro gravando no arquivo de documentação XML: {0}

XML comment has badly formed XML -- '{0}' O comentário XML tem XML com formação incorreta -- "{0}"

XML comment has badly formed XML O comentário XML tem XML possui formato incorreto

XML comment has a duplicate param tag for '{0}' O comentário XML tem uma marca param duplicada para "{0}"

XML comment has a duplicate param tag O comentário XML tem uma marca param duplicada

XML comment has a param tag for '{0}', but there is no parameter by that name Comentário XML tem uma marga param para "{0}", mas não há parâmetro por esse nome

XML comment has a param tag, but there is no parameter by that name O comentário XML tem uma marca param, mas não há nenhum parâmetro com esse nome

XML comment on '{1}' has a paramref tag for '{0}', but there is no parameter by that name Comentário XML em "{1}" tem uma marca de paramref para "{0}", mas não há parâmetro por esse nome

XML comment has a paramref tag, but there is no parameter by that name O comentário XML tem uma marca paramref, mas não há nenhum parâmetro com esse nome

Parameter '{0}' has no matching param tag in the XML comment for '{1}' (but other parameters do) Parâmetro "{0}" não tem marca param correspondente no comentário XML para "{1}" (mas outros parâmetros têm)

Parameter has no matching param tag in the XML comment (but other parameters do) O parâmetro não tem nenhuma marca param correspondente no comentário XML (mas outros parâmetros têm)

XML comment has cref attribute '{0}' that could not be resolved O comentário XML tem atributo cref "{0}" que não pode ser resolvido

XML comment has cref attribute that could not be resolved O comentário XML possui um atributo cref que não pode ser resolvido

A stackalloc expression requires [] after type Uma expressão stackalloc requer [] após o tipo

The line number specified for #line directive is missing or invalid Número de linha especificado para diretiva #line ausente ou inválido

Quoted file name, single-line comment or end-of-line expected Nome do arquivo entre aspas, comentário de linha única ou fim da linha é esperado

Quoted file name expected Nome do arquivo entre aspas é esperado

#r is only allowed in scripts #r somente é permitido em scripts

foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a public instance definition for '{1}' A instrução foreach não pode operar em variáveis do tipo '{0}' porque '{0}' não contém uma definição da instância pública para '{1}'

Invalid type for parameter {0} in XML comment cref attribute: '{1}' Tipo inválido para parâmetro {0} no atributo de cref de comentário XML: "{1}"

Invalid type for parameter in XML comment cref attribute Tipo inválido para o parâmetro no atributo cref do comentário XML

Invalid return type in XML comment cref attribute Tipo de retorno inválido no atributo cref do comentário XML

Error reading Win32 resources -- {0} Erro ao ler recursos do Win32 -- {0}

XML comment has syntactically incorrect cref attribute '{0}' O comentário XML tem atributo cref sintaticamente incorreto "{0}"

XML comment has syntactically incorrect cref attribute O comentário XML possui um atributo cref sintaticamente incorreto

Member modifier '{0}' must precede the member type and name Modificador de membro "{0}" deve preceder o nome e o tipo de membro

Array creation must have array size or array initializer A criação de matriz deve ter tamanho de matriz ou inicializador de matriz

XML comment is not placed on a valid language element O comentário XML não está inserido em um elemento de linguagem válido

Unable to include XML fragment '{1}' of file '{0}' -- {2} Não é possível incluir fragmento XML "{1}" do arquivo "{0}" -- {2}

Unable to include XML fragment Não é possível incluir fragmento XML

Invalid XML include element -- {0} Elemento XML include inválido -- {0}

Invalid XML include element XML inválido para incluir elemento

Missing XML comment for publicly visible type or member '{0}' Comentário XML ausente para tipo publicamente visível ou membro "{0}"

Missing XML comment for publicly visible type or member O comentário XML ausente não foi encontrado para o tipo ou membro visível publicamente

The /doc compiler option was specified, but one or more constructs did not have comments. A opção de compilador /doc foi especificada, mas um ou mais construtores não tinha comentários.

Badly formed XML in included comments file -- '{0}' XML mal formada no arquivo de comentários incluído -- "{0}"

Badly formed XML in included comments file XML malformado no arquivo de comentários incluído

Delegate '{0}' does not take {1} arguments Delegado "{0}" não obtém {1} argumentos

Semicolon after method or accessor block is not valid Ponto-e-vírgula após bloco de acessador ou método não é válido

Method or delegate cannot return type '{0}' Método ou representante não pode retornar tipo "{0}"

Compilation cancelled by user Compilação cancelada pelo usuário

Cannot make reference to variable of type '{0}' Não é possível fazer referência à variável do tipo "{0}"

Cannot assign to '{0}' because it is read-only Não é possível atribuir a "{0}" porque ele é somente leitura

Cannot use '{0}' as a ref or out value because it is read-only Não é possível usar '{0}' como um valor ref ou out porque ele é somente leitura

The RequiredAttribute attribute is not permitted on C# types O atributo RequiredAttribute não é permitido em tipos C#

Modifiers cannot be placed on event accessor declarations Modificadores não podem ser colocados em declarações de acessador de evento

The params parameter cannot be declared as {0} O parâmetro params não pode ser declarado como {0}

Cannot modify the return value of '{0}' because it is not a variable Não é possível modificar o valor de retorno "{0}" porque ele não é uma variável

The managed coclass wrapper class '{0}' for interface '{1}' cannot be found (are you missing an assembly reference?) A classe coclass wrapper gerenciada "{0}" para a interface "{1}" não pode ser encontrada (está faltando uma referência de assembly?)

'{0}' is ambiguous between '{1}' and '{2}'; use either '@{0}' or '{0}Attribute' '{0} é ambíguo entre '{1}' e '{2}'; use '@{0}' ou '{0}Attribute'

Argument {0} may not be passed with the '{1}' keyword O argumento {0} não deve ser transmitido com a palavra-chave '{1}'

Option '{0}' overrides attribute '{1}' given in a source file or added module Opção "{0}" substitui o atributo "{1}" fornecido em um arquivo de origem ou módulo adicionado

Option overrides attribute given in a source file or added module Esta opção substitui o atributo fornecido em um arquivo de origem ou módulo adicionado

This warning occurs if the assembly attributes AssemblyKeyFileAttribute or AssemblyKeyNameAttribute found in source conflict with the /keyfile or /keycontainer command line option or key file name or key container specified in the Project Properties. Este aviso ocorre se os atributos de assembly AssemblyKeyFileAttribute ou o AssemblyKeyNameAttribute encontrados na fonte estiverem em conflito com a opção de linha de comando /keyfile ou /keycontainer ou nome do arquivo-chave ou contêiner-chave especificado nas propriedades do projeto.

Invalid option '{0}' for /langversion. Use '/langversion:?' to list supported values. Opção inválida '{0}' para /langversion. Use ' / langversion:?' para listar os valores com suporte.

Cannot create delegate with '{0}' because it or a method it overrides has a Conditional attribute Não é possível criar representante com "{0}" porque ele ou um método que substitui tem um atributo Conditional

Cannot create temporary file -- {0} Não é possível criar arquivo temporário -- {0}

Argument {0} must be passed with the '{1}' keyword Argumento {0} não deve ser transmitido com a palavra-chave "{1}"

The yield statement cannot be used inside an anonymous method or lambda expression A instrução yield não pode ser usada em um método anônimo ou expressão lambda

Cannot return a value from an iterator. Use the yield return statement to return a value, or yield break to end the iteration. Não é possível retornar um valor de um iterador. Use a instrução yield return para retornar um valor ou yield break para finalizar a iteração.

Iterators cannot have ref, in or out parameters Os iteradores não podem ter parâmetros ref, in ou out

The body of '{0}' cannot be an iterator block because '{1}' is not an iterator interface type O corpo de "{0}" não pode ser um bloco de iteradores porque "{1}" não é um tipo de interface de iterador

Cannot yield in the body of a finally clause Não é possível usar a instrução yield no corpo de uma cláusula finally

Cannot yield a value in the body of a try block with a catch clause Não é possível usar a instrução yield no corpo de um bloco try com uma cláusula catch

Expression expected after yield return Expressão esperada após yield return

Cannot use ref, out, or in parameter '{0}' inside an anonymous method, lambda expression, query expression, or local function Não é possível usar os parâmetro ref, out ou in '{0}' dentro de um método anônimo, de uma expressão lambda de uma expressão de consulta ou de uma função local

Unsafe code may not appear in iterators Código sem segurança só pode aparecer em iteradores

Cannot yield a value in the body of a catch clause Não é possível usar a instrução yield no corpo de uma cláusula catch

Control cannot leave the body of an anonymous method or lambda expression O controle não pode sair do corpo de um método anônimo ou expressão lambda

Unrecognized #pragma directive Diretiva #pragma não reconhecida

Expected disable, restore, enable or safeonly Restauração ou desabilitação esperada

Expected disable, restore, enable or safeonly after #pragma warning Desabilitação ou restauração esperada após o aviso de #pragma

Cannot restore warning 'CS{0}' because it was disabled globally Não é possível restaurar o aviso "CS{0}" porque ele foi desabilitado globalmente

Cannot restore warning because it was disabled globally Não é possível restaurar o aviso porque ele foi desabilitado globalmente

__arglist is not allowed in the parameter list of iterators __arglist não é permitido na lista de parâmetros dos iteradores

Iterators cannot have unsafe parameters or yield types Iteradores não podem ter tipos yield nem parâmetros sem segurança

The managed coclass wrapper class signature '{0}' for interface '{1}' is not a valid class name signature A assinatura de classe coclass wrapper gerenciada "{0}" para interface "{1}" não é uma assinatura de nome de classe válida

foreach statement cannot operate on variables of type '{0}' because it implements multiple instantiations of '{1}'; try casting to a specific interface instantiation A instrução foreach não pode operar em variáveis do tipo "{0}" porque implementa várias instanciações de "{1}"; tente transmitir para uma instanciação de interface específica

A fixed size buffer field must have the array size specifier after the field name Um campo de buffer de tamanho fixo deve ter especificador de tamanho de matriz após o nome do campo

Fixed size buffer fields may only be members of structs Campos de buffer de tamanho fixo só podem ser membros de structs

Not all code paths return a value in {0} of type '{1}' Nem todos os caminhos de código retornam um valor em {0} do tipo "{1}"

Feature '{0}' is not part of the standardized ISO C# language specification, and may not be accepted by other compilers Recurso "{0}" não é parte da especificação de idioma ISO C# padronizada e não pode ser aceito por outros compiladores

Feature is not part of the standardized ISO C# language specification, and may not be accepted by other compilers O recurso não faz parte da especificação de linguagem ISO C# padronizada e pode não ser aceito por outros compiladores

Keyword, identifier, or string expected after verbatim specifier: @ Palavra-chave, cadeia de caracteres ou identificador esperado após o especificador textual: @

A readonly field cannot be used as a ref or out value (except in a constructor) Um campo somente leitura não pode ser usado como um valor ref ou out (exceto em um construtor)

Members of readonly field '{0}' cannot be used as a ref or out value (except in a constructor) Os membros do campo somente leitura '{0}' não podem ser usados como um valor ref ou out (a não ser em um construtor)

A readonly field cannot be assigned to (except in a constructor or a variable initializer) Um campo somente leitura não pode ser atribuído (exceto em um construtor ou inicializador de variável)

Members of readonly field '{0}' cannot be modified (except in a constructor or a variable initializer) Os membros do campo somente leitura "{0}" não podem ser modificados (exceto em um construtor ou inicializador de variável)

Cannot use {0} '{1}' as a ref or out value because it is a readonly variable Não é possível usar {0} '{1}' como um valor de referência ou out porque ela é uma variável somente leitura

Members of {0} '{1}' cannot be used as a ref or out value because it is a readonly variable Membros de {0} '{1}' não podem ser usados como um valor de referência ou out porque ela é uma variável somente leitura

Cannot assign to {0} '{1}' because it is a readonly variable Não é possível atribuir a {0} '{1}' porque não é uma variável somente leitura

Cannot assign to a member of {0} '{1}' because it is a readonly variable Não é possível atribuir a um membro de {0} '{1}' porque é uma variável somente leitura

Cannot return {0} '{1}' by writable reference because it is a readonly variable Não é possível retornar {0} '{1}' por referência gravável porque ela é uma variável somente leitura

Members of {0} '{1}' cannot be returned by writable reference because it is a readonly variable Membros de {0} '{1}' não podem ser retornados por referência gravável porque ela é uma variável somente leitura

Fields of static readonly field '{0}' cannot be assigned to (except in a static constructor or a variable initializer) Campos do campo estático somente leitura "{0}" não podem ser atribuídos (exceto em um construtor estático ou inicializador de variável)

Fields of static readonly field '{0}' cannot be used as a ref or out value (except in a static constructor) Os campos do campo somente leitura estático '{0}' não podem ser usados como um valor ref ou out (exceto em um construtor estático)

Cannot modify members of '{0}' because it is a '{1}' Não é possível modificar membros de "{0}" porque ele é um "{1}"

Cannot use fields of '{0}' as a ref or out value because it is a '{1}' Não é possível usar campos de '{0}' como um valor ref ou out porque ele é um '{1}'

Cannot assign to '{0}' because it is a '{1}' Não é possível atribuir a "{0}" porque ele é um "{1}"

Cannot use '{0}' as a ref or out value because it is a '{1}' Não é possível usar '{0}' como um valor ref ou out porque ele é '{1}'

{0}. See also error CS{1}. {0}. Veja também o erro CS{1}.

Warning is overriding an error O aviso está substituindo um erro

The compiler emits this warning when it overrides an error with a warning. For information about the problem, search for the error code mentioned. O compilador emite esse aviso quando substitui um erro com um aviso. Para obter informações sobre o problema, procure o código de erro mencionado.

Cannot convert {0} to type '{1}' because it is not a delegate type Não é possível converter {0} para o tipo "{1}" porque ele não é um tipo delegado

Cannot convert {0} to type '{1}' because the parameter types do not match the delegate parameter types Não é possível converter {0} para o tipo '{1}' porque os tipos de parâmetro não correspondem aos tipos de parâmetro delegados

Cannot convert {0} to intended delegate type because some of the return types in the block are not implicitly convertible to the delegate return type Não é possível converter {0} para o tipo delegate pretendido porque alguns dos tipos de retorno no bloco não são implicitamente conversíveis para o tipo de retorno delegate

Since this is an async method, the return expression must be of type '{0}' rather than 'Task<{0}>' Como este é um método assíncrono, a expressão de retorno deve ser do tipo "{0}" em vez de "Task<{0}>"

Cannot convert async {0} to delegate type '{1}'. An async {0} may return void, Task or Task<T>, none of which are convertible to '{1}'. Não é possível converter async {0} para tipo delegate "{1}". Um async {0} podem retornar void, Task ou Task<T>, nenhum dos quais são conversíveis para "{1}".

Fixed size buffer type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double Tipo de buffer de tamanho fixo deve ser um dos valores a seguir: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float ou doublé

Fixed size buffer of length {0} and type '{1}' is too big Buffer de tamanho fixo de comprimento {0} e tipo "{1}" é muito grande

Fixed size buffers must have a length greater than zero O tamanho dos buffers de tamanho fixo deve ser maior que zero

You cannot use fixed size buffers contained in unfixed expressions. Try using the fixed statement. Você não pode usar buffers de tamanho fixo contidos em expressões unfixed. Tente usar a instrução fixed.

Attribute '{0}' is not valid on property or event accessors. It is only valid on '{1}' declarations. Atributo "{0}" não é válido em acessadores de propriedade ou evento. Ele é válido somente em declarações "{1}".

Invalid search path '{0}' specified in '{1}' -- '{2}' Caminho de pesquisa inválido "{0}" especificado em "{1}" -- "{2}"

Invalid search path specified Caminho de pesquisa especificado inválido

__arglist is not valid in this context __arglist não é válido neste contexto

params is not valid in this context params não é válido neste contexto

A namespace declaration cannot have modifiers or attributes Uma declaração de namespace não pode ter modificadores nem atributos

Invalid option '{0}' for /platform; must be anycpu, x86, Itanium, arm, arm64 or x64 Opção inválida '{0}' para /platform; precisa ser anycpu, x86, Itanium, arm, arm64 ou x64

Anonymous methods, lambda expressions, and query expressions inside structs cannot access instance members of 'this'. Consider copying 'this' to a local variable outside the anonymous method, lambda expression or query expression and using the local instead. Métodos anônimos, expressões lambda e expressões de consulta dentro de structs não podem acessar membros de instância de 'this'. Copie 'this' para uma variável local fora do método anônimo, da expressão lambda ou da expressão de consulta e use a local em seu lugar.

'{0}': type used in a using statement must be implicitly convertible to 'System.IDisposable' or implement a suitable 'Dispose' method. '{0}': o tipo usado em uma instrução using precisa ser implicitamente conversível em 'System.IDisposable'.

Parameter {0} must be declared with the '{1}' keyword Parâmetro {0} deve ser declarado com a palavra-chave "{1}"

Parameter {0} should not be declared with the '{1}' keyword Parâmetro {0} não deve ser declarado com a palavra-chave "{1}"

Parameter {0} is declared as type '{1}{2}' but should be '{3}{4}' Parâmetro {0} é declarado como tipo "{1}{2}", mas deve ser "{3}{4}"

Invalid extern alias for '/reference'; '{0}' is not a valid identifier Alias extern inválido para "/reference"; "{0}" não é um identificador válido

Invalid reference alias option: '{0}=' -- missing filename Opção de alias de referência inválida: "{0}=" -- nome de arquivo ausente

You cannot redefine the global extern alias Você não pode redefinir o alias externo global

Reference to type '{0}' claims it is defined in this assembly, but it is not defined in source or any added modules Referência ao tipo "{0}" declara que ele está definido neste assembly, mas não está definido no código-fonte ou quaisquer módulo adicionados

Reference to type '{0}' claims it is defined in '{1}', but it could not be found Referência ao tipo "{0}" declara que ele é definido em "{1}", mas não pode ser encontrado

The predefined type '{0}' is defined in multiple assemblies in the global alias; using definition from '{1}' O tipo pré-definido "{0}" está definido em vários assemblies no alias global; usando definição de "{1}"

Predefined type is defined in multiple assemblies in the global alias O tipo predefinido está definido em vários assemblies no alias global

This error occurs when a predefined system type such as System.Int32 is found in two assemblies. One way this can happen is if you are referencing mscorlib or System.Runtime.dll from two different places, such as trying to run two versions of the .NET Framework side-by-side. Este erro ocorre quando um tipo predefinido do sistema, como System.Int32, encontra-se em dois assemblies. Uma forma que pode fazer isso acontecer é referenciar mscorlib ou System.Runtime.dll de dois lugares diferentes, por exemplo, tentando executar duas versões de .NET Framework lado a lado.

Local '{0}' or its members cannot have their address taken and be used inside an anonymous method or lambda expression Local "{0}" ou seus membros não podem ter seu endereço obtido nem serem usados dentro de uma método anônimo ou expressão lambda

Source file has exceeded the limit of 16,707,565 lines representable in the PDB; debug information will be incorrect O arquivo de origem excedeu o limite de 16.707.565 linhas representáveis no PDB; as informações de depuração estarão incorretas

Cannot convert anonymous method block without a parameter list to delegate type '{0}' because it has one or more out parameters Não é possível converter bloco de métodos anônimos sem uma lista de parâmetros de tipo delegate "{0}" porque ele tem um ou mais parâmetros out

Attribute '{0}' is only valid on methods or attribute classes Atributo "{0}" é somente válido em métodos ou classes de atributo

Accessing a member on '{0}' may cause a runtime exception because it is a field of a marshal-by-reference class Acessar um membro em "{0}" pode causar uma exceção de tempo de execução porque é um campo de uma classe marshal por referência

Accessing a member on a field of a marshal-by-reference class may cause a runtime exception Acessar um membro em um campo de uma classe de empacotamento por referência pode gerar uma exceção de tempo de execução

This warning occurs when you try to call a method, property, or indexer on a member of a class that derives from MarshalByRefObject, and the member is a value type. Objects that inherit from MarshalByRefObject are typically intended to be marshaled by reference across an application domain. If any code ever attempts to directly access the value-type member of such an object across an application domain, a runtime exception will occur. To resolve the warning, first copy the member into a local variable and call the method on that variable. Este aviso ocorre quando você tentar chamar um método, propriedade ou indexador em um membro de uma classe que é derivada de MarshalByRefObject, e o membro é um tipo de valor. Objetos herdados de MarshalByRefObject geralmente são destinados a ser empacotado por referência em um domínio de aplicativo. Se um código tentar acessar o membro de tipo de valor de tal objeto diretamente em um domínio de aplicativo, ocorrerá uma exceção de tempo de execução. Para resolver o aviso, primeiro copie o membro em uma variável local e chame o método nessa variável.

'{0}' is not a valid warning number '"{0}" não é um número de aviso válido

Not a valid warning number Este não um número de aviso válido

A number that was passed to the #pragma warning preprocessor directive was not a valid warning number. Verify that the number represents a warning, not an error. Um número que foi passado para a diretiva de pré-processador de aviso #pragma não era um número de aviso válido. Verifique se o número representa um aviso, não um erro.

Invalid number Número inválido

Invalid filename specified for preprocessor directive. Filename is too long or not a valid filename. Nome de arquivo inválido especificado para a diretiva de pré-processamento. O nome de arquivo é muito longo ou não é um nome válido.

Invalid filename specified for preprocessor directive Nome de arquivo inválido especificado para diretiva de pré-processamento

Invalid #pragma checksum syntax; should be #pragma checksum "filename" "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" "XXXX..." Sintaxe de #pragma checksum inválida; deve ser #pragma checksum "nome_de_arquivo" "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" "XXXX..."

Invalid #pragma checksum syntax Sintaxe de soma de verificação #pragma inválida

Single-line comment or end-of-line expected Comentário de linha única ou final de linha esperado

Single-line comment or end-of-line expected after #pragma directive Comentário de linha única ou final de linha esperado após a diretiva #pragma

Different checksum values given for '{0}' Valores diferentes de checksum fornecidos para "{0}"

Different #pragma checksum values given Valores de soma de verificação #pragma diferentes foram fornecidos

Assembly reference '{0}' is invalid and cannot be resolved Referência do assembly "{0}" é inválida e não pode ser resolvida

Assembly reference is invalid and cannot be resolved A referência de assembly é inválida e não pode ser resolvida

This warning indicates that an attribute, such as InternalsVisibleToAttribute, was not specified correctly. Este aviso indica que um atributo, como InternalsVisibleToAttribute, não foi especificado corretamente.

Assuming assembly reference '{0}' used by '{1}' matches identity '{2}' of '{3}', you may need to supply runtime policy Presumindo que a referência de assembly "{0}" usada por "{1}" corresponde a identidade "{2}" de "{3}", talvez seja necessário fornecer a diretiva de tempo de execução

Assuming assembly reference matches identity Presume-se que a referência do assembly coincide com a identidade

The two assemblies differ in release and/or version number. For unification to occur, you must specify directives in the application's .config file, and you must provide the correct strong name of an assembly. Dois assemblies diferem no número de versão. Para que a união ocorra, você deve especificar as diretivas no arquivo .config do aplicativo e fornecer o nome forte correto de um assembly.

Assuming assembly reference matches identity Presume-se que a referência do assembly coincide com a identidade

Multiple assemblies with equivalent identity have been imported: '{0}' and '{1}'. Remove one of the duplicate references. Vários assemblies com identidade equivalente foram importados: "{0}" e "{1}". Remova uma das referências duplicadas.

An assembly with the same simple name '{0}' has already been imported. Try removing one of the references (e.g. '{1}') or sign them to enable side-by-side. Um assembly com o mesmo nome simples "{0}" já foi importado. Tente remover uma das referências (por exemplo: "{1}") ou assine-as para ativar lado a lado.

Assembly '{0}' with identity '{1}' uses '{2}' which has a higher version than referenced assembly '{3}' with identity '{4}' Assembly "{0}" com identidade "{1}" usa "{2}" que tem uma versão mais recente do que o assembly referenciado "{3}" com identidade "{4}"

Fixed size buffers can only be accessed through locals or fields Buffers de tamanho fixo só podem ser acessados por meio de locais ou campos

XML comment has a duplicate typeparam tag for '{0}' O comentário XML tem uma marca typeparam duplicada para "{0}"

XML comment has a duplicate typeparam tag O comentário XML tem uma marca typeparam duplicada

XML comment has a typeparam tag for '{0}', but there is no type parameter by that name Comentário XML tem uma marga typeparam para "{0}", mas não há parâmetro de tipo por esse nome

XML comment has a typeparam tag, but there is no type parameter by that name O comentário XML tem uma marca typeparam, mas não há nenhum parâmetro com esse nome

XML comment on '{1}' has a typeparamref tag for '{0}', but there is no type parameter by that name Comentário XML em "{1}" tem uma marca de typeparamref para "{0}", mas não há parâmetro de tipo com esse nome

XML comment has a typeparamref tag, but there is no type parameter by that name O comentário XML tem uma marca typeparamref, mas não há nenhum parâmetro de tipo com esse nome

Type parameter '{0}' has no matching typeparam tag in the XML comment on '{1}' (but other type parameters do) Parâmetro de tipo "{0}" não tem marca typeparam correspondente no comentário XML para "{1}" (mas outros parâmetros têm)

Type parameter has no matching typeparam tag in the XML comment (but other type parameters do) O parâmetro de tipo não tem nenhuma marca typeparam correspondente no comentário XML (mas outros parâmetros têm)

'{0}': type must be '{2}' to match overridden member '{1}' '"{0}": tipo deve ser "{2}" para corresponder ao membro substituído "{1}"

Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead. Não use o atributo 'System.Runtime.CompilerServices.FixedBuffer'. Use o modificador de campos 'fixed' em seu lugar.

Assignment made to same variable; did you mean to assign something else? Atribuição feita à mesma variável. Você pretendia atribuir outro elemento?

Assignment made to same variable Atribuição feita à mesma variável

Comparison made to same variable; did you mean to compare something else? Comparação feita com a mesma variável. Você pretendia comparar com outro elemento?

Comparison made to same variable Comparação feita com a mesma variável

Error opening Win32 resource file '{0}' -- '{1}' Erro ao abrir o arquivo de recursos do Win32 "{0}" -- "{1}"

Expression will always cause a System.NullReferenceException because the default value of '{0}' is null Expressão sempre causará uma System.NullReferenceException porque o valor padrão de "{0}" é nulo

Expression will always cause a System.NullReferenceException because the type's default value is null A expressão sempre causa uma System.NullReferenceException porque o valor padrão do tipo é nulo

Class '{0}' cannot have multiple base classes: '{1}' and '{2}' Classe "{0}" não pode ter várias classes base: "{1}" e "{2}"

Base class '{0}' must come before any interfaces Classe base "{0}" deve vir antes de quaisquer interfaces

XML comment has cref attribute '{0}' that refers to a type parameter O comentário XML tem atributo cref "{0}" que refere-se a um parâmetro de tipo

XML comment has cref attribute that refers to a type parameter O comentário XML tem um atributo cref que faz referência a um parâmetro de tipo

Friend assembly reference '{0}' is invalid. InternalsVisibleTo declarations cannot have a version, culture, public key token, or processor architecture specified. Referência do assembly Friend "{0}" é inválido. Declarações InternalsVisibleTo não podem ter uma versão, cultura, token de chave pública ou arquitetura de processador especificada.

Friend assembly reference '{0}' is invalid. Strong-name signed assemblies must specify a public key in their InternalsVisibleTo declarations. Referência do assembly Friend "{0}" é inválida. Assemblies assinados com nome forte devem especificar uma chave pública em suas declarações InternalsVisibleTo.

Cannot bind delegate to '{0}' because it is a member of 'System.Nullable<T>' Não é possível associar o representante a "{0}" porque ele é membro de "System.Nullable<T>"

'{0}' does not contain a constructor that takes {1} arguments '"{0}" não contém um construtor que aceita {1} argumentos

Assembly and module attributes must precede all other elements defined in a file except using clauses and extern alias declarations Os atributos assembly e module devem preceder todos os outros elementos definidos em um arquivo, exceto as cláusulas using e as declarações de alias externas

Expected expression Expressão esperada

Invalid version {0} for /subsystemversion. The version must be 6.02 or greater for ARM or AppContainerExe, and 4.00 or greater otherwise Versão inválida {0} para /subsystemversion. A versão deve ser 6.02 ou posterior para ARM ou AppContainerExe e 4.00 ou superior

Embedded interop method '{0}' contains a body. Método de interoperabilidade inserido "{0}" contém um corpo.

Warning level must be in the range 0-4 O nível de aviso deve estar no intervalo de 0-4

Invalid option '{0}' for /debug; must be 'portable', 'embedded', 'full' or 'pdbonly' Opção '{0}' inválida para /debug; deve ser 'portable', 'embedded', 'full' ou 'pdbonly'

Invalid option '{0}'; Resource visibility must be either 'public' or 'private' Opção inválida "{0}"; Visibilidade de recursos deve ser "public" ou "private"

The type of the argument to the DefaultParameterValue attribute must match the parameter type O tipo do argumento para o atributo DefaultParameterValue deve corresponder ao tipo de parâmetro

Argument of type '{0}' is not applicable for the DefaultParameterValue attribute Argumento do tipo "{0}" não é aplicável para o atributo DefaultParameterValue

Duplicate initialization of member '{0}' Duplicar inicialização do membro "{0}"

Member '{0}' cannot be initialized. It is not a field or property. Membro "{0}" não pode ser inicializado. Não é um campo ou propriedade.

Static field or property '{0}' cannot be assigned in an object initializer Campo estático ou propriedade "{0}" não pode ser atribuído a um inicializador de objeto

Members of readonly field '{0}' of type '{1}' cannot be assigned with an object initializer because it is of a value type Membros do campo de somente leitura "{0}" do tipo "{1}" não podem ser atribuídos com um inicializador de objeto porque ele é de um tipo de valor

Members of property '{0}' of type '{1}' cannot be assigned with an object initializer because it is of a value type Membros da propriedade "{0}" do tipo "{1}" não podem ser atribuídos com um inicializador de objeto porque ele é de um tipo de valor

Unsafe type '{0}' cannot be used in object creation O tipo não seguro "{0}" não pode ser usado na criação do objeto

Element initializer cannot be empty O inicializador de elemento não pode estar vazio

The best overloaded method match for '{0}' has wrong signature for the initializer element. The initializable Add must be an accessible instance method. A melhor correspondência de método sobrecarregado para "{0}" tem assinatura errada para o elemento do inicializador. O Add inicializável deve ser um método de instância acessível.

Cannot initialize type '{0}' with a collection initializer because it does not implement 'System.Collections.IEnumerable' Não é possível inicializar o tipo "{0}" com um inicializador de coleta porque ele não implementa "System.Collections.IEnumerable"

Error reading Win32 manifest file '{0}' -- '{1}' Erro ao ler o arquivo de manifesto Win32 "{0}" -- "{1}"

Ignoring /win32manifest for module because it only applies to assemblies Ignore /win32manifest do módulo porque ele só se aplica aos assemblies

'{0}' does not contain a definition for '{1}' and the best extension method overload '{2}' requires a receiver of type '{3}' '"{0}" não contém uma definição para "{1}" e a melhor sobrecarga do método de extensão "{2}" requer um receptor do tipo "{3}"

The range variable '{0}' has already been declared A variável de intervalo "{0}" já foi declarada

The range variable '{0}' conflicts with a previous declaration of '{0}' A variável de intervalo "{0}" está em conflito com uma declaração anterior de "{0}"

Cannot assign {0} to a range variable Não é possível atribuir {0} a uma variável de intervalo

Could not find an implementation of the query pattern for source type '{0}'. '{1}' not found. Consider explicitly specifying the type of the range variable '{2}'. Não foi possível encontrar uma implementação do padrão de consulta para o tipo de origem "{0}". "{1}" não encontrado. Considere especificar explicitamente o tipo da variável de intervalo "{2}".

Could not find an implementation of the query pattern for source type '{0}'. '{1}' not found. Are you missing a reference to 'System.Core.dll' or a using directive for 'System.Linq'? Não foi possível encontrar uma implementação do padrão de consulta para o tipo de origem "{0}". "{1}" não encontrado. Está faltando uma referência a "System.Core.dll" ou uma diretiva using para "System.Linq"?

Could not find an implementation of the query pattern for source type '{0}'. '{1}' not found. Não foi possível encontrar uma implementação do padrão de consulta para o tipo de origem "{0}". "{1}" não encontrado.

The name '{0}' is not in scope on the left side of 'equals'. Consider swapping the expressions on either side of 'equals'. O nome "{0}" não está no escopo à esquerda de "equals". Considere trocar as expressões em cada lado de "equals".

The name '{0}' is not in scope on the right side of 'equals'. Consider swapping the expressions on either side of 'equals'. O nome "{0}" não está no escopo à direita de "equals". Considere trocar as expressões em cada lado de "equals".

Cannot pass the range variable '{0}' as an out or ref parameter Não é possível passar a variável de intervalo "{0}" como um parâmetro out ou ref

Multiple implementations of the query pattern were found for source type '{0}'. Ambiguous call to '{1}'. Várias implementações do padrão de consulta foram encontradas para o tipo de origem "{0}". Chamada ambígua para "{1}".

The type of one of the expressions in the {0} clause is incorrect. Type inference failed in the call to '{1}'. O tipo de uma das expressões na cláusula {0} está incorreto. Inferência de tipos falhou na chamada para "{1}".

The type of the expression in the {0} clause is incorrect. Type inference failed in the call to '{1}'. O tipo da expressão na cláusula {0} está incorreto. Inferência de tipos falhou na chamada para "{1}".

An expression of type '{0}' is not allowed in a subsequent from clause in a query expression with source type '{1}'. Type inference failed in the call to '{2}'. Uma expressão do tipo "{0}" não é permitida em um subsequente da cláusula em uma expressão de consulta com o tipo de origem "{1}". Inferência de tipos falhou na chamada para "{2}".

An expression tree may not contain an unsafe pointer operation Uma árvore de expressão não pode conter uma operação de ponteiro inseguro

An expression tree may not contain an anonymous method expression Uma árvore de expressão não pode conter uma expressão de método anônimo

An anonymous method expression cannot be converted to an expression tree Uma expressão de método anônimo não pode ser convertida em uma árvore de expressão

Range variable '{0}' cannot be assigned to -- it is read only A variável de intervalo "{0}" não pode ser atribuída a -- ela é de somente leitura

The range variable '{0}' cannot have the same name as a method type parameter A variável de intervalo "{0}" não pode ter o mesmo nome de um parâmetro de tipo de método

The contextual keyword 'var' cannot be used in a range variable declaration A palavra-chave contextual 'var' não pode ser usada em uma declaração de variável de intervalo

The best overloaded Add method '{0}' for the collection initializer has some invalid arguments O melhor método Add sobrecarregado "{0}" do inicializador de coleção tem alguns argumentos inválidos

An expression tree lambda may not contain a ref, in or out parameter Uma árvore de expressão da expressão lambda não pode conter um parâmetro ref, in ou out

An expression tree lambda may not contain a method with variable arguments Uma árvore de expressão da expressão lambda não pode conter um método com argumentos variáveis

An expression tree lambda may not contain a method group Uma árvore de expressão da expressão lambda não pode conter um grupo de métodos

The best overloaded method match '{0}' for the collection initializer element cannot be used. Collection initializer 'Add' methods cannot have ref or out parameters. A melhor correspondência de método sobrecarregado "{0}" do elemento de inicializador de coleção não pode ser usada. Os métodos "Add" do inicializador de coleção não podem ter os parâmetros ref ou out.

Non-invocable member '{0}' cannot be used like a method. O membro não invocável "{0}" não pode ser usado como um método.

Member '{0}' implements interface member '{1}' in type '{2}'. There are multiple matches for the interface member at run-time. It is implementation dependent which method will be called. Membro "{0}" implementa membro de interface "{1}" no tipo "{2}". Há várias correspondências para o membro de interface em tempo de execução. Ele é dependente de implementação cujo método será chamado.

Member implements interface member with multiple matches at run-time O membro implementa o membro de interface com várias correspondências no tempo de execução

This warning can be generated when two interface methods are differentiated only by whether a particular parameter is marked with ref or with out. It is best to change your code to avoid this warning because it is not obvious or guaranteed which method is called at runtime. Although C# distinguishes between out and ref, the CLR sees them as the same. When deciding which method implements the interface, the CLR just picks one. Give the compiler some way to differentiate the methods. For example, you can give them different names or provide an additional parameter on one of them. Esse aviso pode ser gerado quando dois métodos de interface são diferenciados somente por se um determinado parâmetro é marcado com ref ou out. É aconselhável alterar o código para evitar este aviso porque não fica óbvio ou garantido qual método é chamado no tempo de execução. Embora C# faça a distinção entre out e ref, o CLR os vê da mesma forma. Ao decidir qual método implementa a interface, o CLR simplesmente escolhe um deles. Forneça ao compilador alguma forma de diferenciar os métodos. Por exemplo, você pode dar-lhes nomes diferentes ou fornecer um parâmetro adicional em um deles.

Member '{1}' overrides '{0}'. There are multiple override candidates at run-time. It is implementation dependent which method will be called. Membro "{1}" substitui "{0}". Há vários candidatos de substituição em tempo de execução. Ele é dependente de implementação cujo método que será chamado.

Member overrides base member with multiple override candidates at run-time O membro substitui o membro base com vários candidatos à substituição no tempo de execução

Object and collection initializer expressions may not be applied to a delegate creation expression As expressões de objeto e de inicializador de coleção não podem ser aplicadas a uma expressão de criação de representante

'{0}' is of type '{1}'. The type specified in a constant declaration must be sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, string, an enum-type, or a reference-type. '"{0}" é do tipo "{1}". O tipo especificado em uma declaração constante deve ser sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, cadeia de caracteres, um tipo enum ou um tipo de referência.

Source file '{0}' could not be found. Arquivo de origem "{0}" não pode ser encontrado.

Source file '{0}' specified multiple times Arquivo de origem "{0}" especificado várias vezes

Source file specified multiple times Arquivo de origem especificado várias vezes

Missing file specification for '{0}' option Falta a especificação de arquivo para "{0}" opção

Command-line syntax error: Missing '{0}' for '{1}' option Erro de sintaxe de linha de comando: "{0}" ausente para a opção "{1}"

Unrecognized option: '{0}' Opção não reconhecida: "{0}"

No source files specified. Nenhum arquivo de origem especificado.

No source files specified Nenhum arquivo de origem especificado

Expected a script (.csx file) but none specified Era esperado um script (arquivo .csx), mas não há scripts especificados

Error opening response file '{0}' Erro ao abrir arquivo de resposta "{0}"

Cannot open '{0}' for writing -- '{1}' Não é possível abrir "{0}" para escrever -- "{1}"

Invalid image base number '{0}' Número base de imagem inválido "{0}"

'{0}' is a binary file instead of a text file '"{0}" é um arquivo binário em vez de um arquivo de texto

Code page '{0}' is invalid or not installed Página de código "{0}" é inválida ou não está instalada

Algorithm '{0}' is not supported Algoritmo '{0}' sem suporte

Cannot specify /main if building a module or library Não é possível especificar /main se criar um módulo ou uma biblioteca

Invalid target type for /target: must specify 'exe', 'winexe', 'library', or 'module' Tipo de destino inválido para /target: deve especificar "exe", "winexe", "library" ou "module"

Ignoring /noconfig option because it was specified in a response file Ignorando a opção /noconfig porque ela foi especificada em um arquivo de resposta

Invalid file section alignment '{0}' Alinhamento de seção de arquivo inválido '{0}'

Invalid output name: {0} Nome de saída inválido: {0}

Invalid debug information format: {0} Formato de informações de depuração inválidas: {0}

'id#' syntax is no longer supported. Use '$id' instead. 'A sintaxe de 'id#' não tem mais suporte. Use '$id'.

Invalid name for a preprocessing symbol; '{0}' is not a valid identifier Nome inválido para um símbolo de pré-processamento. '{0}' não é um identificador válido

Invalid name for a preprocessing symbol; not a valid identifier Nome inválido para um símbolo de pré-processamento; ele não é um identificador válido

Cannot create short filename '{0}' when a long filename with the same short filename already exists Não é possível criar nome de arquivo curto "{0}" quando já existe um nome de arquivo longo com o mesmo nome de arquivo curto

A /reference option that declares an extern alias can only have one filename. To specify multiple aliases or filenames, use multiple /reference options. Uma opção /reference que declara um alias externo só pode ter um nome de arquivo. Para especificar vários aliases ou nomes de arquivo, use várias opções /reference.

Command-line syntax error: Missing ':<number>' for '{0}' option Erro de sintaxe de linha de comando: ":<number>" ausente para a opção "{0}"

The /pdb option requires that the /debug option also be used A opção /pdb requer que a opção /debug também seja usada

An expression tree lambda may not contain a COM call with ref omitted on arguments Uma árvore de expressão da expressão lambda não pode conter uma chamada COM com a omissão de ref nos argumentos

Command-line syntax error: Invalid Guid format '{0}' for option '{1}' Erro de sintaxe de linha de comando: Formato de Guid inválido "{0}" para a opção "{1}"

Command-line syntax error: Missing Guid for option '{1}' Erro de sintaxe de linha de comando: falta Guid para a opção "{1}"

Methods with variable arguments are not CLS-compliant Métodos com argumentos de variável não estão em conformidade com CLS

Argument type '{0}' is not CLS-compliant Tipo de argumento "{0}" não tem conformidade com CLS

Argument type is not CLS-compliant Tipo de argumento não tem conformidade com CLS

Return type of '{0}' is not CLS-compliant Tipo de retorno de "{0}" não tem conformidade com CLS

Return type is not CLS-compliant Tipo de retorno não tem conformidade com CLS

Type of '{0}' is not CLS-compliant Tipo de "{0}" não tem conformidade com CLS

Type is not CLS-compliant Tipo tem conformidade com CLS

A public, protected, or protected internal variable must be of a type that is compliant with the Common Language Specification (CLS). Uma variável pública, protegida ou protegida internamente deve ser de um tipo em conformidade com a Common Language Specification (CLS).

Identifier '{0}' differing only in case is not CLS-compliant Identificador "{0}" diferindo somente se não tem conformidade com CLS

Identifier differing only in case is not CLS-compliant O identificador difere somente quando não tem conformidade com CLS

Overloaded method '{0}' differing only in ref or out, or in array rank, is not CLS-compliant Metódo sobrecarregado "{0}" diferindo somente em ref ou out, ou em classificação de matriz não tem conformidade com CLS

Overloaded method differing only in ref or out, or in array rank, is not CLS-compliant O método sobrecarregado diferindo somente em ref ou out, ou a classificação de matriz, não tem conformidade com CLS

Overloaded method '{0}' differing only by unnamed array types is not CLS-compliant Metódo sobrecarregado "{0}" diferindo somente por tipos de matriz não nomeados não tem conformidade com CLS

Overloaded method differing only by unnamed array types is not CLS-compliant O método sobrecarregado diferindo somente pelos tipos de matriz sem nome não tem conformidade com CLS

This error occurs if you have an overloaded method that takes a jagged array and the only difference between the method signatures is the element type of the array. To avoid this error, consider using a rectangular array rather than a jagged array; use an additional parameter to disambiguate the function call; rename one or more of the overloaded methods; or, if CLS Compliance is not needed, remove the CLSCompliantAttribute attribute. Este erro ocorre se você tiver um método sobrecarregado que usa uma matriz denteada e a única diferença entre as assinaturas do método é o tipo de elemento da matriz. Para evitar esse erro, considere usar uma matriz retangular em vez de uma matriz denteada, usar um parâmetro adicional para desambiguar a chamada de função, renomear um ou mais dos métodos sobrecarregados ou, se não for necessária conformidade com CLS, remova o atributo CLSCompliantAttribute.

Identifier '{0}' is not CLS-compliant Identificador "{0}" não tem conformidade com CLS

Identifier is not CLS-compliant Identificador não tem conformidade com CLS

'{0}': base type '{1}' is not CLS-compliant '"{0}": tipo base "{1}" não tem conformidade com CLS

Base type is not CLS-compliant Tipo base não tem conformidade com CLS

A base type was marked as not having to be compliant with the Common Language Specification (CLS) in an assembly that was marked as being CLS compliant. Either remove the attribute that specifies the assembly is CLS compliant or remove the attribute that indicates the type is not CLS compliant. Um tipo base foi marcado como sem necessidade de estar em conformidade com a Common Language Specification (CLS) em um assembly que foi marcado como em conformidade com CLS. Remova o atributo que especifica que o assembly está em conformidade com CLS ou aquele que indica que o tipo não tem conformidade com CLS.

'{0}': CLS-compliant interfaces must have only CLS-compliant members '"{0}": Interfaces em conformidade com CLS devem ter somente membros em conformidade com CLS

CLS-compliant interfaces must have only CLS-compliant members Interfaces em conformidade com CLS devem ter somente membros em conformidade com CLS

'{0}': only CLS-compliant members can be abstract '"{0}": somente membros em conformidade com CLS podem ser abstratos

Only CLS-compliant members can be abstract Somente membros em conformidade com CLS podem ser abstratos

You must specify the CLSCompliant attribute on the assembly, not the module, to enable CLS compliance checking Especifique o atributo CLSCompliant no assembly, não no módulo, para habilitar a verificação de conformidade com CLS

Added modules must be marked with the CLSCompliant attribute to match the assembly Módulos adicionados devem ser marcados com o atributo CLSCompliant para corresponder ao assembly

'{0}' cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute '"{0}" não pode ser marcado como em comformidade com CLS porque o assembly não tem um atributo CLSCompliant

Type or member cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute O tipo ou membro não pode ser marcado como em comformidade com CLS porque o assembly não possui um atributo CLSCompliant

'{0}' has no accessible constructors which use only CLS-compliant types '"{0}" não tem construtores acessíveis que usam somente tipos em conformidade com CLS

Type has no accessible constructors which use only CLS-compliant types O tipo não tem nenhum construtor acessível que use somente tipos em conformidade com CLS

Arrays as attribute arguments is not CLS-compliant Matrizes como argumentos de atributo não tem conformidade com CLS

You cannot specify the CLSCompliant attribute on a module that differs from the CLSCompliant attribute on the assembly Você não pode especificar o atributo CLSCompliant em um módulo diferente do atributo CLSCompliant no assembly

'{0}' cannot be marked as CLS-compliant because it is a member of non-CLS-compliant type '{1}' '"{0}" não pode ser marcado como em conformidade com CLS porque é membro do tipo não tem conformidade com CLS "{1}"

Type cannot be marked as CLS-compliant because it is a member of non-CLS-compliant type O tipo não pode ser marcado como em conformidade com CLS por ser membro de um tipo sem conformidade com CLS

CLS compliance checking will not be performed on '{0}' because it is not visible from outside this assembly Verificação de compatibilidade com CLS não será executada em "{0}" porque ele não é visível de fora deste assembly

CLS compliance checking will not be performed because it is not visible from outside this assembly A verificação de compatibilidade com CLS não será executada porque ela não é vista de fora deste assembly

'{0}' does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute '"{0}" não necessista de um atributo CLSCompliant porque o assembly não tem um atributo CLSCompliant

Type or member does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute O tipo ou membro não precisa de um atributo CLSCompliant porque o assembly não possui um atributo CLSCompliant

CLSCompliant attribute has no meaning when applied to parameters. Try putting it on the method instead. O atributo CLSCompliant não tem sentido quando aplicado a parâmetros. Tente colocá-lo no método.

CLSCompliant attribute has no meaning when applied to parameters O atributo CLSCompliant não tem sentido quando aplicado a parâmetros

CLSCompliant attribute has no meaning when applied to return types. Try putting it on the method instead. O atributo CLSCompliant não tem sentido quando aplicado a tipos de retorno. Tente colocá-lo no método.

CLSCompliant attribute has no meaning when applied to return types O atributo CLSCompliant não tem sentido quando aplicado a tipos de retorno

Constraint type '{0}' is not CLS-compliant Tipo de restrição "{0}" não tem conformidade com CLS

Constraint type is not CLS-compliant Tipo de restrição não tem conformidade com CLS

CLS-compliant field '{0}' cannot be volatile Campo em conformidade com CLS "{0}" não pode ser volátil

CLS-compliant field cannot be volatile Campo em conformidade com CLS não pode ser volátil

'{0}' is not CLS-compliant because base interface '{1}' is not CLS-compliant '"{0}" não tem conformidade com CLS porque a interface base "{1}" não tem conformidade com CLS

Type is not CLS-compliant because base interface is not CLS-compliant O tipo não tem conformidade com CLS porque a interface base não tem conformidade com CLS

'await' requires that the type {0} have a suitable 'GetAwaiter' method 'await' requer que o tipo {0} tenha um método 'GetAwaiter' adequado

Cannot await '{0}' Não é possível aguardar "{0}"

'await' requires that the return type '{0}' of '{1}.GetAwaiter()' have suitable 'IsCompleted', 'OnCompleted', and 'GetResult' members, and implement 'INotifyCompletion' or 'ICriticalNotifyCompletion' 'await' requer que o tipo de retorno '{0}' de '{1}.GetAwaiter()' tenha membros 'IsCompleted', 'OnCompleted' e 'GetResult' adequados e implemente 'INotifyCompletion' ou 'ICriticalNotifyCompletion'

'await' requires that the type '{0}' have a suitable 'GetAwaiter' method. Are you missing a using directive for 'System'? 'await' requer que o tipo '{0}' tenha um método 'GetAwaiter' adequado. Está faltando uma diretiva using para 'System'?

Cannot await 'void' Não é possível aguardar "void"

'await' cannot be used as an identifier within an async method or lambda expression 'await' não pode ser usado como um identificador em um método assíncrono ou em uma expressão lambda

'{0}' does not implement '{1}' '"{0}" não implementa "{1}"

Since '{0}' is an async method that returns 'Task', a return keyword must not be followed by an object expression. Did you intend to return 'Task<T>'? Como "{0}" é um método assíncrono que retorna "Task", uma palavra-chave return não deve ser seguida por uma expressão de objeto. Você pretendia retornar "Task<T>"?

The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T> O tipo de retorno de um método assíncrono precisa ser nulo, Task, Task<T>, um tipo semelhante à tarefa, IAsyncEnumerable<T> ou IAsyncEnumerator<T>

Cannot return an expression of type 'void' Não é possível retornar uma expressão do tipo 'void'

__arglist is not allowed in the parameter list of async methods __arglist não é permitido na lista de parâmetros dos métodos assíncronos

'await' cannot be used in an expression containing the type '{0}' 'aguardar' não pode ser usado em uma expressão que contém o tipo '{0}'

Async methods cannot have unsafe parameters or return types Os métodos assíncronos não podem ter parâmetros ou tipos de retorno sem segurança

Async methods cannot have ref, in or out parameters Os métodos assíncronos não podem ter parâmetros ref, in ou out

The 'await' operator can only be used when contained within a method or lambda expression marked with the 'async' modifier O operador 'await' só poderá ser usado quando contido em um método ou expressão lambda marcada com o modificador 'async'

The 'await' operator can only be used within an async {0}. Consider marking this {0} with the 'async' modifier. O operador "await" pode somente ser usado em async {0}. Considere a possibilidade de marcar este {0} com o modificador "async".

The 'await' operator can only be used within an async method. Consider marking this method with the 'async' modifier and changing its return type to 'Task<{0}>'. O operador "await" pode somente ser usado em um método assíncrono. Considere a possibilidade de marcar este método com o modificador "async" e alterar seu tipo de retorno para "Task<{0}>".

The 'await' operator can only be used within an async method. Consider marking this method with the 'async' modifier and changing its return type to 'Task'. O operador 'await' só pode ser usado em um método assíncrono. Considere marcar esse método com o modificador 'async' e alterar seu tipo de retorno para 'Task'.

Cannot await in the body of a finally clause Não é possível esperar no corpo de uma cláusula finally

Cannot await in a catch clause Não é possível aguardar em uma cláusula catch

Cannot await in the filter expression of a catch clause Não é possível aguardar na expressão do filtro de uma cláusula catch

Cannot await in the body of a lock statement Não é possível aguardar no corpo de uma instrução lock

The 'await' operator cannot be used in a static script variable initializer. O operador 'await' não pode ser usado em um inicializador de variável de script estático.

Cannot await in an unsafe context Não é possível esperar em um contexto sem segurança

The 'async' modifier can only be used in methods that have a body. O modificador 'async' só pode ser usado em métodos que têm um corpo.

Parameters or locals of type '{0}' cannot be declared in async methods or lambda expressions. Parâmetros ou locais do tipo "{0}" não podem ser declarados em métodos assíncronos ou expressões lambda.

foreach statement cannot operate on enumerators of type '{0}' in async or iterator methods because '{0}' is a ref struct. a instrução foreach não pode operar em enumeradores do tipo '{0}' em métodos assíncronos ou iteradores porque '{0}' é uma struct de referência.

Security attribute '{0}' cannot be applied to an Async method. Atributo de segurança "{0}" não pode ser aplicado a um método Assíncrono.

Async methods are not allowed in an Interface, Class, or Structure which has the 'SecurityCritical' or 'SecuritySafeCritical' attribute. Métodos assíncronos não são permitidos em uma Interface, Classe ou Estrutura que tem o atributo "SecurityCritical" ou "SecuritySafeCritical".

The 'await' operator may only be used in a query expression within the first collection expression of the initial 'from' clause or within the collection expression of a 'join' clause O operador 'await' só pode ser usado em uma expressão de consulta na primeira expressão de coleção da cláusula 'from' inicial ou na expressão de coleção de uma cláusula 'join'

This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread. Este método assíncrono não possui operadores 'await' e será executado de modo síncrono. É recomendável o uso do operador 'await' para aguardar chamadas à API desbloqueadas ou do operador 'await Task.Run(...)' para realizar um trabalho associado à CPU em um thread em segundo plano.

Async method lacks 'await' operators and will run synchronously O método assíncrono não possui operadores 'await' e será executado de forma síncrona

Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call. Como esta chamada não é aguardada, a execução do método atual continua antes da conclusão da chamada. Considere aplicar o operador 'await' ao resultado da chamada.

Because this call is not awaited, execution of the current method continues before the call is completed Como esta chamada não é esperada, a execução do método atual continua antes de a chamada ser concluída

The current method calls an async method that returns a Task or a Task<TResult> and doesn't apply the await operator to the result. The call to the async method starts an asynchronous task. However, because no await operator is applied, the program continues without waiting for the task to complete. In most cases, that behavior isn't what you expect. Usually other aspects of the calling method depend on the results of the call or, minimally, the called method is expected to complete before you return from the method that contains the call. An equally important issue is what happens to exceptions that are raised in the called async method. An exception that's raised in a method that returns a Task or Task<TResult> is stored in the returned task. If you don't await the task or explicitly check for exceptions, the exception is lost. If you await the task, its exception is rethrown. As a best practice, you should always await the call. You should consider suppressing the warning only if you're sure that you don't want to wait for the asynchronous call to complete and that the called method won't raise any exceptions. In that case, you can suppress the warning by assigning the task result of the call to a variable. O método atual chama um método assíncrono que retorna uma Tarefa ou uma Tarefa<TResult> e não aplica o operador "await" ao resultado. A chamada ao método assíncrono inicia uma tarefa assíncrona. No entanto, como o operador "await" está aplicado, o programa continua sem aguardar a conclusão da tarefa. Na maioria dos casos, você não deseja esse comportamento. Geralmente, outros aspectos do método da chamada dependem dos resultados da chamada ou, no mínimo, espera-se que o método chamado seja concluído antes que você volte do método que contém a chamada. Outra questão importante é o que acontece com as exceções que são acionadas no método assíncrono chamado. As exceções acionadas em métodos que retornam uma Task ou Task<TResult> são armazenadas na tarefa retornada. Se você não aguardar a tarefa ou verificar explicitamente se há exceções, a exceção se perde. Se você aguardar a tarefa, a exceção é gerada novamente. Como melhor prática, recomendamos que você sempre aguarde a chamada. Você pode suprimir o aviso se tiver certeza de que não vai querer aguardar a conclusão da chamada assíncrona e de que o método da chamada não gerará exceções. Nesse caso, você pode atribuir o resultado de uma tarefa da chamada a uma variável para suprimir o aviso.

'MethodImplOptions.Synchronized' cannot be applied to an async method 'Não é possível aplicar 'MethodImplOptions.Synchronized' a um método assíncrono

CallerLineNumberAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}' CallerLineNumberAttribute não pode ser aplicado porque não há conversões padrões do tipo "{0}" para o tipo "{1}"

CallerFilePathAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}' CallerFilePathAttribute não pode ser aplicado porque não há conversões padrões do tipo "{0}" para o tipo "{1}"

CallerMemberNameAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}' CallerMemberNameAttribute não pode ser aplicado porque não há conversões padrões do tipo "{0}" para o tipo "{1}"

The CallerLineNumberAttribute may only be applied to parameters with default values O CallerLineNumberAttribute só pode ser aplicado a parâmetros com valores padrão

The CallerFilePathAttribute may only be applied to parameters with default values O CallerFilePathAttribute só pode ser aplicado a parâmetros com valores padrão

The CallerMemberNameAttribute may only be applied to parameters with default values O CallerMemberNameAttribute só pode ser aplicado a parâmetros com valores padrão

The CallerLineNumberAttribute applied to parameter '{0}' will have no effect because it applies to a member that is used in contexts that do not allow optional arguments O CallerLineNumberAttribute aplicado ao parâmetro "{0}" não terá efeito porque ele se aplica a um membro que é usado em contextos que não permitem argumentos opcionais

The CallerLineNumberAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments O CallerLineNumberAttribute não tem efeito porque ele se aplica a um membro que é usado em contextos que não aceitam argumentos opcionais

The CallerFilePathAttribute applied to parameter '{0}' will have no effect because it applies to a member that is used in contexts that do not allow optional arguments O atributo CallerFilePathAttribute aplicado ao parâmetro "{0}" não terá efeito porque ele se aplica a um membro que é usado em contextos que não permitem o uso de argumentos opcionais

The CallerFilePathAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments O atributo CallerFilePathAttribute não terá efeito porque ele se aplica a um membro que é usado em contextos que não permitem o uso de argumentos opcionais

The CallerMemberNameAttribute applied to parameter '{0}' will have no effect because it applies to a member that is used in contexts that do not allow optional arguments O CallerMemberNameAttribute aplicado ao parâmetro "{0}" não terá efeito porque ele se aplica a um membro que é usado em contextos que não permitem argumentos opcionais

The CallerMemberNameAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments O CallerMemberNameAttribute não tem efeito porque ele se aplica a um membro que é usado em contextos que não aceitam argumentos opcionais

Program does not contain a static 'Main' method suitable for an entry point Programa não contém um método "Main" estático adequado para um ponto de entrada

An array initializer of length '{0}' is expected Inicializador de matriz de comprimento "{0}" é esperado

A nested array initializer is expected Esperava-se um inicializador de matriz aninhada

Invalid variance modifier. Only interface and delegate type parameters can be specified as variant. Modificador de variação inválido. Apenas os parâmetros do tipo de representante e de interface podem ser especificados como variante.

Unexpected use of an aliased name Uso inesperado de um nome com alias

Unexpected use of a generic name Uso inesperado de um nome genérico

Unexpected use of an unbound generic name Uso inesperado de um nome genérico não associado

Expressions and statements can only occur in a method body Expressões e instruções podem ocorrer somente em um corpo de método

An array access may not have a named argument specifier Um acesso à matriz não pode ter um especificador de argumento nomeado

This language feature ('{0}') is not yet implemented. Esse recurso de idioma ("{0}") ainda não está implementado.

Default values are not valid in this context. Valores padrão não são válidos neste contexto.

Error opening icon file {0} -- {1} Erro ao abrir o arquivo de ícones {0} -- {1}

Error opening Win32 manifest file {0} -- {1} Erro ao abrir o arquivo de manifesto Win32 {0} -- {1}

Error building Win32 resources -- {0} Erro ao compliar recursos do Win32 -- {0}

Optional parameters must appear after all required parameters Os parâmetros opcionais devem aparecer após todos os parâmetros necessários

Cannot inherit interface '{0}' with the specified type parameters because it causes method '{1}' to contain overloads which differ only on ref and out Não é possível herdar a interface "{0}" com os parâmetros do tipo especificado porque isso faz com que o método "{1}" contenha sobrecargas que diferem somente em ref e out

Partial declarations of '{0}' must have the same type parameter names and variance modifiers in the same order Declarações parciais de "{0}" devem ter os mesmos nomes de parâmetro de tipo e modificadores de variação na mesma ordem

Invalid variance: The type parameter '{1}' must be {3} valid on '{0}'. '{1}' is {2}. Variação inválida: O parâmetro do tipo "{1}" deve ser {3} válido em "{0}". "{1}" é {2}.

'{0}': cannot derive from the dynamic type '"{0}": não é possível derivar do tipo dinâmico

'{0}': cannot implement a dynamic interface '{1}' '"{0}": não é possível implementar uma interface dinâmica "{1}"

Constraint cannot be the dynamic type A restrição não pode ser o tipo dinâmico

Constraint cannot be a dynamic type '{0}' Restrição não pode ser um tipo dinâmico "{0}"

One or more types required to compile a dynamic expression cannot be found. Are you missing a reference? Não é possível encontrar um ou mais tipos necessários para compilar uma expressão dinâmica. Está precisando de uma referência?

Name '{0}' exceeds the maximum length allowed in metadata. Nome "{0}" excede o comprimento máximo permitido em metadados.

Attributes are not valid in this context. Atributos não são válidos neste contexto.

'extern alias' is not valid in this context '"alias externo" não é válido neste contexto

Using '{0}' to test compatibility with '{1}' is essentially identical to testing compatibility with '{2}' and will succeed for all non-null values Usar "{0}" para testar a compatibilidade com "{1}" é essencialmente idêntico testar compatibilidade com "{2}" e terá êxito para todos os valores não-nulos

Using 'is' to test compatibility with 'dynamic' is essentially identical to testing compatibility with 'Object' Usar 'is' para testar a compatibilidade com 'dynamic' é essencialmente o mesmo que o teste de compatibilidade com 'Object'

Cannot use 'yield' in top-level script code Não é possível usar 'yield' no código de script de nível superior

Cannot declare namespace in script code Você não pode declarar o namespace no código de script

Assembly and module attributes are not allowed in this context Atributos assembly e module não são permitidos neste contexto

Delegate '{0}' has no invoke method or an invoke method with a return type or parameter types that are not supported. Delegado "{0}" não tem método invoke ou um método invoke com um tipo de retorno ou tipos de parâmetros que não são suportados.

The entry point of the program is global script code; ignoring '{0}' entry point. O ponto de entrada do programa é o código de script global; ignorando "{0}" ponto de entrada.

The entry point of the program is global script code; ignoring entry point O ponto de entrada do programa é o código de script global; ignorando o ponto de entrada

The second operand of an 'is' or 'as' operator may not be static type '{0}' O segundo operando de um operador "is" ou "as" não pode ser do tipo estático "{0}"

Inconsistent accessibility: event type '{1}' is less accessible than event '{0}' Acessibilidade inconsistente: tipo de evento "{1}" é menos acessível do que o evento "{0}"

Named argument specifications must appear after all fixed arguments have been specified. Please use language version {0} or greater to allow non-trailing named arguments. As especificações de argumentos nomeados devem aparecer depois que todos os argumentos fixos forem especificados. Use a versão de linguagem {0} ou maior permitir argumentos nomeados que não estejam à direita.

Named argument specifications must appear after all fixed arguments have been specified in a dynamic invocation. As especificações de argumentos nomeados devem aparecer depois que todos os argumentos fixos forem especificados em uma invocação dinâmica.

The best overload for '{0}' does not have a parameter named '{1}' A melhor sobrecarga de "{0}" não tem um parâmetro chamado "{1}"

The delegate '{0}' does not have a parameter named '{1}' O representante "{0}" não tem um parâmetro chamado "{1}"

Named argument '{0}' cannot be specified multiple times O argumento nomeado "{0}" não pode ser especificado várias vezes

Named argument '{0}' specifies a parameter for which a positional argument has already been given O argumento nomeado "{0}" especifica um parâmetro para o qual já foi atribuído um argumento posicional

Named argument '{0}' is used out-of-position but is followed by an unnamed argument O argumento nomeado '{0}' é usado fora de posição, mas é seguido por um argumento sem nome

Cannot specify default parameter value in conjunction with DefaultParameterAttribute or OptionalAttribute Não é possível especificar um valor de parâmetro padrão junto com DefaultParameterAttribute ou OptionalAttribute

Default parameter value for '{0}' must be a compile-time constant Valor do parâmetro padrão "{0}" deve ser uma constante de tempo de compilação

A ref or out parameter cannot have a default value Um parâmetro ref ou out não pode ter um valor padrão

Cannot specify a default value for the 'this' parameter Não é possível especificar um valor padrão para o parâmetro 'this'

Cannot specify a default value for a parameter array Não é possível especificar um valor padrão para uma matriz de parâmetros

A value of type '{0}' cannot be used as a default parameter because there are no standard conversions to type '{1}' Um valor de tipo "{0}" não pode ser usado como um parâmetro padrão porque não há conversões padrões para o tipo "{1}"

A value of type '{0}' cannot be used as default parameter for nullable parameter '{1}' because '{0}' is not a simple type Um valor do tipo "{0}" não pode ser usado como parâmetro padrão para parâmetro anulável "{1}" porque "{0}" não é um tipo simples

'{0}' is of type '{1}'. A default parameter value of a reference type other than string can only be initialized with null '"{0}" é do tipo "{1}". Um valor de parâmetro padrão de um tipo de referência diferente de cadeia de caracteres pode somente ser inicializado com null

The default value specified for parameter '{0}' will have no effect because it applies to a member that is used in contexts that do not allow optional arguments O valor padrão especificado para o parâmetro "{0}" não terá efeito porque ele se aplica a um membro que é usado em contextos que não permitem argumentos opcionais

The default value specified will have no effect because it applies to a member that is used in contexts that do not allow optional arguments O valor padrão especificado não tem efeito porque ele se aplica a um membro que é usado em contextos que não aceitam argumentos opcionais

Error signing output with public key from file '{0}' -- {1} Erro ao assinar a saída com a chave pública do arquivo "{0}" -- {1}

Error signing output with public key from container '{0}' -- {1} Erro ao assinar a saída com a chave pública do recipiente "{0}" -- {1}

The typeof operator cannot be used on the dynamic type O operador typeof não pode ser usado no tipo dinâmico

An expression tree may not contain a dynamic operation Uma árvore de expressões não pode conter uma operação dinâmica

Async lambda expressions cannot be converted to expression trees As expressões lambda assíncronas não podem ser convertidas em árvores de expressões

Cannot define a class or member that utilizes 'dynamic' because the compiler required type '{0}' cannot be found. Are you missing a reference? Não é possível definir uma classe ou membro que utiliza "dynamic" porque o tipo necessário pelo compilador "{0}" não pode ser encontrado.

Cannot pass null for friend assembly name Não é possível passar null para nome de assembly amigável

Key file '{0}' is missing the private key needed for signing Arquivo de chave "{0}" está sem a chave portátil necessária para assinatura

Public signing was specified and requires a public key, but no public key was specified. A autenticação pública foi especificada e requer uma chave pública, mas nenhuma chave pública foi especificada.

Public signing is not supported for netmodules. Não há suporte para autenticação pública dos netmodules.

Delay signing was specified and requires a public key, but no public key was specified A assinatura atrasada foi especificada e requer uma chave pública, mas nenhuma chave pública foi especificada

The specified version string does not conform to the required format - major[.minor[.build[.revision]]] A cadeia de caracteres de versão especificada não está de acordo com o formato necessário - major[.minor [.build[.revision]]]

The specified version string contains wildcards, which are not compatible with determinism. Either remove wildcards from the version string, or disable determinism for this compilation A cadeia de caracteres da versão especificada contém curingas, que não são compatíveis com o determinismo. Remova os curingas da cadeia de caracteres da versão ou desabilite o determinismo da compilação

The specified version string does not conform to the required format - major.minor.build.revision (without wildcards) A cadeia de caracteres da versão especificada não está em conformidade com o formato necessário – major.minor.build.revision (sem curingas)

The specified version string does not conform to the recommended format - major.minor.build.revision A cadeia de caracteres de versão especificada não está de acordo com o formato recomendado - major.minor.build.revision

Executables cannot be satellite assemblies; culture should always be empty Executáveis não podem ser assemblies satélites; cultura deve estar sempre vazia

There is no argument given that corresponds to the required formal parameter '{0}' of '{1}' Não há nenhum argumento fornecido que corresponde ao parâmetro formal necessário "{0}" de "{1}"

The command line switch '{0}' is not yet implemented and was ignored. A opção de linha de comando "{0}" ainda não está implementada e foi ignorada.

Command line switch is not yet implemented Opção de linha de comando ainda não implementada

Failed to emit module '{0}'. Falha para emitir o módulo "{0}".

Cannot use fixed local '{0}' inside an anonymous method, lambda expression, or query expression Não é possível usar o local fixo "{0}" dentro de um método anônimo, expressão lambda ou expressão de consulta

An expression tree may not contain a named argument specification Uma árvore de expressão não pode conter uma especificação de argumento nomeado

An expression tree may not contain a call or invocation that uses optional arguments Uma árvore de expressão não pode conter chamada ou invocação que use argumentos opcionais

An expression tree may not contain an indexed property Uma árvore de expressão não pode conter uma propriedade indexada

Indexed property '{0}' has non-optional arguments which must be provided Propriedade indexada "{0}" tem argumentos não opcionais que devem ser fornecidos

Indexed property '{0}' must have all arguments optional Propriedade indexada "{0}" deve ter todos os argumentos opcionais

Instance of type '{0}' cannot be used inside a nested function, query expression, iterator block or async method A instância do tipo '{0}' não pode ser usada dentro de uma função aninhada, expressão de consulta, bloco de iteradores ou método assíncrono

First argument to a security attribute must be a valid SecurityAction Primeiro argumento para um atributo de segurança deve ser uma SecurityAction válida

Security attribute '{0}' has an invalid SecurityAction value '{1}' Atributo de segurança "{0}" tem um valor SecurityAction inválido "{1}"

SecurityAction value '{0}' is invalid for security attributes applied to an assembly Valor SecurityAction "{0}" é inválido para atributos de segurança aplicados a um assembly

SecurityAction value '{0}' is invalid for security attributes applied to a type or a method Valor SecurityAction "{0}" é inválido para atributos de segurança aplicados a um tipo ou um método

SecurityAction value '{0}' is invalid for PrincipalPermission attribute Valor SecurityAction "{0}" é inválido para o atributo PrincipalPermission

An expression tree may not contain '{0}' Uma árvore de expressão não pode conter "{0}"

Unable to resolve file path '{0}' specified for the named argument '{1}' for PermissionSet attribute Não é possível resolver o caminho de arquivo "{0}" especificado para o argumento nomeado "{1}" para o atributo PermissionSet

Error reading file '{0}' specified for the named argument '{1}' for PermissionSet attribute: '{2}' Erro ao ler arquivo "{0}" especificado para o argumento nomeado "{1}" para o atributo PermissionSet: "{2}"

The type name '{0}' could not be found in the global namespace. This type has been forwarded to assembly '{1}' Consider adding a reference to that assembly. O nome do tipo "{0}" não pode ser encontrado no namespace global. Este tipo foi encaminhado para o assembly "{1}" Considere adicionar uma referência a esse assembly.

The type name '{0}' could not be found in the namespace '{1}'. This type has been forwarded to assembly '{2}' Consider adding a reference to that assembly. O nome do tipo "{0}" não pode ser encontrado no namespace "{1}". Este tipo foi encaminhado para o assembly "{2}" Considere adicionar uma referência a esse assembly.

The type name '{0}' could not be found. This type has been forwarded to assembly '{1}'. Consider adding a reference to that assembly. O nome do tipo "{0}" não pode ser encontrado. Esse tipo foi encaminhado para o assembly "{1}". Considere adicionar uma referência a esse assembly.

Assemblies '{0}' and '{1}' refer to the same metadata but only one is a linked reference (specified using /link option); consider removing one of the references. Assemblies "{0}" e "{1}" referem-se aos mesmos metadados, mas somente um é uma referência vinculada (especificada usando a opção /link); considere remover uma das referências.

The best overloaded Add method '{0}' for the collection initializer element is obsolete. O melhor método Add sobrecarregado "{0}" para o elemento do inicializador de coleção está obsoleto.

The best overloaded Add method for the collection initializer element is obsolete O melhor método Add sobrecarregado para o elemento do inicializador de coleta está obsoleto

The best overloaded Add method '{0}' for the collection initializer element is obsolete. {1} O melhor método Adicionar sobrecarregado "{0}" para o elemento do inicializador de coleção está obsoleto. {1}

The best overloaded Add method for the collection initializer element is obsolete O melhor método Add sobrecarregado para o elemento do inicializador de coleta está obsoleto

Yield statements may not appear at the top level in interactive code. Instruções yield podem não aparecer no nível superior no código interativo.

Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations. Atributo de segurança "{0}" não é válido neste tipo de declaração. Atributos de segurança são somente válidos em declarações de assembly, tipo e método.

Cannot use an expression of type '{0}' as an argument to a dynamically dispatched operation. Não é possível usar uma expressão do tipo "{0}" como um argumento para uma operação dinamicamente despachada.

Cannot use a lambda expression as an argument to a dynamically dispatched operation without first casting it to a delegate or expression tree type. Não é possível usar uma expressão lambda como um argumento para uma operação despachada dinamicamente sem primeiro convertê-la para um tipo delegate ou de árvore de expressão.

Cannot use a method group as an argument to a dynamically dispatched operation. Did you intend to invoke the method? Não é possível usar um grupo de métodos como um argumento para uma operação dinamicamente despachada. Você pretendia invocar o método?

The call to method '{0}' needs to be dynamically dispatched, but cannot be because it is part of a base access expression. Consider casting the dynamic arguments or eliminating the base access. A chamada para o método "{0}" precisa ser despachada dinamicamente, mas não pode ser porque ela é parte de uma expressão de acesso básica. Considere converter argumentos dinâmicos ou eliminar o acesso básico.

Query expressions over source type 'dynamic' or with a join sequence of type 'dynamic' are not allowed Não são permitidas expressões de consulta no tipo de origem "dynamic" ou com uma sequência de união do tipo "dynamic"

The indexer access needs to be dynamically dispatched, but cannot be because it is part of a base access expression. Consider casting the dynamic arguments or eliminating the base access. O acesso ao indexador deve ser expedido dinamicamente, mas isso não é possível porque ele faz parte de uma expressão de acesso de base. Converta os argumentos dinâmicos ou elimine o acesso de base.

The dynamically dispatched call to method '{0}' may fail at runtime because one or more applicable overloads are conditional methods. A chamada dinamicamente despachada para o método "{0}" pode falhar em tempo de execução porque um ou mais sobrecargas aplicáveis são métodos condicionais.

Dynamically dispatched call may fail at runtime because one or more applicable overloads are conditional methods Uma chamada despachada dinamicamente pode falhar no tempo de execução porque uma ou mais sobrecargas aplicáveis são métodos condicionais

'{0}' has no applicable method named '{1}' but appears to have an extension method by that name. Extension methods cannot be dynamically dispatched. Consider casting the dynamic arguments or calling the extension method without the extension method syntax. '"{0}" não tem nenhum método aplicável nomeado "{1}" mas parece ter um método de extensão com esse nome. Métodos de extensão não podem ser despachados dinamicamente. Considere a possibilidade de converter os argumentos dinâmicos ou chamar o método de extensão sem a sintaxe do método de extensão.

The CallerMemberNameAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerFilePathAttribute. O CallerMemberNameAttribute aplicado ao parâmetro "{0}" não terá efeito. Ele é substituído pelo CallerFilePathAttribute.

The CallerMemberNameAttribute will have no effect; it is overridden by the CallerFilePathAttribute O CallerMemberNameAttribute não terá nenhum efeito; ele é substituído pelo CallerFilePathAttribute

The CallerMemberNameAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerLineNumberAttribute. O CallerMemberNameAttribute aplicado ao parâmetro "{0}" não terá efeito. Ele é substituído pelo CallerLineNumberAttribute.

The CallerMemberNameAttribute will have no effect; it is overridden by the CallerLineNumberAttribute O CallerMemberNameAttribute não terá nenhum efeito; ele é substituído pelo CallerLineNumberAttribute

The CallerFilePathAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerLineNumberAttribute. O CallerFilePathAttribute aplicado ao parâmetro "{0}" não terá efeito. Ele é substituído pelo CallerLineNumberAttribute.

The CallerFilePathAttribute will have no effect; it is overridden by the CallerLineNumberAttribute O CallerFilePathAttribute não terá nenhum efeito; ele é substituído pelo CallerLineNumberAttribute

Expression must be implicitly convertible to Boolean or its type '{0}' must define operator '{1}'. A expressão deve ser implicitamente convertível em Booliano ou o tipo "{0}" deve definir o operador"{1}".

'{0}' cannot implement '{1}' because '{2}' is a Windows Runtime event and '{3}' is a regular .NET event. '"{0}" não pode implementar "{1}" porque "{2}" é um evento de Tempo de Execução do Windows e "{3}" é um evento regular do .NET.

Call System.IDisposable.Dispose() on allocated instance of {0} before all references to it are out of scope. Chamar System.IDisposable.Dispose() na instância alocada de {0} antes que todas as referências a ele fiquem fora do escopo.

Call System.IDisposable.Dispose() on allocated instance before all references to it are out of scope Chame System.IDisposable.Dispose() na instância alocada antes que todas as referências a ele estejam fora do escopo

Allocated instance of {0} is not disposed along all exception paths. Call System.IDisposable.Dispose() before all references to it are out of scope. Instância alocada de {0} não é descartada ao longo de todos os caminhos de exceção. Chamar System.IDisposable.Dispose() antes que todas as referências a ela estejam fora do escopo.

Allocated instance is not disposed along all exception paths Instância alocada não descartada em todos os caminhos de exceção

Object '{0}' can be disposed more than once. Objeto "{0}" pode ser descartado mais de uma vez.

Object can be disposed more than once O objeto pode ser descartado mais de uma vez

Interop type '{0}' cannot be embedded. Use the applicable interface instead. Tipo de interoperabilidade "{0}" não pode ser incorporado. Ao invés disso, use a interface aplicável.

Type '{0}' cannot be embedded because it is a nested type. Consider setting the 'Embed Interop Types' property to false. Tipo "{0}" não pode ser inserido porque ele é de um tipo aninhado. Considere configurar a propriedade "Inserir Tipos de Interoperabilidade" como falsa.

Type '{0}' cannot be embedded because it has a generic argument. Consider setting the 'Embed Interop Types' property to false. Tipo "{0}" não pode ser incorporado porque ele tem um argumento genérico. Considere definir a propriedade "Incorporar Tipos de Interoperabilidade" como falso.

Embedded interop struct '{0}' can contain only public instance fields. Estrutura de interoperabilidade inserida "{0}" pode conter apenas campos de instância pública.

A Windows Runtime event may not be passed as an out or ref parameter. Um evento de Tempo de Execução do Windows não pode ser passado como parâmetro out ou ref.

Source interface '{0}' is missing method '{1}' which is required to embed event '{2}'. Interface de origem "{0}" está sem o método "{1}" que é necessário para incorporar o evento "{2}".

Interface '{0}' has an invalid source interface which is required to embed event '{1}'. Interface "{0}" tem uma interface de origem inválida que é necessária para incorporar o evento "{1}".

Interop type '{0}' cannot be embedded because it is missing the required '{1}' attribute. Tipo de interoperabilidade "{0}" não pode ser inserido porque está faltando o atributo "{1}" necessário.

Cannot embed interop types from assembly '{0}' because it is missing the '{1}' attribute. Não é possível inserir tipos de interoperabilidade do assembly "{0}" porque ele está sem o "{1}" atributo.

Cannot embed interop types from assembly '{0}' because it is missing either the '{1}' attribute or the '{2}' attribute. Não é possível inserir tipos de interoperabilidade do assembly "{0}" porque ele está sem o atributo "{1}" ou o atributo "{2}".

Cannot embed interop type '{0}' found in both assembly '{1}' and '{2}'. Consider setting the 'Embed Interop Types' property to false. Não é possível inserir o tipo de interoperabilidade "{0}" encontrado em ambos os assemblies "{1}" e "{2}". Considere configurar a propriedade "Incorporar Tipos de Interoperabilidade" como falsa.

Embedding the interop type '{0}' from assembly '{1}' causes a name clash in the current assembly. Consider setting the 'Embed Interop Types' property to false. Incorporar o tipo de interoperabilidade "{0}" do assembly "{1}" causa um conflito de nome no assembly atual. Considere definir a propriedade "Incorporar Tipos de Interoperabilidade" como falsa.

A reference was created to embedded interop assembly '{0}' because of an indirect reference to that assembly created by assembly '{1}'. Consider changing the 'Embed Interop Types' property on either assembly. Foi criada uma referência ao assembly de interoperabilidade inserido "{0}" devido a uma referência indireta ao assembly criado pelo assembly "{1}". Considere alterar a propriedade "Inseir Tipos de Interoperabilidade" em qualquer assembly.

A reference was created to embedded interop assembly because of an indirect assembly reference Foi criada uma referência ao assembly de interoperabilidade inserido devido a uma referência de assembly indireta

You have added a reference to an assembly using /link (Embed Interop Types property set to True). This instructs the compiler to embed interop type information from that assembly. However, the compiler cannot embed interop type information from that assembly because another assembly that you have referenced also references that assembly using /reference (Embed Interop Types property set to False). To embed interop type information for both assemblies, use /link for references to each assembly (set the Embed Interop Types property to True). To remove the warning, you can use /reference instead (set the Embed Interop Types property to False). In this case, a primary interop assembly (PIA) provides interop type information. Você adicionou uma referência a um assembly usando /link (propriedade Incorporar Tipos de Interoperabilidade definida como Verdadeiro). Isso instrui o compilador a incorporar as informações de tipo de interoperabilidade desse assembly. No entanto, o compilador não pode incorporar informações de tipo de interoperabilidade desse assembly porque outro conjunto que você referenciou também faz referência a esse assembly usando /reference (propriedade Incorporar Tipos de Interoperabilidade definida como Falso). Para incorporar informações de tipo de interoperabilidade para os dois assemblies, use /link para fazer referência a cada assembly (defina a propriedade Incorporar Tipos de Interoperabilidade para Verdadeiro). Para remover o aviso, você pode usar o /reference em vez disso (defina a propriedade Incorporar Tipos de Interoperabilidade como Falso). Nesse caso, um assembly de interoperabilidade primária (PIA) fornece informações de tipo de interoperabilidade.

Type '{0}' from assembly '{1}' cannot be used across assembly boundaries because it has a generic type argument that is an embedded interop type. O tipo "{0}" do assembly '{1}' não pode ser usado em limites de assembly porque ele tem um argumento de tipo genérico que é um tipo de interoperabilidade inserido.

Cannot find the interop type that matches the embedded interop type '{0}'. Are you missing an assembly reference? Não é possível encontrar o tipo de interoperabilidade que corresponda ao tipo de interoperabilidade inserido "{0}". Está faltando uma referência de assembly?

By-reference return type 'ref {0}' is not supported. Tipo de retorno por referência "ref {0}" não tem suporte.

Module name '{0}' stored in '{1}' must match its filename. Nome do módulo "{0}" armazenado em "{1}" deve coincidir com seu filename.

Invalid module name: {0} Nome de módulo inválido: {0}

Invalid '{0}' value: '{1}'. Valor "{0}" inválido: "{1}".

AppConfigPath must be absolute. AppConfigPath deve ser absoluto.

Attribute '{0}' from module '{1}' will be ignored in favor of the instance appearing in source Atributo "{0}" do módulo "{1}" será ignorado em favor da instância que aparece na fonte

Attribute will be ignored in favor of the instance appearing in source O atributo será ignorado em prol da instância que aparece na fonte

Attribute '{0}' given in a source file conflicts with option '{1}'. Atributo "{0}" fornecido em um arquivo de origem com a opção "{1}".

A fixed buffer may only have one dimension. Um buffer fixo pode ter somente uma dimensão.

Referenced assembly '{0}' does not have a strong name. Assembly referenciado "{0}" não tem um nome forte.

Referenced assembly does not have a strong name Assembly referenciado sem um nome forte

Invalid signature public key specified in AssemblySignatureKeyAttribute. Chave pública de assinatura inválida especificada em AssemblySignatureKeyAttribute.

Type '{0}' exported from module '{1}' conflicts with type declared in primary module of this assembly. Tipo "{0}" exportado do módulo "{1}" está em conflito com tipo declarado no módulo primário deste assembly.

Type '{0}' exported from module '{1}' conflicts with type '{2}' exported from module '{3}'. Tipo "{0}" exportado do módulo "{1}" está em conflito com tipo "{2}" exportado do módulo "{3}".

Forwarded type '{0}' conflicts with type declared in primary module of this assembly. Tipo encaminhado "{0}" está em conflito com o tipo declarado no módulo primário deste assembly.

Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' forwarded to assembly '{3}'. Tipo "{0}" encaminhado para o assembly "{1}" está em conflito com tipo "{2}" encaminhado para o módulo "{3}".

Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' exported from module '{3}'. Tipo "{0}" encaminhado para o assembly "{1}" está em conflito com tipo "{2}" exportado do módulo "{3}".

Referenced assembly '{0}' has different culture setting of '{1}'. Assembly referenciado "{0}" tem a configuração de cultura diferente de "{1}".

Referenced assembly has different culture setting O assembly referenciado possui uma configuração de cultura diferente

Agnostic assembly cannot have a processor specific module '{0}'. Assembly desconhecido não pode ter um módulo específico de processador "{0}".

Assembly and module '{0}' cannot target different processors. Assembly e módulo "{0}" não podem diferentes processadores como destino.

Referenced assembly '{0}' targets a different processor. Assembly referenciado "{0}" destinado a um processador diferente.

Referenced assembly targets a different processor O assembly referenciado está direcionado a um processador diferente

Cryptographic failure while creating hashes. Falha na criptografia ao criar valores hashes.

Reference to '{0}' netmodule missing. Referência a "{0}" netmodule ausente.

Module '{0}' is already defined in this assembly. Each module must have a unique filename. Módulo "{0}" já está definido neste assembly. Cada módulo deve ter um filename exclusivo.

Cannot read config file '{0}' -- '{1}' Não é possível ler o arquivo de configuração "{0}" -- "{1}"

Cannot continue since the edit includes a reference to an embedded type: '{0}'. Não é possível continuar pois a edição inclui uma referência a um tipo incorporado: '{0}'.

Member '{0}' added during the current debug session can only be accessed from within its declaring assembly '{1}'. Membro '{0}' adicionado durante a sessão de depuração atual pode ser acessado somente neste assembly de declaração '{1}'.

Compilation options '{0}' and '{1}' can't both be specified at the same time. As opções de compilação '{0}' e '{1}' não podem ser especificadas ao mesmo tempo.

Linked netmodule metadata must provide a full PE image: '{0}'. Metadados netmodule vinculados devem fornecer uma imagem completa de PE: "{0}".

/platform:anycpu32bitpreferred can only be used with /t:exe, /t:winexe and /t:appcontainerexe /platform:anycpu32bitpreferred pode apenas ser usado com /t:exe, /t:winexe e /t:appcontainerexe

null propagating operator operador de propagação nula

expression-bodied method método apto para expressão

expression-bodied property propriedade apta para expressão

expression-bodied indexer indexador apto para expressão

auto property initializer inicializador de autopropriedade

byref locals and returns retornos e locais de byref

readonly references referências somente leitura

ref structs structs de referência

Compilation (C#): Compilação (C#):

Syntax node is not within syntax tree Nó de sintaxe não está dentro da árvore de sintaxe

Location must be provided in order to provide minimal type qualification. Local deve ser fornecido para fornecer a qualificação do tipo mínimo.

SyntaxTreeSemanticModel must be provided in order to provide minimal type qualification. SyntaxTreeSemanticModel deve ser fornecido para fornecer a qualificação do tipo mínimo.

Can't reference compilation of type '{0}' from {1} compilation. Não é possível fazer referência a compilação do tipo "{0}" de {1} compilação.

Syntax tree already present Árvore de sintaxe já está presente

Submission can only include script code. Envio só pode incluir código de script.

Submission can have at most one syntax tree. Envio pode ter no máximo uma árvore de sintaxe.

tree must have a root node with SyntaxKind.CompilationUnit árvores devem ter um nó raiz com SyntaxKind.CompilationUnit

Type argument cannot be null Argumento de tipo não pode ser nulo

Wrong number of type arguments Número errado de argumentos de tipo

Name conflict for name {0} Conflito de nome para o nome {0}

LookupOptions has an invalid combination of options LookupOptions tem uma combinação inválida de opções

items: must be non-empty itens: devem ser não vazios

Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier or Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier to create identifier tokens. Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier ou Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier para criar tokens de identificador.

Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal to create character literal tokens. Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal para criar tokens literais de caracteres.

Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal to create numeric literal tokens. Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal para criar tokens literais numéricos.

This method can only be used to create tokens - {0} is not a token kind. Este método pode somente ser usado para criar tokens - {0} não é um tipo de token.

Generic parameter is definition when expected to be reference {0} Parâmetro genérico é definição quando é esperado que seja referência {0}

Called GetDeclarationName for a declaration node that can possibly contain multiple variable declarators. GetDeclarationName chamado para um nó de declaração que possivelmente pode conter múltiplos declaradores variáveis.

tree not part of compilation árvore não faz parte da compilação

Position is not within syntax tree with full span {0} Posição não está dentro da árvore de sintaxe com intervalo total {0}

The language name '{0}' is invalid. O nome de idioma "{0}" é inválido.

The language name is invalid O nome do idioma é inválido

Transparent identifier member access failed for field '{0}' of '{1}'. Does the data being queried implement the query pattern? Falha no acesso de membro de identificador transparente para o campo "{0}" de "{1}". Os dados que estão sendo consultados implementam o padrão de consulta?

The parameter has multiple distinct default values. O parâmetro tem vários valores padrão diferentes.

The field has multiple distinct constant values. O campo tem vários valores constantes distintos.

Within cref attributes, nested types of generic types should be qualified. Em atributos cref, tipos aninhados de tipos genéricos devem ser qualificados.

Within cref attributes, nested types of generic types should be qualified Em atributos cref, tipos aninhados de tipos genéricos devem ser qualificados

Not a C# symbol. Não é um símbolo C#.

Unnecessary using directive. Diretiva de uso desnecessária.

Unused extern alias. Alias externo não usado.

Elements cannot be null. Elementos não podem ser nulos.

LIB environment variable variável de ambiente LIB

/LIB option opção /LIB

/REFERENCEPATH option Opção /REFERENCEPATH

directory does not exist diretório não existe

path is too long or invalid o caminho é muito longo ou inválido

No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options. Nenhum valor para RuntimeMetadataVersion encontrado. Nenhum assembly contendo System.Object foi encontrado nem foi encontrado um valor de RuntimeMetadataVersion especificado por meio de opções.

No value for RuntimeMetadataVersion found Nenhum valor de RuntimeMetadataVersion foi encontrado

Expected a {0} SemanticModel. Espera-se um {0} SemanticModel.

lambda expression expressão lambda

Feature '{0}' is not available in C# 1. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 1. Use a versão de linguagem {1} ou superior.

Feature '{0}' is not available in C# 2. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 2. Use a versão de linguagem {1} ou superior.

Feature '{0}' is not available in C# 3. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 3. Use a versão de linguagem {1} ou superior.

Feature '{0}' is not available in C# 4. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 4. Use a versão de linguagem {1} ou superior.

Feature '{0}' is not available in C# 5. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 5. Use a versão de linguagem {1} ou superior.

Feature '{0}' is not available in C# 6. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 6. Use a versão de linguagem {1} ou superior.

Feature '{0}' is not available in C# 7.0. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 7.0. Use a versão de linguagem {1} ou superior.

Feature '{0}' is not implemented in this compiler. O recurso '{0}' não é implementado nesse compilador.

'experimental' 'experimental'

Position must be within span of the syntax tree. A posição deve ser dentro do intervalo da árvore de sintaxe.

Syntax node to be speculated cannot belong to a syntax tree from the current compilation. Nó de sintaxe a ser especulado não pode pertencer a uma árvore de sintaxe da compilação atual.

Chaining speculative semantic model is not supported. You should create a speculative model from the non-speculative ParentModel. Não há suporte ao encadeamento do modelo semântico especulativo. Você deve criar um modelo especulativo com base no ParentModel não especulativo.

Microsoft (R) Visual C# Compiler Compilador do Microsoft (R) Visual C#

{0} version {1} {0} versão {1}

Supported language versions: Versões de linguagens com suporte:

'{0}': a class with the ComImport attribute cannot specify field initializers. '"{0}": uma classe com o atributo ComImport não pode especificar inicializadores de campo.

Local name '{0}' is too long for PDB. Consider shortening or compiling without /debug. Nome local "{0}" é muito longo para PDB. Considere reduzir ou compilar sem /debug.

Local name is too long for PDB O nome do local é muito longo para o PDB

Anonymous function converted to a void returning delegate cannot return a value Função anônima convertida para um representante de retorno void não pode retornar um valor

Async lambda expression converted to a 'Task' returning delegate cannot return a value. Did you intend to return 'Task<T>'? Expressão lambda assíncrona convertida a um representante de retorno "Task" não pode retornar um valor. Você pretendia retornar "Task<T>"?

An instance of analyzer {0} cannot be created from {1} : {2}. Uma instância do analisador de {0} não pode ser criada de {1} : {2}.

An analyzer instance cannot be created Não é possível criar uma instância do analisador

The assembly {0} does not contain any analyzers. O assembly {0} não contém quaisquer analisadores.

Assembly does not contain any analyzers O assembly não contém analisadores

Unable to load Analyzer assembly {0} : {1} Não é possível carregar o assembly do Analisador {0} : {1}

Unable to load Analyzer assembly Não é possível carregar o assembly do analisador

Skipping some types in analyzer assembly {0} due to a ReflectionTypeLoadException : {1}. Ignorando a alguns tipos de assembly de analisador {0} devido a uma ReflectionTypeLoadException: {1}.

Error reading ruleset file {0} - {1} Erro ao ler arquivo de conjunto de regras {0} - {1}

Error reading debug information for '{0}' Erro ao ler as informações de depuração para '{0}'

Operation caused a stack overflow. A operação causou um estouro de pilha.

Expected identifier or numeric literal. Identificador esperado ou literal numérico.

Expected identifier or numeric literal Identificador esperado ou literal numérico

Only auto-implemented properties can have initializers. Somente propriedades implementadas automaticamente podem ter inicializadores.

Auto-implemented properties must have get accessors. Propriedades autoimplementadas devem ter acessadores get.

Auto-implemented properties must override all accessors of the overridden property. Propriedades autoimplementadas devem substituir todos os acessadores de propriedade substituída.

Auto-implemented properties inside interfaces cannot have initializers. Propriedades autoimplementadas em interfaces não podem ter inicializadores.

Structs without explicit constructors cannot contain members with initializers. Estruturas sem construtores explícitos não podem conter membros com inicializadores.

Cannot emit debug information for a source text without encoding. Não é possível emitir informações de depuração para um texto de origem sem codificação.

Block bodies and expression bodies cannot both be provided. Corpos de bloco e de expressão não podem ser ambos fornecidos.

Control cannot fall out of switch from final case label ('{0}') O controle não pode ficar fora do switch do rótulo de caso final ('{0}')

Type arguments are not allowed in the nameof operator. Os argumentos de tipo não são permitidos no nome do operador.

An expression tree lambda may not contain a null propagating operator. Uma árvore de expressão da expressão lambda não pode conter um operador nulo em propagação.

An expression tree lambda may not contain a dictionary initializer. Uma árvore de expressão da expressão lambda não pode conter um inicializador de dicionário.

An extension Add method is not supported for a collection initializer in an expression lambda. Não há suporte para um método de Adição de extensão para um inicializador de coleção em uma expressão lambda.

nameof operator nome do operador

dictionary initializer inicializador de dicionário

Missing close delimiter '}' for interpolated expression started with '{'. Delimitador de fechamento ausente '}' para expressão interpolada iniciada com '{'.

A single-line comment may not be used in an interpolated string. Um comentário de uma linha não pode ser usado em uma cadeia de caracteres interpolada.

An expression is too long or complex to compile Uma expressão é muito longa ou complexa para ser compilada

Expression does not have a name. A expressão não tem um nome.

Sub-expression cannot be used in an argument to nameof. A subexpressão não pode ser usada em um argumento para nameof.

An alias-qualified name is not an expression. Um nome qualificado para alias não é uma expressão.

Type parameters are not allowed on a method group as an argument to 'nameof'. Os parâmetros de tipo não são permitidos em um grupo de métodos como um argumento para 'nameof'.

SearchCriteria is expected. SearchCriteria é esperado.

Assembly culture strings may not contain embedded NUL characters. As cadeias de caracteres de cultura de assembly podem não conter caracteres NUL incorporados.

using static usando estático

interpolated strings cadeias de caracteres interpoladas

await in catch blocks and finally blocks aguardar em blocos variáveis e blocos finais

binary literals literais binários

digit separators separadores de dígito

local functions funções locais

A '{0}' character must be escaped (by doubling) in an interpolated string. Um caractere '{0}' deve ser de escape (ao duplicar) em uma cadeia de caracteres interpolada.

A '{0}' character may only be escaped by doubling '{0}{0}' in an interpolated string. Um caractere '{0}' somente deve ser de escape ao duplicar '{0}{0}' em uma cadeia de caracteres interpolada.

A format specifier may not contain trailing whitespace. Um especificador de formato não pode conter espaço em branco à direita.

Empty format specifier. Especificador de formato vazio.

There is an error in a referenced assembly '{0}'. Há um erro em um assembly referenciado '{0}'.

Expression or declaration statement expected. Expressão ou declaração de instrução esperada.

Extension method groups are not allowed as an argument to 'nameof'. Grupos de métodos de extensão não são permitidos como um argumento para 'nameof'.

Alignment value {0} has a magnitude greater than {1} and may result in a large formatted string. O valor do alinhamento {0} possui uma magnitude maior que {1}, podendo resultar em uma grande cadeia de caracteres formatada.

Unused extern alias Alias externo não usado

Unnecessary using directive Diretiva de uso desnecessária

Skip loading types in analyzer assembly that fail due to a ReflectionTypeLoadException Ignorar tipos de carregamento no assembly analisador que falharem devido a uma ReflectionTypeLoadException

Alignment value has a magnitude that may result in a large formatted string O valor do alinhamento tem uma magnitude que pode resultar em uma grande cadeia de caracteres formatada

Length of String constant exceeds current memory limit. Try splitting the string into multiple constants. O comprimento da constante de cadeia de caracteres excede o limite de memória atual. Tente dividir a cadeia de caracteres em várias constantes.

Tuple must contain at least two elements. A tupla deve conter pelo menos dois elementos.

Debug entry point must be a definition of a method declared in the current compilation. O ponto de entrada da depuração deve ser uma definição de um método declarado na compilação atual.

#load is only allowed in scripts #load só pode ser usado em scripts

Cannot use #load after first token in file Não é permitido usar #load após o primeiro token do arquivo

Could not find file. Não foi possível encontrar o arquivo. File path referenced in source (#load) could not be resolved.

SyntaxTree resulted from a #load directive and cannot be removed or replaced directly. A SyntaxTree o é resultado de uma diretiva #load e não pode ser removida nem substituída diretamente.

Source file references are not supported. Não há suporte às referências do arquivo de origem.

The pathmap option was incorrectly formatted. A opção pathmap foi formatada incorretamente.

Invalid real literal. Literal real inválido.

Auto-implemented properties cannot return by reference As propriedades autoimplementadas não podem retornar por referência

Properties which return by reference must have a get accessor As propriedades que retornam por referência devem ter um acessador get

Properties which return by reference cannot have set accessors As propriedades que retornam por referência não podem ter acessadores definidos

'{0}' must match by reference return of overridden member '{1}' '{0}' deve corresponder ao retorno de referência de membro substituído '{1}'

By-reference returns may only be used in methods that return by reference Retornos por referência podem ser usados somente em métodos que são retornados por referência

By-value returns may only be used in methods that return by value Retornos by-value podem ser usados somente em métodos que retornam um valor

The return expression must be of type '{0}' because this method returns by reference A expressão de retorno deve ser do tipo '{0}' porque esse método é retornado por referência

'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}' because it does not have matching return by reference. '{0}' não implementa o membro de inferface '{1}'. O '{2}' não pode implementar '{1}' porque ele não tem retorno correspondente por referência.

The body of '{0}' cannot be an iterator block because '{0}' returns by reference O corpo de '{0}' não pode ser um bloco de iteradores, pois '{0}' é retornado por referência

Lambda expressions that return by reference cannot be converted to expression trees Expressões lambda que retornam por referência não podem ser convertidas para árvores de expressão

An expression tree lambda may not contain a call to a method, property, or indexer that returns by reference O lambda da árvore de expressão pode não conter uma chamada para um método, propriedade ou indexador que é retornado por referência

An expression cannot be used in this context because it may not be passed or returned by reference Uma expressão não pode ser usada nesse contexto, pois ela pode não ser ignorada ou retornada por referência

Cannot return '{0}' by reference because it was initialized to a value that cannot be returned by reference Não é possível retornar '{0}' por referência porque ele foi inicializado para um valor que não pode ser retornado por referência

Cannot return by reference a member of '{0}' because it was initialized to a value that cannot be returned by reference Não é possível retornar por referência um membro de '{0}' porque ele foi inicializado para um valor que não pode ser retornado por referência

Cannot return '{0}' by reference because it is read-only Não é possível retornar '{0}' por referência, porque ele é somente leitura

Cannot return the range variable '{0}' by reference Não é possível retornar a variável de intervalo '{0}' por referência

Cannot return '{0}' by reference because it is a '{1}' Não é possível retornar '{0}' por referência, porque ele é um '{1}'

Cannot return fields of '{0}' by reference because it is a '{1}' Não é possível retornar campos de '{0}' por referência, porque ele é um '{1}'

A readonly field cannot be returned by writable reference Um campo somente leitura não pode ser retornado por referência gravável

A static readonly field cannot be returned by writable reference Um campo somente leitura estático não pode ser retornado por referência gravável

Members of readonly field '{0}' cannot be returned by writable reference Membros do campo somente leitura '{0}' não podem ser retornados por referência gravável

Fields of static readonly field '{0}' cannot be returned by writable reference Os campos do campo somente leitura estático '{0}' não podem ser retornados por referência gravável

Cannot return a parameter by reference '{0}' because it is not a ref or out parameter Não é possível retornar um parâmetro por referência '{0}', pois ele não é um parâmetro ref ou out

Cannot return by reference a member of parameter '{0}' because it is not a ref or out parameter Não é possível retornar um membro do parâmetro '{0}' por referência, porque ele não é um parâmetro de referência ou out

Cannot return local '{0}' by reference because it is not a ref local Não é possível retornar o local '{0}' por referência porque ele não é um local ref

Cannot return a member of local '{0}' by reference because it is not a ref local Não é possível retornar um membro do '{0}' local por referência porque ele não é um local ref

Struct members cannot return 'this' or other instance members by reference Membros struct não podem retornar 'this' ou outros membros de instância por referência

Expression cannot be used in this context because it may indirectly expose variables outside of their declaration scope A expressão não pode ser usada neste contexto porque ela pode expor indiretamente variáveis fora do seu escopo de declaração

Cannot use local '{0}' in this context because it may expose referenced variables outside of their declaration scope Não é possível usar o local '{0}' nesse contexto porque ele pode expor variáveis referenciadas fora do seu escopo de declaração

Cannot use a result of '{0}' in this context because it may expose variables referenced by parameter '{1}' outside of their declaration scope Não é possível usar um resultado '{0}' nesse contexto porque ele pode expor as variáveis referenciadas pelo parâmetro '{1}' fora do seu escopo de declaração

Cannot use a member of result of '{0}' in this context because it may expose variables referenced by parameter '{1}' outside of their declaration scope Não é possível usar um membro de resultado de '{0}' nesse contexto porque ele pode expor as variáveis referenciadas pelo parâmetro '{1}' fora do seu escopo de declaração

This combination of arguments to '{0}' is disallowed because it may expose variables referenced by parameter '{1}' outside of their declaration scope Essa combinação de argumentos para '{0}' não é permitida porque ela pode expor as variáveis referenciadas pelo parâmetro '{1}' fora do seu escopo de declaração

Branches of a ref conditional operator cannot refer to variables with incompatible declaration scopes Branches de um operador ternário de referência não podem se referir a variáveis com escopos de declaração incompatível

A result of a stackalloc expression of type '{0}' cannot be used in this context because it may be exposed outside of the containing method Um resultado de uma expressão stackalloc do tipo '{0}' não pode ser usado nesse contexto porque ele pode ser exposto fora do método que o contém

Cannot initialize a by-value variable with a reference Não é possível inicializar uma variável by-value com uma referência

Cannot initialize a by-reference variable with a value Não é possível inicializar uma variável por referência com um valor

The expression must be of type '{0}' because it is being assigned by reference A expressão deve ser do tipo '{0}' porque ela está sendo atribuída por referência

A declaration of a by-reference variable must have an initializer A declaração de uma variável por referência deve ter um inicializador

Cannot use ref local '{0}' inside an anonymous method, lambda expression, or query expression Não é possível usar a referência local '{0}' em um método anônimo, expressão lambda ou expressão de consulta

Iterators cannot have by-reference locals Os iteradores não podem ter locais por referência

Async methods cannot have by-reference locals Os métodos assíncronos não podem ter locais por referência

'await' cannot be used in an expression containing a call to '{0}' because it returns by reference 'await' não pode ser usado em uma expressão contendo uma chamada para '{0}', pois ele é retornado por referência

'await' cannot be used in an expression containing a ref conditional operator 'await' não pode ser usado em uma expressão que contém um operador condicional de referência

Both conditional operator values must be ref values or neither may be a ref value Ambos os valores de operador condicional devem ser valores de referência ou nenhum pode ser um valor de referência

The expression must be of type '{0}' to match the alternative ref value A expressão deve ser do tipo '{0}' para corresponder ao valor de referência alternativo

An expression tree may not contain a reference to a local function Uma árvore de expressão não pode conter uma referência a uma função local

Cannot pass argument with dynamic type to params parameter '{0}' of local function '{1}'. Não é possível passar argumento com tipo dinâmico para parâmetro params '{0}' da função local '{1}'.

Syntax tree should be created from a submission. A árvore de sintaxe deve ser criada de uma submissão.

Combined length of user strings used by the program exceeds allowed limit. Try to decrease use of string literals. O comprimento combinado de cadeias do usuários usadas pelo programa excede o limite permitido. Tente diminuir o uso de literais de cadeia.

It is not legal to use nullable type '{0}' in a pattern; use the underlying type '{1}' instead. É ilegal usar o tipo que permite valor nulo '{0}' em um padrão; em vez disso, use o tipo subjacente '{1}'.

An error occurred while writing the output file: {0}. Ocorreu um erro ao gravar o arquivo de saída: {0}.

Tuple element names must be unique. Os nomes de elemento de tupla devem ser exclusivos.

Tuple element name '{0}' is only allowed at position {1}. O nome do elemento de tupla '{0}' é permitido somente na posição {1}.

Tuple element name '{0}' is disallowed at any position. O nome do elemento de tupla '{0}' não é permitido em qualquer posição.

Member '{0}' was not found on type '{1}' from assembly '{2}'. O membro '{0}' não foi encontrado no tipo '{1}' do assembly '{2}'.

tuples tuplas

No suitable 'Deconstruct' instance or extension method was found for type '{0}', with {1} out parameters and a void return type. Nenhuma instância nem método de extensão 'Deconstruct' adequado foi localizado para o tipo '{0}' com {1} parâmetros de saída e um tipo de retorno nulo.

Deconstruct assignment requires an expression with a type on the right-hand-side. Desconstruir uma atribuição requer uma expressão com um tipo no lado direito.

The switch expression must be a value; found '{0}'. A expressão switch deve ser um valor. {0} foi encontrado.

An expression of type '{0}' cannot be handled by a pattern of type '{1}'. Uma expressão do tipo '{0}' não pode ser manipulada por um padrão do tipo '{1}'.

Attribute '{0}' is ignored when public signing is specified. O atributo '{0}' é ignorado quando a autenticação pública é especificada.

Attribute is ignored when public signing is specified. O atributo é ignorado quando a autenticação pública é especificada.

Option '{0}' must be an absolute path. A opção '{0}' deve ser um caminho absoluto.

Tuple with {0} elements cannot be converted to type '{1}'. A tupla com {0} elementos não pode ser convertida para o tipo '{1}'.

out variable declaration declaração de variável externa

Reference to an implicitly-typed out variable '{0}' is not permitted in the same argument list. Referência a uma variável '{0}' digitada implicitamente não é permitida na mesma lista de argumentos.

Cannot infer the type of implicitly-typed out variable '{0}'. Não é possível inferir o tipo da variável out de tipo implícito '{0}'.

Cannot infer the type of implicitly-typed deconstruction variable '{0}'. Não é possível inferir o tipo da variável de desconstrução digitada implicitamente '{0}'.

Cannot infer the type of implicitly-typed discard. Não é possível inferir o tipo de descarte de tipo implícito.

Cannot deconstruct a tuple of '{0}' elements into '{1}' variables. Não é possível desconstruir uma tupla de '{0}' elementos em '{1}' variáveis.

Cannot deconstruct dynamic objects. Não é possível desconstruir objetos dinâmicos.

Deconstruction must contain at least two variables. A desconstrução deve conter pelo menos duas variáveis.

The tuple element name '{0}' is ignored because a different name or no name is specified by the target type '{1}'. O nome do elemento de tupla '{0}' foi ignorado porque um nome diferente ou nenhum nome foi especificado pelo tipo de destino '{1}'.

The tuple element name is ignored because a different name or no name is specified by the assignment target. O nome do elemento de tupla é ignorado porque um nome diferente ou nenhum nome foi especificado pelo destino de atribuição.

Predefined type '{0}' must be a struct. O tipo predefinido '{0}' deve ser um struct.

'new' cannot be used with tuple type. Use a tuple literal expression instead. 'new' não pode ser usado com o tipo da tupla. Use uma expressão literal da tupla no lugar.

Deconstruction 'var (...)' form disallows a specific type for 'var'. O formulário de desconstrução 'var (...)' não permite um tipo específico para 'var'.

Cannot define a class or member that utilizes tuples because the compiler required type '{0}' cannot be found. Are you missing a reference? Não é possível definir uma classe ou membro que utiliza tuplas porque o tipo '{0}' necessário de compilador não pode ser localizado. Uma referência está ausente?

Cannot reference 'System.Runtime.CompilerServices.TupleElementNamesAttribute' explicitly. Use the tuple syntax to define tuple names. Não é possível fazer referência a 'System.Runtime.CompilerServices.TupleElementNamesAttribute' explicitamente. Use a sintaxe de tupla para definir os nomes das tuplas.

An expression tree may not contain an out argument variable declaration. Uma árvore de expressão não pode conter uma declaração de variável de argumento out.

An expression tree may not contain a discard. Uma árvore de expressão não pode conter um descarte.

An expression tree may not contain an 'is' pattern-matching operator. Uma árvore de expressão não pode conter um operador 'is' com padrões correspondentes.

An expression tree may not contain a tuple literal. Uma árvore de expressão não pode conter um literal de tupla.

An expression tree may not contain a tuple conversion. Uma árvore de expressão não pode conter uma conversão de tupla.

/sourcelink switch is only supported when emitting PDB. A opção /sourcelink tem suporte apenas ao emitir o PDB.

/embed switch is only supported when emitting a PDB. A opção /inserir tem suporte apenas ao emitir um PDB.

Invalid instrumentation kind: {0} Variante de instrumentação inválida: {0}

The syntax 'var (...)' as an lvalue is reserved. A sintaxe 'var (...)' como um lvalue está reservada.

{ or ; or => expected { ou ; ou => esperado

A throw expression is not allowed in this context. Uma expressão throw não é permitida neste contexto.

A deconstruction cannot mix declarations and expressions on the left-hand-side. Uma desconstrução não pode mesclar declarações e expressões à esquerda.

A declaration is not allowed in this context. Uma declaração não é permitida neste contexto.

A foreach loop must declare its iteration variables. Um Loop ForEach deve declarar suas variáveis de iteração.

Tuple element names are not permitted on the left of a deconstruction. Os nomes de elemento de tupla não são permitidos à esquerda de uma desconstrução.

To cast a negative value, you must enclose the value in parentheses. Para converter um valor negativo, é necessário delimitá-lo com parêntesis.

An expression tree may not contain a throw-expression. Uma árvore de expressão não pode conter uma expressão throw.

Invalid assembly name: {0} Nome de assembly inválido: {0}

For type '{0}' to be used as an AsyncMethodBuilder for type '{1}', its Task property should return type '{1}' instead of type '{2}'. Para o tipo '{0}' a ser usado como um AsyncMethodBuilder para o tipo '{1}', sua propriedade Task deve retornar o tipo '{1}' em vez do tipo '{2}'.

Attributes are not allowed on local function parameters or type parameters Os atributos não são permitidos em parâmetros de função local ou parâmetros de tipo

Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'. O módulo '{0}' no assembly '{1}' está encaminhando o tipo '{2}' para vários assemblies: '{3}' e '{4}'.

It is not legal to use the type 'dynamic' in a pattern. É ilegal usar o tipo 'dinâmico' em um padrão.

Cannot use a default literal as an argument to a dynamically dispatched operation. Não é possível usar um padrão literal como um argumento para uma operação dinamicamente expedida.

Provided documentation mode is unsupported or invalid: '{0}'. O modo de documentação fornecido não tem suporte ou é inválido: '{0}'.

Provided source code kind is unsupported or invalid: '{0}' O tipo de código-fonte fornecido não tem suporte ou é inválido: '{0}'

Provided language version is unsupported or invalid: '{0}'. A versão de linguagem fornecida não tem suporte ou é inválida: '{0}'.

Invalid name for a preprocessing symbol; '{0}' is not a valid identifier Nome inválido para um símbolo de pré-processamento. '{0}' não é um identificador válido

Feature '{0}' is not available in C# 7.1. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 7.1. Use a versão de linguagem {1} ou superior.

Feature '{0}' is not available in C# 7.2. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 7.2. Use a versão de linguagem {1} ou superior.

Specified language version '{0}' cannot have leading zeroes A versão de linguagem '{0}' especificada não pode ter zeros à esquerda

A value of type 'void' may not be assigned. Um valor do tipo 'void' não pode ser atribuído.

'{0}' is for evaluation purposes only and is subject to change or removal in future updates. '{0}' é para fins de avaliação somente e está sujeito a alterações ou remoções em atualizações futuras.

Type is for evaluation purposes only and is subject to change or removal in future updates. O tipo destina-se somente para fins de avaliação e está sujeito a alterações ou remoções em atualizações futuras.

Compiler version: '{0}'. Language version: {1}. Versão do compilador: '{0}'. Versão de linguagem: {1}.

async main assíncrono principal

Tuple element name '{0}' is inferred. Please use language version {1} or greater to access an element by its inferred name. O nome do elemento de tupla '{0}' é deduzido. Use a versão de idioma {1} ou posterior para acessar um elemento pelo nome deduzido.

A tuple may not contain a value of type 'void'. Uma tupla não pode conter um valor do tipo 'void'.

A void or int returning entry point cannot be async Um ponto de entrada que retorna void ou int não pode ser assíncrono

An expression of type '{0}' cannot be handled by a pattern of type '{1}' in C# {2}. Please use language version {3} or greater. Uma expressão do tipo '{0}' não pode ser manipulada por um padrão do tipo '{1}' em C# {2}. Use a versão de linguagem {3} ou superior.

The local function '{0}' is declared but never used A função local '{0}' está declarada, mas nunca é usada

Local function is declared but never used A função local foi declarada, mas nunca usada

'{0}' is a local function and must therefore always have a body. '{0}' é uma função local e, portanto, deve sempre ter um corpo.

Unable to read debug information of method '{0}' (token 0x{1:X8}) from assembly '{2}' Não é possível ler as informações de depuração do método '{0}' (token 0x{1:X8}) do assembly '{2}'

{0} is not a valid C# conversion expression {0} não é uma expressão de conversão C# válida

Cannot pass argument with dynamic type to generic local function '{0}' with inferred type arguments. Não é possível passar um argumento com tipo dinâmico para função local genérica '{0}' com argumentos de tipo inferidos.

leading digit separator separador de dígito à esquerda

Do not use '{0}'. This is reserved for compiler usage. Não use '{0}'. Isso é reservado para uso do compilador.

The type name '{0}' is reserved to be used by the compiler. O nome do tipo '{0}' está reservado para ser usado pelo compilador.

The first parameter of an 'in' extension method '{0}' must be a value type. O primeiro parâmetro de um método de extensão "in" "{0}" deve ser um tipo de valor.

Instance fields of readonly structs must be readonly. Campos de instância de structs somente leitura devem ser somente leitura.

Auto-implemented instance properties in readonly structs must be readonly. Propriedades da instância autoimplementadas em structs somente leitura devem ser somente leitura.

Field-like events are not allowed in readonly structs. Eventos semelhantes a campos não são permitidos em structs somente leitura.

ref extension methods métodos de extensão de referência

Conversion of a stackalloc expression of type '{0}' to type '{1}' is not possible. A conversão de uma expressão stackalloc do tipo '{0}' para o tipo '{1}' não é possível.

The first parameter of a 'ref' extension method '{0}' must be a value type or a generic type constrained to struct. O primeiro parâmetro de um método de extensão "ref" "{0}" deve ser um tipo de valor ou um tipo genérico restrito a struct.

An in parameter cannot have the Out attribute. Um parâmetro In não pode ter o atributo Out.

{0} is not a valid C# compound assignment operation {0} não é uma operação de atribuição composta de C# válida

Filter expression is a constant 'false', consider removing the catch clause A expressão de filtro é uma constante ‘false’, considere remover a cláusula catch

Filter expression is a constant 'false' A expressão de filtro é uma constante ‘false’

Filter expression is a constant 'false', consider removing the try-catch block A expressão de filtro é uma constante ‘false’, considere remover o bloco try-catch

Filter expression is a constant 'false'. A expressão de filtro é uma constante ‘false’.

__arglist cannot have an argument of void type __arglist não pode ter um argumento de tipo nulo

A conditional expression cannot be used directly in a string interpolation because the ':' ends the interpolation. Parenthesize the conditional expression. Uma expressão condicional não pode ser usada diretamente em uma interpolação de cadeia de caracteres porque ‘:’ encerra a interpolação. Use parênteses na expressão condicional.

A default literal 'default' is not valid as a case constant. Use another literal (e.g. '0' or 'null') as appropriate. If you intended to write the default label, use 'default:' without 'case'. Um literal padrão 'default' não é válido como uma constante case. Use outro literal (por exemplo, '0' ou 'null') conforme apropriado. Se sua intenção era gravar o rótulo padrão, use 'default:' sem 'case'.

Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute on a property Não use o atributo 'System.Runtime.CompilerServices.FixedBuffer' em uma propriedade

Feature '{0}' is not available in C# 7.3. Please use language version {1} or greater. O recurso '{0}' não está disponível em C# 7.3. Use a versão da linguagem {1} ou superior.

Field-targeted attributes on auto-properties are not supported in language version {0}. Please use language version {1} or greater. Os atributos direcionados a campo em propriedades automáticas não são compatíveis com a versão da linguagem {0}. Use a versão da linguagem {1} ou superior.

Field-targeted attributes on auto-properties are not supported in this version of the language. Os atributos direcionados a campo em propriedades automáticas não são compatíveis com esta versão da linguagem.

async streams fluxos assíncronos

'{0}': type used in an async using statement must be implicitly convertible to 'System.IAsyncDisposable' or implement a suitable 'DisposeAsync' method. '{0}': o tipo usado em uma instrução using assíncrona deve ser implicitamente conversível em 'System.IAsyncDisposable'

Asynchronous foreach requires that the return type '{0}' of '{1}' must have a suitable public 'MoveNextAsync' method and public 'Current' property A foreach assíncrona requer que o tipo de retorno '{0}' de '{1}' tenha um método 'MoveNextAsync' público adequado e a propriedade 'Current' pública

Asynchronous foreach statement cannot operate on variables of type '{0}' because it implements multiple instantiations of '{1}'; try casting to a specific interface instantiation A instrução foreach assíncrona não pode operar em variáveis do tipo '{0}' porque implementa várias instanciações de '{1}'; tente transmitir para uma instanciação de interface específica