Cannot use '{0}' as a calling convention modifier. Cannot use '{0}' as a calling convention modifier.

Passing '{0}' is not valid unless '{1}' is 'SignatureCallingConvention.Unmanaged'. Passing '{0}' is not valid unless '{1}' is 'SignatureCallingConvention.Unmanaged'.

Cannot create constructed generic type from another constructed generic type. No se puede crear un tipo genérico construido a partir de otro tipo genérico construido.

Cannot create constructed generic type from non-generic type. No se puede crear un tipo genérico construido a partir de un tipo no genérico.

'{0}': abstract event cannot use event accessor syntax "{0}": un evento abstracto no puede usar la sintaxis de descriptor de acceso de eventos

'&' on method groups cannot be used in expression trees '&' on method groups cannot be used in expression trees

Cannot convert &method group '{0}' to non-function pointer type '{1}'. Cannot convert &method group '{0}' to non-function pointer type '{1}'.

To use '@$' instead of '$@' for an interpolated verbatim string, please use language version '{0}' or greater. Para usar "@$" en lugar de "$@" para una cadena textual interpolada, use la versión "{0}" del lenguaje o una posterior.

Operator '{0}' is ambiguous on operands '{1}' and '{2}' Operator '{0}' is ambiguous on operands '{1}' and '{2}'

Operator '{0}' cannot be applied to 'default' and operand of type '{1}' because it is a type parameter that is not known to be a reference type No se puede aplicar el operador "{0}" a "Predeterminado" y a un operando de tipo "{1}", ya que es un parámetro de tipo del que no se conoce que sea un tipo de referencia.

Cannot use a nullable reference type in object creation. No se puede usar un tipo de referencia que acepte valores NULL en la creación de objetos.

Element names are not permitted when pattern-matching via 'System.Runtime.CompilerServices.ITuple'. No se permiten nombres de elemento cuando se lleva a cabo la coincidencia de patrones con "System.Runtime.CompilerServices.ITuple".

It is not legal to use nullable reference type '{0}?' in an as expression; use the underlying type '{0}' instead. No se puede usar el tipo "{0}?" que acepta valores NULL en una expresión as; use en su lugar el tipo "{0}" subyacente.

Init-only property or indexer '{0}' can only be assigned in an object initializer, or on 'this' or 'base' in an instance constructor or an 'init' accessor. Init-only property or indexer '{0}' can only be assigned in an object initializer, or on 'this' or 'base' in an instance constructor or an 'init' accessor.

Attribute '{0}' is not valid on event accessors. It is only valid on '{1}' declarations. El atributo "{0}" no es válido en descriptores de acceso de eventos. Solo es válido en declaraciones "{1}".

Auto-implemented property '{0}' cannot be marked 'readonly' because it has a 'set' accessor. La propiedad implementada automáticamente "{0}" no se puede marcar como "readonly" porque tiene un descriptor de acceso "set".

Auto-implemented 'set' accessor '{0}' cannot be marked 'readonly'. El descriptor de acceso "set" implementado automáticamente "{0}" no puede marcarse como "readonly".

Asynchronous foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a suitable public instance or extension definition for '{1}' Una instrucción foreach asincrónica no puede funcionar en variables de tipo "{0}", porque "{0}" no contiene una definición de instancia pública adecuada para "{1}".

Asynchronous foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a public instance or extension definition for '{1}'. Did you mean 'foreach' rather than 'await foreach'? Una instrucción foreach asincrónica no puede funcionar en variables de tipo "{0}" porque "{0}" no contiene ninguna definición de instancia pública para "{1}". ¿Quiso decir “foreach” en lugar de “await foreach”?

Cannot use a collection of dynamic type in an asynchronous foreach No se puede usar una colección de tipo dinámico en una instrucción foreach asincrónica.

Function pointer '{0}' does not take {1} arguments Function pointer '{0}' does not take {1} arguments

'{0}' cannot be used as a modifier on a function pointer parameter. '{0}' cannot be used as a modifier on a function pointer parameter.

Only records may inherit from records. Only records may inherit from records.

The 'init' accessor is not valid on static members The 'init' accessor is not valid on static members

Invalid option '{0}' for /nullable; must be 'disable', 'enable', 'warnings' or 'annotations' Opción no válida "{0}" para /nullable; debe ser "deshabilitar", ·"habilitar"', "advertencias" o "anotaciones"

The typeof operator cannot be used on a nullable reference type El operador typeof no se puede usar en un tipo de referencia que acepta valores NULL

Operator '{0}' cannot be applied to operand '{1}' Operator '{0}' cannot be applied to operand '{1}'

Invalid operand for pattern match; value required, but found '{0}'. Operando no válido para la coincidencia de patrones. Se requería un valor, pero se encontró '{0}'.

Records may only inherit from object or another record Records may only inherit from object or another record

A positional record must have a non-empty parameter list Un registro posicional debe tener un modificador "data" y una lista de parámetros no vacía

Record member '{0}' must be a readable instance property of type '{1}' to match positional parameter '{2}'. Record member '{0}' must be a readable instance property of type '{1}' to match positional parameter '{2}'.

Command-line syntax error: '{0}' is not a valid value for the '{1}' option. The value must be of the form '{2}'. Error de sintaxis de la línea de comandos: "{0}" no es un valor válido para la opción "{1}". El valor debe tener el formato "{2}".

Cannot convert &method group '{0}' to delegate type '{0}'. Cannot convert &method group '{0}' to delegate type '{0}'.

'managed' calling convention cannot be combined with unmanaged calling convention specifiers. 'managed' calling convention cannot be combined with unmanaged calling convention specifiers.

The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type.

Cannot use an extension method with a receiver as the target of a '&' operator. Cannot use an extension method with a receiver as the target of a '&' operator.

'{0}' must match by init-only of overridden member '{1}' '{0}' must match by init-only of overridden member '{1}'

__arglist cannot have an argument passed by 'in' or 'out' __arglist no puede tener un argumento que se ha pasado con "in" o "out"

Members named 'Clone' are disallowed in records. Members named 'Clone' are disallowed in records.

'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'. '{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}'.

Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}' El parámetro de tipo "{1}" tiene la restricción "unmanaged"; por tanto, "{1}" no se puede usar como restricción para "{0}"

Local function '{0}' must be 'static' in order to use the Conditional attribute Local function '{0}' must be 'static' in order to use the Conditional attribute

An expression of type '{0}' cannot be handled by a pattern of type '{1}'. Please use language version '{2}' or greater to match an open type with a constant pattern. Un patrón de tipo "{0}" no se puede controlar por un patrón de tipo "{1}". Use la versión de lenguaje "{2}" o superior para buscar un tipo abierto con un patrón constante.

A copy constructor in a record must call a copy constructor of the base, or a parameterless object constructor if the record inherits from object. A copy constructor in a record must call a copy constructor of the base, or a parameterless object constructor if the record inherits from object.

A copy constructor '{0}' must be public or protected because the record is not sealed. A copy constructor '{0}' must be public or protected because the record is not sealed.

The name '{0}' does not match the corresponding 'Deconstruct' parameter '{1}'. El nombre "{0}" no coincide con el parámetro de "Deconstruct" correspondiente, "{1}".

The 'default' constraint is valid on override and explicit interface implementation methods only. The 'default' constraint is valid on override and explicit interface implementation methods only.

Type '{0}' cannot be embedded because it has a non-abstract member. Consider setting the 'Embed Interop Types' property to false. El tipo "{0}" no se puede incrustar porque tiene un miembro no abstracto. Puede establecer la propiedad "Incrustar tipos de interoperabilidad" en false.

There is no target type for the default literal. No hay ningún tipo de destino para el literal predeterminado.

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 '_'. Un literal predeterminado "default" no es válido como patrón. Use otro literal (por ejemplo, "0" o "null") según corresponda. Para hacer coincidir todo, use un patrón de descarte "_".

A variable may not be declared within a 'not' or 'or' pattern. A variable may not be declared within a 'not' or 'or' pattern.

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 '_'. El patrón de descarte no se permite como etiqueta de caso en una instrucción switch. Use "case var _:" para un patrón de descarte o "case @_:" para una constante con el nombre '_'.

'{0}' does not override expected property from '{1}'. '{0}' does not override expected property from '{1}'.

'{0}' does not override expected method from '{1}'. '{0}' does not override expected method from '{1}'.

'{0}' does not override expected method from 'object'. '{0}' does not override expected method from 'object'.

A return type can only have one '{0}' modifier. A return type can only have one '{0}' modifier.

'{0}' is explicitly implemented more than once. "{0}" está implementado de forma explícita más de una vez.

Duplicate null suppression operator ('!') Duplicar el operador de supresión de tipo null ("!")

Cannot specify 'readonly' modifiers on both accessors of property or indexer '{0}'. Instead, put a 'readonly' modifier on the property itself. No se pueden especificar modificadores "readonly" en ambos descriptores de acceso de la propiedad o del indizador "{0}". En su lugar, coloque un modificador "readonly" en la propiedad.

'else' cannot start a statement. “else” no puede iniciar una instrucción.

Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed. No se permite la aplicación explícita de "System.Runtime.CompilerServices.NullableAttribute".

Accessors '{0}' and '{1}' should both be init-only or neither Accessors '{0}' and '{1}' should both be init-only or neither

The given expression cannot be used in a fixed statement La expresión proporcionada no se puede utilizar en una instrucción "fixed"

An expression tree may not contain a null coalescing assignment Un árbol de expresión no puede contener una asignación de fusión nula.

Expression tree cannot contain value of ref struct or restricted type '{0}'. Un árbol de expresión no puede contener un valor de estructura ref ni el tipo restringido “{0}”.

An expression tree may not contain a from-end index ('^') expression. An expression tree may not contain a from-end index ('^') expression.

An expression tree may not contain a pattern System.Index or System.Range indexer access An expression tree may not contain a pattern System.Index or System.Range indexer access

An expression tree may not contain a range ('..') expression. An expression tree may not contain a range ('..') expression.

An expression tree may not contain a switch expression. Un árbol de expresión no puede contener una expresión switch.

An expression tree may not contain a tuple == or != operator Un árbol de expresión no puede contener un operador de tupla == o !=.

An expression tree may not contain a with-expression. An expression tree may not contain a with-expression.

'{0}': extern event cannot have initializer "{0}": un evento externo no puede tener un inicializador

The feature '{0}' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version. La característica "{0}" se encuentra actualmente en vista previa y *no se admite*. Para usar características en vista previa, utilice la versión de idioma "vista previa".

Feature '{0}' is experimental and unsupported; use '/features:{1}' to enable. La característica "{0}" es experimental y no se admite. Use "/features:{1}" para habilitarla.

Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 8.0. Use la versión {1} del lenguaje o una posterior.

Feature '{0}' is not available in C# 9.0. Please use language version {1} or greater. Feature '{0}' is not available in C# 9.0. Please use language version {1} or greater.

Field-like event '{0}' cannot be 'readonly'. El evento de tipo campo "{0}" no puede ser "readonly".

foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a public instance or extension definition for '{1}'. Did you mean 'await foreach' rather than 'foreach'? La instrucción foreach no puede funcionar en variables de tipo "{0}" porque "{0}" no contiene ninguna definición de instancia pública para "{1}". ¿Quiso decir “await foreach” en lugar de “foreach”?

Cannot create a function pointer for '{0}' because it is not a static method Cannot create a function pointer for '{0}' because it is not a static method

Ref mismatch between '{0}' and function pointer '{1}' Ref mismatch between '{0}' and function pointer '{1}'

A goto cannot jump to a location before a using declaration within the same block. Una instrucción goto no puede saltar a una ubicación antes que una declaración using dentro del mismo bloque.

A goto cannot jump to a location after a using declaration. Una instrucción goto no puede saltar a una ubicación después de una declaración using.

The suppression operator is not allowed in this context No se permite el operador de supresión en este contexto.

Invocation of implicit Index Indexer cannot name the argument. La invocación del indizador de índices implícito no puede nombrar el argumento.

Invocation of implicit Range Indexer cannot name the argument. La invocación del indizador de rangos implícito no puede nombrar el argumento.

Arguments with 'in' modifier cannot be used in dynamically dispatched expressions. No se pueden usar argumentos con el modificador "in" en expresiones distribuidas dinámicamente.

Instance properties in interfaces cannot have initializers. Instance properties in interfaces cannot have initializers.

'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter “{0}” no puede implementar el miembro de interfaz “{1}” en el tipo “{2}” porque tiene un parámetro __arglist

Internal error in the C# compiler. Error interno en el compilador de C#.

'{0}' is not a valid function pointer return type modifier. Valid modifiers are 'ref' and 'ref readonly'. '{0}' is not a valid function pointer return type modifier. Valid modifiers are 'ref' and 'ref readonly'.

'{0}' is not a valid calling convention specifier for a function pointer. '{0}' is not a valid calling convention specifier for a function pointer.

Invalid hash algorithm name: '{0}' Nombre de algoritmo hash no válido: "{0}"

Invalid object creation Creación de objeto no válida

Cannot specify 'readonly' modifiers on both property or indexer '{0}' and its accessor. Remove one of them. No se pueden especificar modificadores "readonly" en la propiedad o el indizador "{0}" y su descriptor de acceso. Quite uno de ellos.

"Invalid rank specifier: expected ']' "Especificador de rango no válido: se esperaba "]""

The receiver of a `with` expression must have a non-void type. The receiver of a `with` expression must have a non-void type.

It is not legal to use nullable reference type '{0}?' in an is-type expression; use the underlying type '{0}' instead. No se puede usar el tipo "{0}?" que acepta valores NULL en una expresión is-type; use en su lugar el tipo "{0}" subyacente.

An expression of type '{0}' can never match the provided pattern. Una expresión de tipo "{0}" no puede coincidir nunca con el patrón proporcionado.

Method '{0}' with an iterator block must be 'async' to return '{1}' El método "{0}" con un bloqueo de iterador debe ser "asincrónico" para devolver "{1}"

No overload for '{0}' matches function pointer '{1}' No overload for '{0}' matches function pointer '{1}'

Cannot convert method group to function pointer (Are you missing a '&'?) Cannot convert method group to function pointer (Are you missing a '&'?)

Pattern missing Falta un patrón.

Module initializer method '{0}' must not be generic and must not be contained in a generic type Module initializer method '{0}' must not be generic and must not be contained in a generic type

Module initializer method '{0}' must be accessible at the module level Module initializer method '{0}' must be accessible at the module level

A module initializer must be an ordinary member method A module initializer must be an ordinary member method

Module initializer method '{0}' must be static, must have no parameters, and must return 'void' Module initializer method '{0}' must be static, must have no parameters, and must return 'void'

Multiple analyzer config files cannot be in the same directory ('{0}'). No es posible que un mismo directorio ("{0}") contenga varios archivos de configuración del analizador.

The attribute [EnumeratorCancellation] cannot be used on multiple parameters El atributo [EnumeratorCancellation] no se puede usar en varios parámetros

Only a single record partial declaration may have a parameter list Only a single record partial declaration may have a parameter list

The 'new()' constraint cannot be used with the 'unmanaged' constraint La restricción "new()" no se puede utilizar con la restricción "unmanaged"

'{0}': type used in an asynchronous using statement must be implicitly convertible to 'System.IAsyncDisposable' or implement a suitable 'DisposeAsync' method. Did you mean 'using' rather than 'await using'? "{0}": el tipo usado en una instrucción using asincrónica debe poder convertirse de forma implícita en "System.IAsyncDisposable" o implementar un método "DisposeAsync" adecuado. ¿Quiso decir "using" en lugar de "await using"?

'{0}': type used in a using statement must be implicitly convertible to 'System.IDisposable'. Did you mean 'await using' rather than 'using'? "{0}": el tipo usado en una instrucción using debe poder convertirse implícitamente en "System.IDisposable". ¿Quiso decir "await using" en lugar de "using"?

No accessible copy constructor found in base type '{0}'. No accessible copy constructor found in base type '{0}'.

Output directory could not be determined Output directory could not be determined

The receiver type '{0}' is not a valid record type. The receiver type '{0}' is not a valid record type.

Record member '{0}' must be private. Record member '{0}' must be private.

Record member '{0}' must be protected. Record member '{0}' must be protected.

Record member '{0}' must be public. Record member '{0}' must be public.

'{0}' must allow overriding because the containing record is not sealed. '{0}' must allow overriding because the containing record is not sealed.

Expected 'enable', 'disable', or 'restore' Se esperaba "enable", "disable" o "restore".

Expected 'warnings', 'annotations', or end of directive Se esperaban "advertencias", "anotaciones" o el final de la directiva

Invalid '{0}' value: '{1}' for C# {2}. Please use language version '{3}' or greater. Valor "{0}" no válido: "{1}" para C# {2}. Use la versión del lenguaje "{3}" o una posterior.

A nullable type parameter must be known to be a value type or non-nullable reference type unless language version '{0}' or greater is used. Consider changing the language version or adding a 'class', 'struct', or type constraint. A nullable type parameter must be known to be a value type or non-nullable reference type unless language version '{0}' or greater is used. Consider changing the language version or adding a 'class', 'struct', or type constraint.

Omitting the type argument is not allowed in the current context Omitting the type argument is not allowed in the current context

An out variable cannot be declared as a ref local Una variable out no se puede declarar como ref local

Method '{0}' specifies a 'default' constraint for type parameter '{1}', but corresponding type parameter '{2}' of overridden or explicitly implemented method '{3}' is constrained to a reference type or a value type. Method '{0}' specifies a 'default' constraint for type parameter '{1}', but corresponding type parameter '{2}' of overridden or explicitly implemented method '{3}' is constrained to a reference type or a value type.

Method '{0}' specifies a 'class' constraint for type parameter '{1}', but corresponding type parameter '{2}' of overridden or explicitly implemented method '{3}' is not a reference type. El método "{0}" especifica una restricción "class" para el parámetro de tipo "{1}", pero el parámetro de tipo correspondiente "{2}" de los métodos invalidados o implementados explícitamente "{3}" no es un tipo de referencia.

Method '{0}' specifies a 'struct' constraint for type parameter '{1}', but corresponding type parameter '{2}' of overridden or explicitly implemented method '{3}' is not a non-nullable value type. El método "{0}" especifica una restricción "struct" para el parámetro de tipo "{1}", pero el parámetro de tipo correspondiente "{2}" de los métodos invalidados o implementados explícitamente "{3}" no es un tipo de valor que acepta valores NULL.

Both partial method declarations must have identical accessibility modifiers. Both partial method declarations must have identical accessibility modifiers.

Both partial method declarations must have identical combinations of 'virtual', 'override', 'sealed', and 'new' modifiers. Both partial method declarations must have identical combinations of 'virtual', 'override', 'sealed', and 'new' modifiers.

Both partial method declarations must be readonly or neither may be readonly Ambas declaraciones de métodos parciales deben ser de solo lectura o ninguna de ellas puede ser de solo lectura

Partial method declarations must have matching ref return values. Partial method declarations must have matching ref return values.

Both partial method declarations must have the same return type. Both partial method declarations must have the same return type.

Partial method '{0}' must have an implementation part because it has accessibility modifiers. Partial method '{0}' must have an implementation part because it has accessibility modifiers.

Partial method '{0}' must have accessibility modifiers because it has a 'virtual', 'override', 'sealed', 'new', or 'extern' modifier. Partial method '{0}' must have accessibility modifiers because it has a 'virtual', 'override', 'sealed', 'new', or 'extern' modifier.

Partial method '{0}' must have accessibility modifiers because it has a non-void return type. Partial method '{0}' must have accessibility modifiers because it has a non-void return type.

Partial method '{0}' must have accessibility modifiers because it has 'out' parameters. Partial method '{0}' must have accessibility modifiers because it has 'out' parameters.

Pattern-matching is not permitted for pointer types. No se permite la coincidencia de patrones para tipos de puntero.

The body of an async-iterator method must contain a 'yield' statement. El cuerpo de un método async-iterator debe contener una instrucción "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. El cuerpo de un método async-iterator debe contener una instrucción "yield". Considere quitar "async" de la declaración del método o agregar una instrucción "yield".

A property subpattern requires a reference to the property or field to be matched, e.g. '{{ Name: {0} }}' El subpatrón de una propiedad requiere una referencia a la propiedad o al campo que debe coincidir; por ejemplo, "{{ Name: {0} }}"

Type '{0}' cannot be embedded because it has a re-abstraction of a member from base interface. Consider setting the 'Embed Interop Types' property to false. El tipo "{0}" no se puede insertar porque tiene una reabstracción de un miembro de la interfaz base. Puede establecer la propiedad "Incrustar tipos de interoperabilidad" en false.

'{0}': 'readonly' can only be used on accessors if the property or indexer has both a get and a set accessor "{0}": "readonly" solo se puede usar en los descriptores de acceso si la propiedad o el indexador tienen un descriptor de acceso get y set

Cannot ref-assign '{1}' to '{0}' because '{1}' has a narrower escape scope than '{0}'. No se puede asignar referencia "{1}" a "{0}" porque "{1}" tiene un ámbito de escape más limitado que "{0}".

The left-hand side of a ref assignment must be a ref local or parameter. La parte izquierda de una asignación de referencias debe ser una referencia local o un parámetro.

Relational patterns may not be used for a floating-point NaN. Relational patterns may not be used for a floating-point NaN.

'{0}': Target runtime doesn't support covariant types in overrides. Type must be '{2}' to match overridden member '{1}' '{0}': Target runtime doesn't support covariant types in overrides. Type must be '{2}' to match overridden member '{1}'

'{0}': Target runtime doesn't support covariant return types in overrides. Return type must be '{2}' to match overridden member '{1}' '{0}': Target runtime doesn't support covariant return types in overrides. Return type must be '{2}' to match overridden member '{1}'

Target runtime doesn't support 'protected', 'protected internal', or 'private protected' accessibility for a member of an interface. El entorno de ejecución de destino no admite la accesibilidad protegida, protegida interna o protegida privada para un miembro de una interfaz.

The target runtime doesn't support extensible or runtime-environment default calling conventions. The target runtime doesn't support extensible or runtime-environment default calling conventions.

'{0}' cannot be sealed because containing record is not sealed. '{0}' cannot be sealed because containing record is not sealed.

Record member '{0}' must return '{1}'. Record member '{0}' must return '{1}'.

Cannot specify /main if there is a compilation unit with top-level statements. Cannot specify /main if there is a compilation unit with top-level statements.

Cannot use local variable or local function '{0}' declared in a top-level statement in this context. Cannot use local variable or local function '{0}' declared in a top-level statement in this context.

Only one compilation unit can have top-level statements. Only one compilation unit can have top-level statements.

Program using top-level statements must be an executable. Program using top-level statements must be an executable.

A single-element deconstruct pattern requires some other syntax for disambiguation. It is recommended to add a discard designator '_' after the close paren ')'. Un patrón de deconstrucción de un solo elemento requiere más sintaxis para la desambiguación. Se recomienda agregar un designador de descarte "_" después del paréntesis de cierre ")".

Record member '{0}' may not be static. Record member '{0}' may not be static.

A static anonymous function cannot contain a reference to 'this' or 'base'. A static anonymous function cannot contain a reference to 'this' or 'base'.

A static anonymous function cannot contain a reference to '{0}'. A static anonymous function cannot contain a reference to '{0}'.

A static local function cannot contain a reference to 'this' or 'base'. Una función local estática no puede contener una referencia a "this" o "base".

A static local function cannot contain a reference to '{0}'. Una función local estática no puede contener una referencia a "{0}".

Static member '{0}' cannot be marked 'readonly'. El miembro estático "{0}" no se puede marcar como "readonly".

stdin argument '-' is specified, but input has not been redirected from the standard input stream. stdin argument '-' is specified, but input has not been redirected from the standard input stream.

The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match. El patrón ya se ha controlado con una parte anterior de la expresión switch.

The switch case is unreachable. It has already been handled by a previous case or it is impossible to match. El caso del modificador ya se ha gestionado en un caso anterior.

No best type was found for the switch expression. No se encontró el mejor tipo para la expresión switch.

Parentheses are required around the switch governing expression. La expresión switch aplicable requiere paréntesis.

Top-level statements must precede namespace and type declarations. Top-level statements must precede namespace and type declarations.

Unexpected character sequence '...' Secuencia de caracteres "..." inesperada.

The name '{0}' does not identify tuple element '{1}'. El nombre "{0}" no identifica el 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. Los tipos de tupla utilizados como operandos de un operador == o != deben tener cardinalidades coincidentes. Pero este operador tiene tipos de tupla de cardinalidad {0} a la izquierda y {1} a la derecha.

The 'class', 'struct', 'unmanaged', 'notnull', and 'default' constraints cannot be combined or duplicated, and must be specified first in the constraints list. The 'class', 'struct', 'unmanaged', 'notnull', and 'default' constraints cannot be combined or duplicated, and must be specified first in the constraints list.

Type '{0}' must be public to be used as a calling convention. Type '{0}' must be public to be used as a calling convention.

Type '{0}' is not defined. Type '{0}' is not defined.

The type '{0}' may not be used as the target type of new() The type '{0}' may not be used as the target type of new()

There is no target type for '{0}' There is no target type for '{0}'

Use of new() is not valid in this context Use of new() is not valid in this context

Unexpected argument list. Unexpected argument list.

A constructor declared in a record with parameters must have 'this' constructor initializer. A constructor declared in a record with parameters must have 'this' constructor initializer.

'{0}': cannot specify both a constraint class and the 'unmanaged' constraint "{0}": no se puede especificar a la vez una clase de restricción y la restricción "unmanaged"

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}' "{2}" debe ser un tipo de valor que no acepta valores NULL, junto con todos los campos de cualquier nivel de anidamiento, para poder usarlo como parámetro "{1}" en el tipo o método genérico "{0}"

The calling convention of '{0}' is not supported by the language. The calling convention of '{0}' is not supported by the language.

Relational patterns may not be used for a value of type '{0}'. Relational patterns may not be used for a value of type '{0}'.

A using variable cannot be used directly within a switch section (consider using braces). Una variable using no se puede usar directamente en una sección switch (considere el uso de llaves).

The syntax 'var' for a pattern is not permitted to refer to a type, but '{0}' is in scope here. La sintaxis "var" de un patrón no puede hacer referencia a un tipo, pero "{0}" está dentro del ámbito aquí.

Enums, classes, and structures cannot be declared in an interface that has an 'in' or 'out' type parameter. Las enumeraciones, las clases y las estructuras no se pueden declarar en una interfaz que tenga un parámetro de tipo "in" o "out".

Calling convention of '{0}' is not compatible with '{1}'. Calling convention of '{0}' is not compatible with '{1}'.

Matching the tuple type '{0}' requires '{1}' subpatterns, but '{2}' subpatterns are present. La coincidencia del tipo de tupla "{0}" requiere subpatrones "{1}", pero hay subpatrones "{2}".

File name '{0}' is empty, contains invalid characters, has a drive specification without an absolute path, or is too long El nombre de archivo '{0}' está vacío, contiene caracteres no válidos, tiene una especificación de unidad sin ruta de acceso absoluta o es demasiado largo

&method group &method group

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 (use "nullable" for all nullability warnings) -warn:<n> Set warning level (0 or higher) (Short form: -w) -nowarn:<warn list> Disable specific warning messages (use "nullable" for all nullability warnings) -ruleset:<file> Specify a ruleset file that disables specific diagnostics. -errorlog:<file>[,version=<sarif_version>] Specify a file to log all compiler and analyzer diagnostics. sarif_version:{1|2|2.1} Default is 1. 2 and 2.1 both mean SARIF version 2.1.0. -reportanalyzer Report additional analyzer information, such as execution time. -skipanalyzers[+|-] Skip execution of diagnostic analyzers. - 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 `latest` (latest version, including minor versions), `default` (same as `latest`), `latestmajor` (latest version, excluding minor versions), `preview` (latest version, including features in unsupported preview), or specific versions like `6` or `7.1` -nullable[+|-] Specify nullable context option enable|disable. -nullable:{enable|disable|warnings|annotations} Specify nullable context option enable|disable|warnings|annotations. - 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 Opciones del compilador de Visual C# - ARCHIVOS DE SALIDA - -out:<archivo> Especifica el nombre del archivo de salida (el valor predeterminado: nombre base del archivo con la clase principal o el primer archivo) -target:exe Compila un archivo ejecutable de consola (predeterminado) (forma corta: -t:exe) -target:winexe Compila un archivo ejecutable de Windows (forma corta: -t:winexe) -target:library Compila una biblioteca (forma corta: -t:library) -target:module Compila un módulo que se puede agregar a otro ensamblado (forma corta: -t:module) -target:appcontainerexe Compila un archivo ejecutable Appcontainer (forma corta: -t:appcontainerexe) -target:winmdobj Compila un archivo intermedio de Windows Runtime para que consuma WinMDExp (forma corta: -t:winmdobj) -doc:<archivo> Archivo de documentación XML que se va a generar -refout:<archivo> Salida de ensamblado de referencia para generar -platform:<cadena> Limita en qué plataformas se puede ejecutar este código: x86, Itanium, x64, arm, anycpu32bitpreferred o anycpu. La predeterminada es anycpu. - ARCHIVOS DE ENTRADA - -recurse:<comodín> Incluye todos los archivos del directorio actual y los subdirectorios de acuerdo con las especificaciones del comodín -reference:<alias>=<archivo> Metadatos de referencia del archivo de ensamblado especificado mediante el alias dado (forma corta: -r) -reference:<lista de archivos> Metadatos de referencia de los archivos de ensamblado especificados (forma corta: -r) -addmodule:<lista de archivos> Vincula los módulos especificados en este ensamblado -link:<lista de archivos> Inserta metadatos de los archivos de ensamblado de interoperabilidad especificados (forma corta: -l) -analyzer:<lista de archivos> Ejecuta los analizadores de este ensamblado (forma corta: -a) -additionalfile:<lista de archivos> Archivos adicionales que no afectan directamente a la generación de código pero que pueden usar los analizadores para producir errores o advertencias. -embed Inserta todos los archivos de origen en el PDB. -embed:<lista de archivos> Inserta los archivos especificados en el PDB - RECURSOS - -win32res:<archivo> Especifica un archivo de recursos Win32 (.res) -win32icon:<archivo> Usa este icono para la salida -win32manifest:<archivo> Especifica un archivo de manifiesto Win32 (.xml) -nowin32manifest No incluye el manifiesto Win32 predeterminado -resource:<resinfo> Insertar el recurso especificado (forma corta: -res) -linkresource:<info recurso> Vincula el recurso especificado con este ensamblado (forma corta: -linkres) Donde el formato de resinfo es <archivo>[,<nombre de cadena>[,public|private]] - GENERACIÓN DE CÓDIGO - -debug[+|-] Emite información de depuración -debug:{full|pdbonly|portable|embedded} Especifica el tipo de depuración ("full"' es el valor predeterminado, "portable" es un formato multiplataforma, "embedded" es un formato multiplataforma insertado en el archivo .dll o .exe de destino) -optimize[+|-] Permite optimizaciones (forma corta: -o) -deterministic Produce un ensamblado determinista (que incluye el GUID y la marca de tiempo de la versión del módulo) -refonly Produce un ensamblado de referencia en lugar de la salida principal -instrument:TestCoverage Produce un ensamblado instrumentado para recopilar información de cobertura -sourcelink:<archivo> Información del vínculo de origen para insertar en el PDB. - ERRORES Y ADVERTENCIAS - -warnaserror[+|-] Notifica todas las advertencias como errores -warnaserror[+|-]:<lista de advertencias> Notifica advertencias específicas como errores -warn:<n> Establece el nivel de advertencia (de 0 a 4) (forma corta: -w) -nowarn:<lista de advertencias> Deshabilita mensajes de advertencia específicos -ruleset:<archivo> Especifica un archivo de conjunto de reglas que deshabilite diagnósticos específicos. -errorlog:<archivo>[,version=<versión_de_sarif >] Especifica un archivo para registrar todos los diagnósticos del compilador y el analizador. sarif_version:{1|2|2.1} El valor predeterminado es 1. 2 y 2.1 significa SARIF versión 2.1.0. -reportanalyzer Notifica información adicional del analizador, como el tiempo de ejecución. - LENGUAJE - -checked[+|-] Genera comprobaciones de desbordamiento -unsafe[+|-] Permite código "no seguro" -define:<lista de símbolos> Define símbolos de compilación condicional (forma corta: -d) -langversion:? Muestra los valores permitidos para la versión de lenguaje\ r -langversion:<cadena> Especifica la versión de lenguaje como “latest” (última versión, incluidas las secundarias, “default” (igual que “latest”), “latestmajor” (última versión, excluidas las secundarias), “preview” (última versión, incluidas las características en la versión preliminar no admitida) o versiones específicas como “6” o “7.1” -nullable[+|-] Especifique la opción de contexto anulable enable|disable. -nullable:{enable|disable|warnings|annotations} Especifique la opción de contexto anulable enable|disable|warnings|annotations. - SEGURIDAD - -delaysign[+|-] Retrasa la firma del ensamblado usando solo la parte pública de la clave de nombre seguro -publicsign[+|-] Publica la firma del ensamblado usando solo la parte pública de la clave de nombre seguro -keyfile:<archivo> Especifica un archivo de clave de nombre seguro -keycontainer:<cadena> Especifica un contenedor de claves de nombres seguros -highentropyva[+|-] Habilita ASLR de alta entropía - VARIOS - @<archivo> Lee el archivo de respuesta para ver más opciones -help Muestra este mensaje de uso (forma corta: -?) -nologo Suprime el mensaje de copyright del compilador -noconfig No incluye automáticamente el archivo CSC.RSP -parallel[+|-] Compilación simultánea. -version Muestra el número de versión del compilador y cierra. - AVANZADO - -baseaddress:<dirección> Dirección base de la biblioteca que se compilará -checksumalgorithm:<alg> Especifica el algoritmo para calcular la suma de comprobación del archivo de origen almacenado en PDB. Los valores admitidos son: SHA1 o SHA256 (predeterminado). -codepage:<n> Especifica la página de código que se usará al abrir los archivos de origen -utf8output Mensajes de compilador de salida en codificación UTF-8 -main:<tipo> Especifica el tipo que contiene el punto de entrada (ignora todos los demás puntos de entrada posibles) (Forma corta: -m) -fullpaths El compilador genera rutas de acceso completas -filealign:<n> Especifica la alineación usada para las secciones del archivo de salida -pathmap:<K1>=<V1>,<K2>=<V2>,... Especifica una asignación para los nombres de rutas de acceso de origen emitidos por el compilador. -pdb:<archivo> Especifica el nombre de archivo de información de depuración (valor predeterminado: nombre de archivo de salida con la extensión .pdb) -errorendlocation Línea y columna de salida de la ubicación final de cada error -preferreduilang Especifica el nombre del lenguaje de salida preferido. -nosdkpath Deshabilita la búsqueda de la ruta del SDK predeterminada para los ensamblados de biblioteca estándar. -nostdlib[+|-] No hace referencia a la biblioteca estándar (mscorlib.dll) -subsystemversion:<cadena> Especifica la versión del subsistema de este ensamblado -lib:<lista de archivos> Especifica directorios adicionales en los que buscar referencias -errorreport:<cadena> Especifica cómo tratar los errores internos del compilador: avisar, enviar, poner en cola o ninguno. El valor predeterminado es poner en cola. -appconfig:<archivo> Especifica un archivo de configuración de aplicación que contenga opciones de enlace de ensamblado -moduleassemblyname:<cadena> Nombre del ensamblado del que esté módulo formará parte -modulename:<cadena> Especifica el nombre del módulo de origen Visual C# Compiler Options

default interface implementation implementación de interfaz predeterminada

disposable descartable

alternative interpolated verbatim strings cadenas textuales interpoladas alternativas

and pattern and pattern

asynchronous using using asincrónica

coalescing assignment asignación de incorporación

covariant returns covariant returns

default type parameter constraints default type parameter constraints

delegate generic type constraints restricciones de tipo genérico delegate

enum generic type constraints restricciones de tipo genérico enum

declaration of expression variables in member initializers and queries declaración de variables de expresión en inicializadores y consultas de miembros

extended partial methods extended partial methods

extensible fixed statement instrucción "fixed" extensible

extension GetAsyncEnumerator extension GetAsyncEnumerator

extension GetEnumerator extension GetEnumerator

extern local functions extern local functions

function pointers function pointers

index operator operador de índice

indexing movable fixed buffers indexando búferes fijos movibles

init-only setters init-only setters

local function attributes local function attributes

lambda discard parameters parámetros de descarte de lambda

MemberNotNull attribute MemberNotNull attribute

module initializers module initializers

name shadowing in nested functions sombreado de nombres en funciones anidadas

native-sized integers native-sized integers

stackalloc in nested expressions stackalloc en expresiones anidadas

notnull generic type constraint restricción de tipo genérico notnull

not pattern not pattern

null pointer constant pattern null pointer constant pattern

nullable reference types tipos de referencia que aceptan valores NULL

obsolete on property accessor descriptor de acceso obsoleto en propiedad

or pattern or pattern

parenthesized pattern parenthesized pattern

warning action enable acción de advertencia "enable"

range operator operador de intervalo

readonly members miembros de solo lectura

records records

recursive patterns patrones recursivos

ref conditional expression expresión condicional de referencia

ref for-loop variables variables for-loop de referencias

ref foreach iteration variables variables de iteración foreach de referencias

ref reassignment reasignación de referencias

relational pattern relational pattern

stackalloc initializer inicializador stackalloc

static anonymous function static anonymous function

static local functions funciones locales estáticas

target-typed conditional expression target-typed conditional expression

target-typed object creation target-typed object creation

tuple equality igualdad de tupla

type pattern type pattern

unconstrained type parameters in null coalescing operator parámetros de tipo sin restricciones en operador de incorporación nulo

unmanaged constructed types tipos construidos no administrados

unmanaged generic type constraints restricciones de tipo genérico unmanaged

using declarations declaraciones using

constraints for override and explicit interface implementation methods restricciones para métodos de implementación de interfaz explícita e invalidación

(Location of symbol related to previous error) (Ubicación del símbolo relacionado con el error anterior)

(Location of symbol related to previous warning) (Ubicación del símbolo relacionado con la advertencia anterior)

top-level statements top-level statements

Badly formed XML file "{0}" cannot be included El archivo XML con formato incorrecto "{0}" no se puede incluir

Failed to insert some or all of included XML Error al insertar algunos de los XML de inclusión o todos ellos

Include tag is invalid La etiqueta de inclusión no es válida

No matching elements were found for the following include tag No se encontraron elementos coincidentes para la siguiente etiqueta de inclusión

Missing file attribute Falta el atributo de archivo

Missing path attribute Falta el atributo 'path'

generics genéricos

anonymous methods métodos anónimos

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

namespace alias qualifier calificador de alias de espacio de nombres

fixed size buffers búferes de tamaño fijo

#pragma #pragma

static classes clases estáticas

readonly structs estructuras readonly

partial types tipos parciales

async function función asincrónica

switch on boolean type activar tipo booleano

method group grupo de métodos

anonymous method método anónimo

lambda expression expresión lambda

collection colección

access modifiers on properties modificadores de acceso en propiedades

extern alias alias externo

iterators iteradores

default operator operador predeterminado

default literal literal predeterminado

private protected private protected

nullable types tipos que aceptan valores NULL

pattern matching coincidencia de patrones

expression body property accessor descriptor de acceso de propiedades del cuerpo de expresión

expression body constructor and destructor constructor y destructor del cuerpo de expresión

throw expression expresión throw

implicitly typed array matriz con tipo implícito

implicitly typed local variable variable local con tipo implícito

anonymous types tipos anónimos

automatically implemented properties propiedades implementadas automáticamente

readonly automatically implemented properties propiedades de solo lectura implementadas automáticamente

object initializer inicializador de objeto

collection initializer inicializador de colección

query expression expresión de consulta

extension method método de extensión

partial method método parcial

method método

type tipo

namespace espacio de nombres

field campo

property propiedad

element elemento

variable variable

label etiqueta

event evento

type parameter parámetro de tipo

using alias alias using

extern alias alias externo

constructor constructor

foreach iteration variable variable de iteración foreach

fixed variable variable fixed

using variable variable using

contravariant contravariante

contravariantly de forma contravariante

covariant covariante

covariantly de forma covariante

invariantly de forma no variante

dynamic dinámico

named argument argumento con nombre

optional parameter parámetro opcional

exception filter filtro de excepciones

type variance varianza de tipo

Given {0} parameter types and {1} parameter ref kinds. These arrays must have the same length. Given {0} parameter types and {1} parameter ref kinds. These arrays must have the same length.

'RefKind.Out' is not a valid ref kind for a return type. 'RefKind.Out' is not a valid ref kind for a return type.

SyntaxTree is not part of the compilation SyntaxTree no forma parte de la compilación

SyntaxTree is not part of the compilation, so it cannot be removed SyntaxTree no forma parte de la compilación, así que no se puede quitar

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. El nombre "_" hace referencia a la constante, no al patrón de descarte. Use "var _" para descartar el valor o "@_" para hacer referencia a una constante con ese nombre.

Do not use '_' for a case constant. No use "_" para una constante de caso.

Constant value '{0}' may overflow '{1}' at runtime (use 'unchecked' syntax to override) Constant value '{0}' may overflow '{1}' at runtime (use 'unchecked' syntax to override)

Constant value may overflow at runtime (use 'unchecked' syntax to override) Constant value may overflow at runtime (use 'unchecked' syntax to override)

Converting null literal or possible null value to non-nullable type. Se va a convertir un literal nulo o un posible valor nulo en un tipo que no acepta valores NULL

A possible null value may not be used for a type marked with [NotNull] or [DisallowNull] No se puede usar un posible valor null para un tipo marcado con [NotNull] o [DisallowNull]

Method '{0}' lacks `[DoesNotReturn]` annotation to match implemented or overridden member. Method '{0}' lacks `[DoesNotReturn]` annotation to match implemented or overridden member.

Method lacks `[DoesNotReturn]` annotation to match implemented or overridden member. Method lacks `[DoesNotReturn]` annotation to match implemented or overridden member.

'{0}' is already listed in the interface list on type '{1}' with different nullability of reference types. "{0}" ya está en la lista de interfaces del tipo "{1}" con una nulabilidad diferente de los tipos de referencia.

Interface is already listed in the interface list with different nullability of reference types. La interfaz ya está en la lista de interfaces con una nulabilidad diferente de los tipos de referencia.

Generator '{0}' failed to generate source. It will not contribute to the output and compilation errors may occur as a result. Exception was of type '{1}' with message '{2}' Generator '{0}' failed to generate source. It will not contribute to the output and compilation errors may occur as a result. Exception was of type '{1}' with message '{2}' {0} is the name of the generator that failed. {1} is the type of exception that was thrown {2} is the message in the exception

Generator threw the following exception: '{0}'. Generator threw the following exception: '{0}'. {0} is the string representation of the exception that was thrown.

Generator failed to generate source. Generator failed to generate source.

Generator '{0}' failed to initialize. It will not contribute to the output and compilation errors may occur as a result. Exception was of type '{1}' with message '{2}' Generator '{0}' failed to initialize. It will not contribute to the output and compilation errors may occur as a result. Exception was of type '{1}' with message '{2}' {0} is the name of the generator that failed. {1} is the type of exception that was thrown {2} is the message in the exception

Generator threw the following exception: '{0}'. Generator threw the following exception: '{0}'. {0} is the string representation of the exception that was thrown.

Generator failed to initialize. Generator failed to initialize.

The given expression always matches the provided constant. La expresión dada coincide siempre con la constante proporcionada.

The given expression always matches the provided pattern. The given expression always matches the provided pattern.

The given expression never matches the provided pattern. La expresión dada no coincide nunca con el patrón proporcionado.

Call to non-readonly member '{0}' from a 'readonly' member results in an implicit copy of '{1}'. La llamada a un miembro "{0}" que no es de solo lectura desde un miembro "readonly" da como resultado una copia implícita de "{1}".

Call to non-readonly member from a 'readonly' member results in an implicit copy. La llamada a un miembro que no es de solo lectura desde un miembro "readonly" da como resultado una copia implícita.

An expression of type '{0}' always matches the provided pattern. An expression of type '{0}' always matches the provided pattern.

The input always matches the provided pattern. The input always matches the provided pattern.

The name '_' refers to the type '{0}', not the discard pattern. Use '@_' for the type, or 'var _' to discard. El nombre "_" hace referencia al tipo "{0}", no al patrón de descarte. Use "@_" para el tipo o "var _" para el descarte.

Do not use '_' to refer to the type in an is-type expression. No use "_" para hacer referencia al tipo en una expresión is-type.

Member '{0}' must have a non-null value when exiting. Member '{0}' must have a non-null value when exiting.

Member '{0}' cannot be used in this attribute. Member '{0}' cannot be used in this attribute.

Member cannot be used in this attribute. Member cannot be used in this attribute.

Member '{0}' must have a non-null value when exiting with '{1}'. Member '{0}' must have a non-null value when exiting with '{1}'.

Member must have a non-null value when exiting in some condition. Member must have a non-null value when exiting in some condition.

Member must have a non-null value when exiting. Member must have a non-null value when exiting.

The annotation for nullable reference types should only be used in code within a '#nullable' annotations context. La anotación para tipos de referencia que aceptan valores NULL solo debe usarse en el código dentro de un contexto de anotaciones "#nullable".

The annotation for nullable reference types should only be used in code within a '#nullable' annotations context. Auto-generated code requires an explicit '#nullable' directive in source. La anotación de tipos de referencia que aceptan valores NULL solo se debe usar en el código en un contexto de anotaciones "#nullable". El código generado automáticamente requiere una directiva "#nullable" explícita en el código fuente.

Cannot convert null literal to non-nullable reference type. No se puede convertir un literal NULL en un tipo de referencia que no acepta valores NULL.

Possible null reference argument for parameter '{0}' in '{1}'. Posible argumento de referencia nulo para el parámetro "{0}" en "{1}".

Possible null reference argument. Posible argumento de referencia nulo

Possible null reference assignment. Posible asignación de referencia nula.

Possible null reference assignment. Posible asignación de referencia nula

Object or collection initializer implicitly dereferences possibly null member '{0}'. El inicializador de objeto o colección desreferencia el miembro "{0}" posiblemente NULL de forma implícita.

Object or collection initializer implicitly dereferences possibly null member. El inicializador de objeto o colección desreferencia el miembro posiblemente NULL de forma implícita.

Dereference of a possibly null reference. Desreferencia de una referencia posiblemente NULL.

Possible null reference return. Posible tipo de valor devuelto de referencia nulo.

Possible null reference return. Posible tipo de valor devuelto de referencia nulo

Argument of type '{0}' cannot be used for parameter '{2}' of type '{1}' in '{3}' due to differences in the nullability of reference types. El argumento de tipo "{0}" no se puede usar para el parámetro "{2}" de tipo "{1}" en "{3}" debido a las diferencias en la nulabilidad de los tipos de referencia.

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. El argumento de tipo "{0}" no se puede usar como salida de tipo "{1}" para el parámetro "{2}" en "{3}" debido a las diferencias en la nulabilidad de los tipos de referencia.

Argument cannot be used as an output for parameter due to differences in the nullability of reference types. El argumento no se puede usar como salida para el parámetro debido a las diferencias en la nulabilidad de los tipos de referencia.

Argument cannot be used for parameter due to differences in the nullability of reference types. El argumento no se puede usar para el parámetro debido a las diferencias en la nulabilidad de los tipos de referencia.

Nullability of reference types in value of type '{0}' doesn't match target type '{1}'. La nulabilidad de los tipos de referencia en el valor de tipo "{0}" no coincide con el tipo de destino "{1}".

Nullability of reference types in value doesn't match target type. La nulabilidad de los tipos de referencia del valor no coincide con el 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. La nulabilidad de las restricciones del parámetro de tipo "{0}" del método "{1}" no coincide con las restricciones del parámetro de tipo "{2}" del método de interfaz "{3}". Considere usar una implementación de interfaz explícita en su lugar.

Nullability in constraints for type parameter doesn't match the constraints for type parameter in implicitly implemented interface method'. La nulabilidad de las restricciones del parámetro de tipo no coincide con las restricciones del parámetro de tipo del método de interfaz implementado de forma implícita

Partial method declarations of '{0}' have inconsistent nullability in constraints for type parameter '{1}' Las declaraciones de métodos parciales de "{0}" tienen una nulabilidad incoherente de las restricciones para el parámetro de tipo "{1}"

Partial method declarations have inconsistent nullability in constraints for type parameter Las declaraciones de métodos parciales tienen una nulabilidad incoherente de las restricciones para el parámetro de tipo

Nullability of reference types in explicit interface specifier doesn't match interface implemented by the type. La nulabilidad de los tipos de referencia del especificador de interfaz explícito no coincide con la interfaz que el tipo implementa.

'{0}' does not implement interface member '{1}'. Nullability of reference types in interface implemented by the base type doesn't match. "{0}" no implementa el miembro de interfaz "{1}". La nulabilidad de los tipos de referencia de la interfaz que implementa el tipo base no coincide.

Type does not implement interface member. Nullability of reference types in interface implemented by the base type doesn't match. El tipo no implementa un miembro de interfaz. La nulabilidad de los tipos de referencia de la interfaz que implementa el tipo base no coincide.

Nullability of reference types in type of parameter '{0}' of '{1}' doesn't match the target delegate '{2}'. La nulabilidad de los tipos de referencia del tipo de parámetro "{0}" de "{1}" no coincide con el delegado de destino "{2}".

Nullability of reference types in type of parameter doesn't match the target delegate. La nulabilidad de los tipos de referencia del tipo de parámetro no coincide con el delegado de destino

Nullability of reference types in type of parameter '{0}' doesn't match implemented member '{1}'. La nulabilidad de los tipos de referencia del tipo de parámetro "{0}" no coincide con el miembro implementado "{1}".

Nullability of reference types in type of parameter doesn't match implemented member. La nulabilidad de los tipos de referencia del tipo de parámetro no coincide con el miembro implementado

Nullability of reference types in type of parameter '{0}' of '{1}' doesn't match implicitly implemented member '{2}'. La nulabilidad de los tipos de referencia del tipo de parámetro"{0}" de "{1}" no coincide con el miembro "{2}" implementado de forma implícita.

Nullability of reference types in type of parameter doesn't match implicitly implemented member. La nulabilidad de los tipos de referencia del tipo de parámetro no coincide con el miembro implementado de forma implícita

Nullability of reference types in type of parameter '{0}' doesn't match overridden member. La nulabilidad de los tipos de referencia del tipo de parámetro"{0}" no coincide con el miembro reemplazado.

Nullability of reference types in type of parameter doesn't match overridden member. La nulabilidad de los tipos de referencia del tipo de parámetro no coincide con el miembro reemplazado

Nullability of reference types in type of parameter '{0}' doesn't match partial method declaration. La nulabilidad de los tipos de referencia del tipo de parámetro"{0}" no coincide con la declaración de método parcial.

Nullability of reference types in type of parameter doesn't match partial method declaration. La nulabilidad de los tipos de referencia del tipo de parámetro no coincide con la declaración de método parcial

Nullability of reference types in return type of '{0}' doesn't match the target delegate '{1}'. La nulabilidad de los tipos de referencia en el tipo de valor devuelto de "{0}" no coincide con el delegado de destino "{1}".

Nullability of reference types in return type doesn't match the target delegate. La nulabilidad de los tipos de referencia en el tipo de valor devuelto no coincide con el delegado de destino

Nullability of reference types in return type doesn't match implemented member '{0}'. La nulabilidad de los tipos de referencia en el tipo de valor devuelto no coincide con el miembro implementado "{0}".

Nullability of reference types in return type doesn't match implemented member. La nulabilidad de los tipos de referencia en el tipo de valor devuelto no coincide con el miembro implementado

Nullability of reference types in return type of '{0}' doesn't match implicitly implemented member '{1}'. La nulabilidad de los tipos de referencia del tipo de valor devuelto de "{0}" no coincide con el miembro "{1}" implementado de forma implícita.

Nullability of reference types in return type doesn't match implicitly implemented member. La nulabilidad de los tipos de referencia en el tipo de valor devuelto no coincide con el miembro implementado de forma implícita

Nullability of reference types in return type doesn't match overridden member. La nulabilidad de los tipos de referencia en el tipo de valor devuelto no coincide con el miembro reemplazado.

Nullability of reference types in return type doesn't match overridden member. La nulabilidad de los tipos de referencia en el tipo de valor devuelto no coincide con el miembro reemplazado

Nullability of reference types in return type doesn't match partial method declaration. Nullability of reference types in return type doesn't match partial method declaration.

Nullability of reference types in type doesn't match implemented member '{0}'. La nulabilidad de los tipos de referencia del tipo no coincide con el miembro implementado "{0}".

Nullability of reference types in type doesn't match implemented member. La nulabilidad de los tipos de referencia del tipo no coincide con el miembro implementado

Nullability of reference types in type of '{0}' doesn't match implicitly implemented member '{1}'. La nulabilidad de los tipos de referencia del tipo de "{0}" no coincide con el miembro "{1}" implementado de forma implícita.

Nullability of reference types in type doesn't match implicitly implemented member. La nulabilidad de los tipos de referencia del tipo no coincide con el miembro implementado de forma implícita

Nullability of reference types in type doesn't match overridden member. La nulabilidad de los tipos de referencia del tipo no coincide con el miembro reemplazado.

Nullability of reference types in type doesn't match overridden member. La nulabilidad de los tipos de referencia del tipo no coincide con el miembro reemplazado

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}'. El tipo "{3}" no se puede usar como parámetro de tipo "{2}" en el tipo o método genérico "{0}". La nulabilidad del argumento de tipo "{3}" no coincide con el tipo de restricción "{1}".

The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match constraint type. El tipo no se puede usar como parámetro de tipo en el tipo o método genérico. La nulabilidad del argumento de tipo no coincide con el tipo de restricción

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 'notnull' constraint. El tipo "{2}" no se puede usar como parámetro de tipo "{1}" en el método o tipo genérico "{0}". La nulabilidad del argumento de tipo "{2}" no coincide con la restricción "notnull".

The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'notnull' constraint. El tipo no se puede usar como parámetro de tipo en el método o tipo genérico. La nulabilidad del argumento de tipo no coincide con la restricción "notnull"

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. El tipo "{2}" no se puede usar como parámetro de tipo "{1}" en el tipo o método genérico "{0}". La nulabilidad del argumento de tipo "{2}" no coincide con la restricción "class".

The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'class' constraint. El tipo no se puede usar como parámetro de tipo en el tipo o método genérico. La nulabilidad del argumento de tipo no coincide con la restricción "class"

Nullable value type may be null. Un tipo que acepta valores NULL puede ser nulo.

The out parameter '{0}' must be assigned to before control leaves the current method The out parameter '{0}' must be assigned to before control leaves the current method

An out parameter must be assigned to before control leaves the method An out parameter must be assigned to before control leaves the method

Parameter '{0}' must have a non-null value when exiting with '{1}'. El parámetro "{0}" no puede tener un valor NULL al salir con "{1}".

Parameter must have a non-null value when exiting in some condition. El parámetro no puede tener un valor NULL al salir en alguna condición.

Parameter '{0}' must have a non-null value when exiting. Parameter '{0}' must have a non-null value when exiting.

Parameter must have a non-null value when exiting. Parameter must have a non-null value when exiting.

Operator '{0}' cannot be used here due to precedence. Use parentheses to disambiguate. Operator '{0}' cannot be used here due to precedence. Use parentheses to disambiguate.

Operator cannot be used here due to precedence. Operator cannot be used here due to precedence.

'{0}' does not implement the '{1}' pattern. '{2}' is not a public instance or extension method. '{0}' does not implement the '{1}' pattern. '{2}' is not a public instance or extension method.

Type does not implement the collection pattern; member is is not a public instance or extension method. Type does not implement the collection pattern; member is is not a public instance or extension method.

A method marked [DoesNotReturn] should not return. Un método marcado [DoesNotReturn] no debe devolver.

The second operand of an 'is' or 'as' operator may not be static type '{0}' The second operand of an 'is' or 'as' operator may not be static type '{0}'

The second operand of an 'is' or 'as' operator may not be a static type The second operand of an 'is' or 'as' operator may not be a static type

The switch expression does not handle all possible values of its input type (it is not exhaustive). For example, the pattern '{0}' is not covered. The switch expression does not handle all possible values of its input type (it is not exhaustive). For example, the pattern '{0}' is not covered.

The switch expression does not handle some null inputs (it is not exhaustive). For example, the pattern '{0}' is not covered. The switch expression does not handle some null inputs (it is not exhaustive). For example, the pattern '{0}' is not covered.

The switch expression does not handle some null inputs (it is not exhaustive). For example, the pattern '{0}' is not covered. However, a pattern with a 'when' clause might successfully match this value. The switch expression does not handle some null inputs (it is not exhaustive). For example, the pattern '{0}' is not covered. However, a pattern with a 'when' clause might successfully match this value.

The switch expression does not handle some null inputs. The switch expression does not handle some null inputs.

The switch expression does not handle some null inputs. La expresión switch no controla algunas entradas de tipo NULL.

The switch expression does not handle all possible values of its input type (it is not exhaustive). For example, the pattern '{0}' is not covered. However, a pattern with a 'when' clause might successfully match this value. The switch expression does not handle all possible values of its input type (it is not exhaustive). For example, the pattern '{0}' is not covered. However, a pattern with a 'when' clause might successfully match this value.

The switch expression does not handle all possible values of its input type (it is not exhaustive). The switch expression does not handle all possible values of its input type (it is not exhaustive).

The switch expression does not handle all possible values of its input type (it is not exhaustive). La expresión switch no controla todos los valores posibles de su tipo de entrada (no es exhaustiva).

Thrown value may be null. El valor generado puede ser NULL.

Nullability of reference types in type of parameter '{0}' doesn't match implemented member '{1}' (possibly because of nullability attributes). Nullability of reference types in type of parameter '{0}' doesn't match implemented member '{1}' (possibly because of nullability attributes).

Nullability of reference types in type of parameter doesn't match implemented member (possibly because of nullability attributes). Nullability of reference types in type of parameter doesn't match implemented member (possibly because of nullability attributes).

Nullability of reference types in type of parameter '{0}' of '{1}' doesn't match implicitly implemented member '{2}' (possibly because of nullability attributes). Nullability of reference types in type of parameter '{0}' of '{1}' doesn't match implicitly implemented member '{2}' (possibly because of nullability attributes).

Nullability of reference types in type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes). Nullability of reference types in type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes).

Nullability of type of parameter '{0}' doesn't match overridden member (possibly because of nullability attributes). Nullability of type of parameter '{0}' doesn't match overridden member (possibly because of nullability attributes).

Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes). Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes).

Nullability of reference types in return type doesn't match implemented member '{0}' (possibly because of nullability attributes). Nullability of reference types in return type doesn't match implemented member '{0}' (possibly because of nullability attributes).

Nullability of reference types in return type doesn't match implemented member (possibly because of nullability attributes). Nullability of reference types in return type doesn't match implemented member (possibly because of nullability attributes).

Nullability of reference types in return type of '{0}' doesn't match implicitly implemented member '{1}' (possibly because of nullability attributes). Nullability of reference types in return type of '{0}' doesn't match implicitly implemented member '{1}' (possibly because of nullability attributes).

Nullability of reference types in return type doesn't match implicitly implemented member (possibly because of nullability attributes). Nullability of reference types in return type doesn't match implicitly implemented member (possibly because of nullability attributes).

Nullability of return type doesn't match overridden member (possibly because of nullability attributes). Nullability of return type doesn't match overridden member (possibly because of nullability attributes).

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. No se tiene en cuenta el nombre de elemento de tupla "{0}" porque no se ha especificado ningún nombre, o se ha especificado uno diferente, en el otro lado del operador == o != de la 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. No se tiene en cuenta el nombre de elemento de tupla porque no se ha especificado ningún nombre, o se ha especificado uno diferente, en el otro lado del operador == o != de la tupla.

Type parameter '{0}' has the same name as the type parameter from outer method '{1}' El parámetro de tipo "{0}" tiene el mismo nombre que el parámetro de tipo del método externo "{1}"

Type parameter has the same type as the type parameter from outer method. El parámetro de tipo tiene el mismo tipo que el parámetro de tipo del método externo.

Field '{0}' must be fully assigned before control is returned to the caller Field '{0}' must be fully assigned before control is returned to the caller

Auto-implemented property '{0}' must be fully assigned before control is returned to the caller. Auto-implemented property '{0}' must be fully assigned before control is returned to the caller.

An auto-implemented property must be fully assigned before control is returned to the caller. An auto-implemented property must be fully assigned before control is returned to the caller.

Fields of a struct must be fully assigned in a constructor before control is returned to the caller Fields of a struct must be fully assigned in a constructor before control is returned to the caller

Unboxing a possibly null value. Conversión unboxing a un valor posiblemente NULL.

The EnumeratorCancellationAttribute applied to parameter '{0}' will have no effect. The attribute is only effective on a parameter of type CancellationToken in an async-iterator method returning IAsyncEnumerable El valor de EnumeratorCancellationAttribute aplicado al parámetro "{0}" no surtirá efecto. El atributo solo es efectivo en un parámetro de tipo CancellationToken en un método iterador asincrónico que devuelve IAsyncEnumerable

The EnumeratorCancellationAttribute will have no effect. The attribute is only effective on a parameter of type CancellationToken in an async-iterator method returning IAsyncEnumerable El valor de EnumeratorCancellationAttribute no surtirá efecto. El atributo solo es efectivo en un parámetro de tipo CancellationToken en un método iterador asincrónico que devuelve IAsyncEnumerable

Async-iterator '{0}' has one or more parameters of type 'CancellationToken' but none of them is decorated with the 'EnumeratorCancellation' attribute, so the cancellation token parameter from the generated 'IAsyncEnumerable<>.GetAsyncEnumerator' will be unconsumed El iterador de asincronía "{0}" tiene uno o más parámetros de tipo "CancellationToken", pero en ninguno se incluye el atributo "EnumeratorCancellation", por lo que el parámetro de token de cancelación del objeto "IAsyncEnumerable<>.GetAsyncEnumerator" generado no se consumirá

Async-iterator member has one or more parameters of type 'CancellationToken' but none of them is decorated with the 'EnumeratorCancellation' attribute, so the cancellation token parameter from the generated 'IAsyncEnumerable<>.GetAsyncEnumerator' will be unconsumed El miembro del iterador de asincronía tiene uno o más parámetros de tipo "CancellationToken", pero en ninguno se incluye el atributo "EnumeratorCancellation", por lo que el parámetro de token de cancelación del objeto "IAsyncEnumerable<>.GetAsyncEnumerator" generado no se consumirá

Non-nullable {0} '{1}' must contain a non-null value when exiting constructor. Consider declaring the {0} as nullable. La instancia de {0} "{1}" que acepta valores NULL está sin inicializar. Considere la posibilidad de declarar la instancia de {0} como capaz de aceptar valores NULL.

Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable. El campo que acepta valores NULL está sin inicializar. Considere la posibilidad de declararlo como que acepta valores NULL.

Use of unassigned local variable '{0}' Use of unassigned local variable '{0}'

Use of possibly unassigned field '{0}' Use of possibly unassigned field '{0}'

Use of possibly unassigned field Use of possibly unassigned field

Use of unassigned out parameter '{0}' Use of unassigned out parameter '{0}'

Use of unassigned out parameter Use of unassigned out parameter

Use of possibly unassigned auto-implemented property '{0}' Use of possibly unassigned auto-implemented property '{0}'

Use of possibly unassigned auto-implemented property Use of possibly unassigned auto-implemented property

The 'this' object cannot be used before all of its fields have been assigned The 'this' object cannot be used before all of its fields have been assigned

The 'this' object cannot be used in a constructor before all of its fields have been assigned The 'this' object cannot be used in a constructor before all of its fields have been assigned

Use of unassigned local variable Use of unassigned local variable

The character(s) '{0}' cannot be used at this location. El/los carácter/caracteres '{0}' no se puede/n usar en esta ubicación.

Incorrect syntax was used in a comment. Se ha usado sintaxis incorrecta en un comentario.

An invalid character was found inside an entity reference. Se encontró un carácter no válido dentro de una referencia de entidad.

Expected '>' or '/>' to close tag '{0}'. Se esperaba '>' o '/>' para cerrar la etiqueta '{0}'.

An identifier was expected. Se esperaba un identificador.

Invalid unicode character. Carácter Unicode no válido.

Whitespace is not allowed at this location. No se permite un espacio en blanco en esta ubicación.

The character '<' cannot be used in an attribute value. El carácter '<' no se puede usar en un valor de atributo.

Missing equals sign between attribute and attribute value. Falta el signo igual entre el atributo y el valor de atributo.

Reference to undefined entity '{0}'. Referencia a entidad sin definir '{0}'.

A string literal was expected, but no opening quotation mark was found. Se esperaba un literal de cadena, pero no se encontró la comilla de apertura.

Missing closing quotation mark for string literal. Falta la comilla de cierre en el literal de cadena.

Non-ASCII quotations marks may not be used around string literals. No se pueden usar comillas no ASCII en los literales de cadena.

End tag was not expected at this location. No se esperaba una etiqueta final en esta ubicación.

End tag '{0}' does not match the start tag '{1}'. La etiqueta final '{0}' no coincide con la etiqueta de inicio '{1}'.

Expected an end tag for element '{0}'. Se esperaba una etiqueta final para el elemento '{0}'.

Required white space was missing. Falta el espacio en blanco necesario.

Unexpected character at this location. Carácter inesperado en esta ubicación.

The literal string ']]>' is not allowed in element content. La cadena literal ']]>' no se permite en el contenido de elemento.

Duplicate '{0}' attribute Atributo '{0}' duplicado

Metadata file '{0}' could not be found No se encontró el archivo de metadatos '{0}'

Metadata references are not supported. Las referencias de metadatos no son compatibles.

Metadata file '{0}' could not be opened -- {1} No se pudo abrir el archivo de metadatos '{0}': {1}

The type '{0}' is defined in an assembly that is not referenced. You must add a reference to assembly '{1}'. El tipo '{0}' está definido en un ensamblado al que no se hace referencia. Debe agregar una referencia al ensamblado '{1}'.

The type '{0}' is defined in a module that has not been added. You must add the module '{1}'. El tipo '{0}' está definido en un módulo que todavía no se ha agregado. Debe agregar el módulo '{1}'.

Could not write to output file '{0}' -- '{1}' No se puede escribir en el archivo de salida '{0}': '{1}'

Program has more than one entry point defined. Compile with /main to specify the type that contains the entry point. El programa tiene más de un punto de entrada definido. Compile con /main para especificar el tipo que contiene el punto de entrada.

Operator '{0}' cannot be applied to operands of type '{1}' and '{2}' El operador '{0}' no se puede aplicar a operandos del tipo '{1}' y '{2}'

Division by constant zero División entre constante cero

Cannot apply indexing with [] to an expression of type '{0}' No se puede aplicar la indización con [] a una expresión del tipo '{0}'

Wrong number of indices inside []; expected {0} Número incorrecto de índices dentro de []; se esperaba {0}.

Operator '{0}' cannot be applied to operand of type '{1}' El operador '{0}' no se puede aplicar al operando del tipo '{1}'

Keyword 'this' is not valid in a static property, static method, or static field initializer La palabra clave 'this' no es válida en una propiedad, método o inicializador de campo estáticos

Keyword 'this' is not available in the current context La palabra clave 'this' no está disponible en el contexto actual

'{0}' has the wrong signature to be an entry point '{0}' tiene una firma incorrecta para ser un punto de entrada

Method has the wrong signature to be an entry point El método tiene la firma incorrecta para ser un punto de entrada

Cannot implicitly convert type '{0}' to '{1}' No se puede convertir implícitamente el tipo '{0}' en '{1}'

Cannot convert type '{0}' to '{1}' No se puede convertir el tipo '{0}' en '{1}'

Constant value '{0}' cannot be converted to a '{1}' El valor constante '{0}' no se puede convertir en '{1}'

Operator '{0}' is ambiguous on operands of type '{1}' and '{2}' El operador '{0}' es ambiguo en operandos del tipo '{1}' y '{2}'

Operator '{0}' is ambiguous on an operand of type '{1}' El operador '{0}' es ambiguo en un operando del tipo '{1}'

An out parameter cannot have the In attribute Un parámetro Out no puede tener un atributo In

Cannot convert null to '{0}' because it is a non-nullable value type No se puede convertir NULL en '{0}' porque es un tipo de valor que no acepta valores NULL.

Cannot convert type '{0}' to '{1}' via a reference conversion, boxing conversion, unboxing conversion, wrapping conversion, or null type conversion No se puede convertir el tipo '{0}' en '{1}' mediante una conversión de referencia, boxing, unboxing, de ajuste del texto o de tipo NULL

Unexpected error writing debug information -- '{0}' Error inesperado al escribir la información de depuración: '{0}'

Inconsistent accessibility: return type '{1}' is less accessible than method '{0}' Incoherencia de accesibilidad: el tipo de valor devuelto '{1}' es menos accesible que el método '{0}'

Inconsistent accessibility: parameter type '{1}' is less accessible than method '{0}' Incoherencia de accesibilidad: el tipo de parámetro '{1}' es menos accesible que el método '{0}'

Inconsistent accessibility: field type '{1}' is less accessible than field '{0}' Incoherencia de accesibilidad: el tipo de campo '{1}' es menos accesible que el campo '{0}'

Inconsistent accessibility: property type '{1}' is less accessible than property '{0}' Incoherencia de accesibilidad: el tipo de propiedad '{1}' es menos accesible que la propiedad '{0}'

Inconsistent accessibility: indexer return type '{1}' is less accessible than indexer '{0}' Incoherencia de accesibilidad: el tipo de valor devuelto de indizador '{1}' es menos accesible que el indizador '{0}'

Inconsistent accessibility: parameter type '{1}' is less accessible than indexer '{0}' Incoherencia de accesibilidad: el tipo de parámetro '{1}' es menos accesible que el indizador '{0}'

Inconsistent accessibility: return type '{1}' is less accessible than operator '{0}' Incoherencia de accesibilidad: el tipo de valor devuelto '{1}' es menos accesible que el operador '{0}'

Inconsistent accessibility: parameter type '{1}' is less accessible than operator '{0}' Incoherencia de accesibilidad: el tipo de parámetro '{1}' es menos accesible que el operador '{0}'

Inconsistent accessibility: return type '{1}' is less accessible than delegate '{0}' Incoherencia de accesibilidad: el tipo de valor devuelto '{1}' es menos accesible que el delegado '{0}'

Inconsistent accessibility: parameter type '{1}' is less accessible than delegate '{0}' Incoherencia de accesibilidad: el tipo de parámetro '{1}' es menos accesible que el delegado '{0}'

Inconsistent accessibility: base class '{1}' is less accessible than class '{0}' Incoherencia de accesibilidad: la clase base '{1}' es menos accesible que la clase '{0}'

Inconsistent accessibility: base interface '{1}' is less accessible than interface '{0}' Incoherencia de accesibilidad: la interfaz base '{1}' es menos accesible que la interfaz '{0}'

'{0}': event property must have both add and remove accessors '{0}': la propiedad del evento debe tener los descriptores de acceso add y remove

'{0}': event must be of a delegate type '{0}': el evento debe ser de tipo delegado

The event '{0}' is never used El evento '{0}' nunca se usa

Event is never used Nunca se usa el evento

'{0}': instance event in interface cannot have initializer "{0}": el evento de instancia en la interfaz no puede tener un inicializador

The event '{0}' can only appear on the left hand side of += or -= (except when used from within the type '{1}') El evento '{0}' solo puede aparecer a la izquierda de += o -= (excepto cuando se usa desde dentro del tipo '{1}')

An explicit interface implementation of an event must use event accessor syntax Una implementación de interfaz explícita de un evento debe usar la sintaxis de descriptor de acceso de eventos

'{0}': cannot override; '{1}' is not an event '{0}': no se puede invalidar; '{1}' no es un evento

An add or remove accessor must have a body Un descriptor de acceso add o remove debe tener un cuerpo

'{0}': abstract event cannot have initializer '{0}': un evento abstracto no puede tener inicializador

The assembly name '{0}' is reserved and cannot be used as a reference in an interactive session El nombre de ensamblado '{0}' está reservado y no se puede usar como referencia en una sesión interactiva

The enumerator name '{0}' is reserved and cannot be used El nombre de enumerador '{0}' está reservado y no se puede usar

The as operator must be used with a reference type or nullable type ('{0}' is a non-nullable value type) El operador as se debe usar con un tipo de referencia o un tipo que acepte valores NULL ('{0}' es un tipo de valor que no acepta valores NULL)

The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity El sufijo 'l' se confunde fácilmente con el dígito '1': utilice 'L' para mayor claridad

The 'l' suffix is easily confused with the digit '1' El sufijo "l" se confunde fácilmente con el número "1"

The event '{0}' can only appear on the left hand side of += or -= El evento '{0}' solo puede aparecer a la izquierda de += o -=.

Constraints are not allowed on non-generic declarations No se permiten restricciones en declaraciones no genéricas

Type parameter declaration must be an identifier not a type La declaración de parámetros de tipo debe ser un identificador, no un tipo

Type '{1}' already reserves a member called '{0}' with the same parameter types El tipo '{1}' reserva ya un miembro denominado '{0}' con los mismos tipos de parámetro

The parameter name '{0}' is a duplicate El nombre de parámetro '{0}' está duplicado

The namespace '{1}' already contains a definition for '{0}' El espacio de nombres '{1}' ya contiene una definición para '{0}'

The type '{0}' already contains a definition for '{1}' El tipo '{0}' ya contiene una definición para '{1}'

The name '{0}' does not exist in the current context El nombre '{0}' no existe en el contexto actual

The name '{0}' does not exist in the current context (are you missing a reference to assembly '{1}'?) El nombre '{0}' no existe en el contexto actual (¿falta alguna referencia al ensamblado '{1}'?)

'{0}' is an ambiguous reference between '{1}' and '{2}' '{0}' es una referencia ambigua entre '{1}' y '{2}'

The using directive for '{0}' appeared previously in this namespace La directiva using para '{0}' aparece previamente en este espacio de nombres

Using directive appeared previously in this namespace La directiva using apareció anteriormente en este espacio de nombre

The modifier '{0}' is not valid for this item El modificador '{0}' no es válido para este elemento

More than one protection modifier Hay más de un modificador de protección

'{0}' hides inherited member '{1}'. Use the new keyword if hiding was intended. '{0}' oculta el miembro heredado '{1}'. Use la palabra clave new si su intención era ocultarlo.

Member hides inherited member; missing new keyword El miembro oculta el miembro heredado. Falta una contraseña nueva

A variable was declared with the same name as a variable in a base type. 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. Se declaró una variable con el mismo nombre como una variable en la clase base. Sin embargo, la nueva palabra clave no está en uso. Esta advertencia le informa de que debería usar new. La variable se declaró como si new se hubiera usado en la declaración.

The member '{0}' does not hide an accessible member. The new keyword is not required. El miembro '{0}' no oculta un miembro accesible. La palabra clave new no es necesaria.

Member does not hide an inherited member; new keyword is not required El miembro no oculta un miembro heredado. No se necesita una nueva palabra clave

The evaluation of the constant value for '{0}' involves a circular definition La evaluación del valor constante de '{0}' comprende una definición circular

Type '{1}' already defines a member called '{0}' with the same parameter types El tipo '{1}' ya define un miembro denominado '{0}' con los mismos tipos de parámetro

A static member '{0}' cannot be marked as override, virtual, or abstract Un miembro estático '{0}' no se puede marcar como invalidación, virtual o abstracto

A member '{0}' marked as override cannot be marked as new or virtual Un miembro '{0}' marcado como override no se puede marcar como new o 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 el miembro heredado '{1}'. Para hacer que el miembro actual invalide esa implementación, agregue la palabra clave override. Si no, agregue la palabra clave new.

Member hides inherited member; missing override keyword El miembro oculta el miembro heredado. Falta una contraseña de invalidación

'{0}': no suitable method found to override '{0}': no se encontró ningún miembro adecuado para invalidar

A namespace cannot directly contain members such as fields or methods Un espacio de nombres no puede contener directamente miembros como campos o métodos.

'{0}' does not contain a definition for '{1}' '{0}' no contiene una definición para '{1}'

'{0}' is a {1} but is used like a {2} '{0}' es {1} pero se usa como {2}

'{0}' is a {1}, which is not valid in the given context '{0}' es {1}, que no es válida en el contexto indicado

An object reference is required for the non-static field, method, or property '{0}' Se requiere una referencia de objeto para el campo, método o propiedad '{0}' no estáticos

The call is ambiguous between the following methods or properties: '{0}' and '{1}' La llamada es ambigua entre los métodos o las propiedades siguientes: '{0}' y '{1}'

'{0}' is inaccessible due to its protection level '{0}' no es accesible debido a su nivel de protección

No overload for '{0}' matches delegate '{1}' Ninguna sobrecarga correspondiente a '{0}' coincide con el delegado '{1}'

An object of a type convertible to '{0}' is required Se requiere un objeto cuyo tipo se pueda convertir en '{0}'

Since '{0}' returns void, a return keyword must not be followed by an object expression Como '{0}' devuelve void, una palabra clave return no debe ir seguida de una expresión de objeto

A local variable or function named '{0}' is already defined in this scope Una variable o función local denominada '{0}' ya se ha definido en este ámbito

The left-hand side of an assignment must be a variable, property or indexer La parte izquierda de una asignación debe ser una variable, una propiedad o un indizador

'{0}': a static constructor must be parameterless '{0}': un constructor estático no debe tener parámetros

The expression being assigned to '{0}' must be constant La expresión que se asigne a '{0}' debe ser constante

'{0}' is of type '{1}'. A const field of a reference type other than string can only be initialized with null. '{0}' es de tipo '{1}'. Un campo const de un tipo de referencia que no sea de cadena solo se puede inicializar con 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 Una variable local o un parámetro denominados '{0}' no se pueden declarar en este ámbito porque ese nombre se está usando en un ámbito local envolvente para definir una variable local o un 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 Las directivas de uso de espacio de nombres solo se pueden aplicar a espacios de nombres. '{0}' es un tipo, no un espacio de nombres. Puede que deba utilizar una directiva de uso de versión estática en su lugar

A 'using static' directive can only be applied to types; '{0}' is a namespace not a type. Consider a 'using namespace' directive instead Las directivas de uso de versión estática solo se pueden aplicar a tipos. '{0}' es un espacio de nombres, no un tipo. Puede que deba utilizar una directiva de uso de espacio de nombres en su lugar

A 'using static' directive cannot be used to declare an alias No se puede usar una directiva de uso de versión estática para declarar un alias

No enclosing loop out of which to break or continue No hay ningún bucle envolvente desde el que interrumpir o continuar

The label '{0}' is a duplicate La etiqueta '{0}' está duplicada

The type '{0}' has no constructors defined El tipo '{0}' no tiene constructores definidos

Cannot create an instance of the abstract type or interface '{0}' No se puede crear una instancia de la clase o interfaz abstracta '{0}'

A const field requires a value to be provided El campo const requiere que se proporcione un valor

Circular base type dependency involving '{0}' and '{1}' Dependencia de clase base circular que requiere '{0}' y '{1}'

The delegate '{0}' does not have a valid constructor El delegado '{0}' no tiene un constructor válido

Method name expected Se espera un nombre de método

A constant value is expected Se espera un valor constante

A switch expression or case label must be a bool, char, string, integral, enum, or corresponding nullable type in C# 6 and earlier. Una expresión switch o etiqueta de caso debe ser del tipo bool, char, string, integral, enum o del correspondiente tipo que acepte valores NULL en C# 6 y versiones anteriores.

A value of an integral type expected Se espera un valor de tipo entero

The switch statement contains multiple cases with the label value '{0}' La instrucción switch contiene varios casos con el valor de etiqueta '{0}'

A goto case is only valid inside a switch statement Una instrucción goto case solo es válida dentro de una instrucción switch

The property or indexer '{0}' cannot be used in this context because it lacks the get accessor La propiedad o el indizador '{0}' no se puede usar en este contexto porque carece del descriptor de acceso get

The type caught or thrown must be derived from System.Exception El tipo detectado o producido debe derivarse de System.Exception

A throw statement with no arguments is not allowed outside of a catch clause No se permite una instrucción throw sin argumentos fuera de una cláusula catch

Control cannot leave the body of a finally clause El control no puede salir del texto de una cláusula finally

The label '{0}' shadows another label by the same name in a contained scope La etiqueta '{0}' oculta otra etiqueta del mismo nombre en un ámbito contenido

No such label '{0}' within the scope of the goto statement No existe la etiqueta '{0}' en el ámbito de la instrucción goto

A previous catch clause already catches all exceptions of this or of a super type ('{0}') Una cláusula catch previa ya detecta todas las excepciones de este tipo o de tipo superior ('{0}')

Filter expression is a constant 'true', consider removing the filter La expresión de filtro es una constante "true", puede quitar el filtro

Filter expression is a constant 'true' La expresión de filtro es una constante "true"

'{0}': not all code paths return a value '{0}': no todas las rutas de acceso de código devuelven un valor

Unreachable code detected Se detectó código inaccesible

Control cannot fall through from one case label ('{0}') to another El control no puede pasar explícitamente de una etiqueta case ('{0}') a otra

This label has not been referenced No existe ninguna referencia a esta etiqueta

Use of unassigned local variable '{0}' Uso de la variable local no asignada '{0}'

The variable '{0}' is declared but never used La variable '{0}' se ha declarado pero nunca se usa

Variable is declared but never used La variable está declarada pero nunca se usa

The field '{0}' is never used El campo '{0}' nunca se usa

Field is never used Nunca se usa el campo

Use of possibly unassigned field '{0}' Uso del campo '{0}' posiblemente sin asignar

Use of possibly unassigned auto-implemented property '{0}' Uso de una propiedad implementada automáticamente posiblemente sin asignar '{0}'

Field '{0}' must be fully assigned before control is returned to the caller El campo '{0}' debe estar totalmente asignado antes de que se devuelva el control al llamador

Type of conditional expression cannot be determined because '{0}' and '{1}' implicitly convert to one another No se puede determinar el tipo de expresión condicional porque '{0}' y '{1}' se convierten implícitamente uno en el otro

Type of conditional expression cannot be determined because there is no implicit conversion between '{0}' and '{1}' No se puede determinar el tipo de la expresión condicional porque no hay una conversión implícita entre '{0}' y '{1}'

A base class is required for a 'base' reference Clase base requerida para una referencia 'base'

Use of keyword 'base' is not valid in this context El uso de la palabra clave 'base' no es válido en este contexto

Member '{0}' cannot be accessed with an instance reference; qualify it with a type name instead No se puede obtener acceso al miembro '{0}' con una referencia de instancia; califíquelo con un nombre de tipo en su lugar

The out parameter '{0}' must be assigned to before control leaves the current method Es necesario asignar el parámetro '{0}' out antes de que el control abandone el método actual

Invalid rank specifier: expected ',' or ']' Especificador de rango no válido: se esperaba ',' o ']'

'{0}' cannot be extern and declare a body '{0}' no puede ser externo y declarar un cuerpo

'{0}' cannot be extern and have a constructor initializer '{0}' no puede ser externo y tener un inicializador de constructor

'{0}' cannot be both extern and abstract '{0}' no puede ser externo y abstracto a la vez

Attribute constructor parameter '{0}' has type '{1}', which is not a valid attribute parameter type El parámetro del constructor de atributo '{0}' tiene el tipo '{1}', que no es un 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 Un argumento de atributo debe ser una expresión constante, una expresión typeof o una expresión de creación de matrices de un tipo de parámetro de atributo

Attribute constructor parameter '{0}' is optional, but no default parameter value was specified. El parámetro del constructor de atributo '{0}' es opcional, pero no se especificó ningún valor de parámetro predeterminado.

The given expression is always of the provided ('{0}') type La expresión dada siempre es del tipo proporcionado ('{0}')

'is' expression's given expression is always of the provided type 'La expresión dada de la expresión "is" siempre tiene el tipo provisto

The given expression is never of the provided ('{0}') type La expresión dada nunca es del tipo proporcionado ('{0}')

'is' expression's given expression is never of the provided type 'La expresión dada de la expresión "is" nunca tiene el tipo provisto

'{0}' is not a reference type as required by the lock statement '{0}' no es el tipo de referencia que requiere la instrucción lock

Use of null is not valid in this context No se permite utilizar NULL en este contexto

Use of default literal is not valid in this context El uso del literal predeterminado no es válido en este contexto.

The 'this' object cannot be used before all of its fields have been assigned El objeto 'this' no se puede utilizar antes de que se hayan asignado todos sus campos

The __arglist construct is valid only within a variable argument method La construcción __arglist solo es válida dentro de un método de argumento de variable

The * or -> operator must be applied to a pointer El operador * o -> se debe aplicar a un puntero

A pointer must be indexed by only one value Un puntero solo puede estar indizado por un 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 Si se utiliza '{0}' como valor out o ref, o se acepta su dirección, se puede producir una excepción en tiempo de ejecución porque es un campo de una clase de serialización por referencia.

Using a field of a marshal-by-reference class as a ref or out value or taking its address may cause a runtime exception Si se utiliza un campo de una clase de serialización por referencia como valor ref o out, o se acepta su dirección, se puede producir una excepción en tiempo de ejecución.

A static readonly field cannot be assigned to (except in a static constructor or a variable initializer) No se puede asignar un campo de solo lectura estático (excepto en un constructor estático o inicializador de variable)

A static readonly field cannot be used as a ref or out value (except in a static constructor) No se puede usar un campo estático de solo lectura como valor out o ref (excepto en un constructor estático).

Property or indexer '{0}' cannot be assigned to -- it is read only No se puede asignar a la propiedad o el indizador '{0}' porque es de solo lectura

Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement Solo las expresiones de asignación, llamada, incremento, decremento, espera y objeto nuevo se pueden usar como instrucción

foreach requires that the return type '{0}' of '{1}' must have a suitable public 'MoveNext' method and public 'Current' property "foreach" requiere que el tipo de valor devuelto "{0}" de "{1}" tenga un método "MoveNext" público y una propiedad "Current" pública adecuados.

Only 65534 locals, including those generated by the compiler, are allowed Solo se permiten 65534 variables locales incluyendo las generadas por el compilador

Cannot call an abstract base member: '{0}' No se puede llamar a un miembro base abstracto: '{0}'

A property or indexer may not be passed as an out or ref parameter Una propiedad o un indizador no se puede pasar como parámetro out o ref

Cannot take the address of, get the size of, or declare a pointer to a managed type ('{0}') No se puede adquirir la dirección, obtener el tamaño ni declarar un puntero a un tipo administrado ('{0}')

The type of a local declared in a fixed statement must be a pointer type El tipo de una variable local declarado en una instrucción "fixed" debe ser un tipo de puntero

You must provide an initializer in a fixed or using statement declaration Debe proporcionar un inicializador en una declaración de instrucción fixed o using

Cannot take the address of the given expression No se puede adquirir la dirección de la expresión dada

You can only take the address of an unfixed expression inside of a fixed statement initializer Solo se puede adquirir la dirección de una expresión de tipo unfixed de un inicializador de instrucción "fixed"

You cannot use the fixed statement to take the address of an already fixed expression No se puede usar la instrucción "fixed" para adquirir la dirección de una expresión de tipo fixed

Pointers and fixed size buffers may only be used in an unsafe context Los punteros y los búferes de tamaño fijo solo se pueden utilizar en un contexto no seguro

The return type of operator True or False must be bool El tipo de valor devuelto del operador True o False debe ser bool

The operator '{0}' requires a matching operator '{1}' to also be defined El operador '{0}' requiere que también se defina un operador coincidente '{1}'

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 que se pueda aplicar un operador de cortocircuito, el operador lógico definido por el usuario ('{0}') debe tener el mismo tipo de valor devuelto y los mismos tipos de parámetros

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}' sea aplicable como operador de cortocircuito, su tipo declarativo '{1}' debe definir un operador true y otro false

The variable '{0}' is assigned but its value is never used La variable '{0}' está asignada pero su valor nunca se usa

Variable is assigned but its value is never used La variable está asignada pero nunca se usa su valor

The operation overflows at compile time in checked mode La operación se desborda en el momento de la compilación en modo checked

Constant value '{0}' cannot be converted to a '{1}' (use 'unchecked' syntax to override) El valor constante '{0}' no se puede convertir en '{1}' (use la sintaxis 'unchecked' para invalidar)

A method with vararg cannot be generic, be in a generic type, or have a params parameter Un método con vararg no puede ser genérico, estar en un tipo genérico ni tener un parámetro params

The params parameter must be a single dimensional array El parámetro params debe ser una matriz unidimensional

An __arglist expression may only appear inside of a call or new expression La expresión __arglist solo puede aparecer dentro de una llamada o una expresión new

Unsafe code may only appear if compiling with /unsafe El código no seguro solo puede aparecer si se compila con /unsafe

Ambiguity between '{0}' and '{1}' Ambigüedad entre '{0}' y '{1}'

Type and identifier are both required in a foreach statement En una instrucción foreach se requieren un tipo y un identificador

A params parameter must be the last parameter in a formal parameter list Un parámetro params debe ser el último parámetro de una lista de parámetros formales

'{0}' does not have a predefined size, therefore sizeof can only be used in an unsafe context "{0}" no tiene un tamaño predefinido; por tanto, sizeof solo se puede usar en un contexto no seguro

The type or namespace name '{0}' does not exist in the namespace '{1}' (are you missing an assembly reference?) El tipo o el nombre del espacio de nombres '{0}' no existe en el espacio de nombres '{1}' (¿falta alguna referencia de ensamblado?)

A field initializer cannot reference the non-static field, method, or property '{0}' Un inicializador de campo no puede hacer referencia al campo, método o propiedad no estáticos '{0}'

'{0}' cannot be sealed because it is not an override '{0}' no puede estar sellado porque no es una invalidación

'{0}': cannot override inherited member '{1}' because it is sealed '{0}': no se puede invalidar el miembro heredado '{1}' porque está sellado

The operation in question is undefined on void pointers La operación en cuestión no está definida en punteros void

The Conditional attribute is not valid on '{0}' because it is an override method El atributo Conditional no es válido en '{0}' porque es un método de reemplazo

Neither 'is' nor 'as' is valid on pointer types Ni 'is' ni 'as' son válidos como tipos de puntero

Destructors and object.Finalize cannot be called directly. Consider calling IDisposable.Dispose if available. Los destructores y object.Finalize no se pueden llamar directamente. Puede llamar a IDisposable.Dispose si está disponible.

The type or namespace name '{0}' could not be found (are you missing a using directive or an assembly reference?) El nombre del tipo o del espacio de nombres '{0}' no se encontró (¿falta una directiva using o una referencia de ensamblado?)

Cannot use a negative size with stackalloc No se puede utilizar un tamaño negativo con stackalloc

Cannot create an array with a negative size No se puede crear una matriz con un tamaño negativo

Do not override object.Finalize. Instead, provide a destructor. No invalide object.Finalize. En su lugar, proporcione un destructor.

Do not directly call your base type Finalize method. It is called automatically from your destructor. No llame directamente al método Finalize de la clase base. Se llama automáticamente desde el destructor.

Indexing an array with a negative index (array indices always start at zero) Indizando una matriz con un índice negativo (los índices de matriz siempre comienzan por cero)

Indexing an array with a negative index Indexando una matriz con un índice negativo

Possible unintended reference comparison; to get a value comparison, cast the left hand side to type '{0}' Posible comparación de referencias no intencionada; para obtener una comparación de valores, convierta el lado de la izquierda en el tipo '{0}'

Possible unintended reference comparison; left hand side needs cast Posible comparación de referencias involuntaria: El lado de la mano izquierda necesita conversión

Possible unintended reference comparison; to get a value comparison, cast the right hand side to type '{0}' Posible comparación de referencias no intencionada; para obtener una comparación de valores, convierta el lado de la derecha en el tipo '{0}'

Possible unintended reference comparison; right hand side needs cast Posible comparación de referencias involuntaria. El lado de la mano derecha necesita conversión

The right hand side of a fixed statement assignment may not be a cast expression El lado derecho de una asignación de instrucción "fixed" no puede ser una expresión de conversión

stackalloc may not be used in a catch or finally block stackalloc no se puede usar en un bloque catch o finally

An __arglist parameter must be the last parameter in a formal parameter list El parámetro __arglist debe ser el último en una lista de parámetros formales

Missing partial modifier on declaration of type '{0}'; another partial declaration of this type exists Falta el modificador parcial en la declaración de tipo '{0}'; existe otra declaración parcial de este tipo

Partial declarations of '{0}' must be all classes, all records, all structs, or all interfaces Las declaraciones parciales de '{0}' deben ser todas clases, todas estructuras o todas interfaces

Partial declarations of '{0}' have conflicting accessibility modifiers Las declaraciones parciales de '{0}' tienen modificadores de accesibilidad que entran en conflicto

Partial declarations of '{0}' must not specify different base classes Las declaraciones parciales de '{0}' no deben especificar clases base diferentes

Partial declarations of '{0}' must have the same type parameter names in the same order Las declaraciones parciales de '{0}' deben tener los mismos nombres de parámetros de tipo en el mismo orden

Partial declarations of '{0}' have inconsistent constraints for type parameter '{1}' Las declaraciones parciales de '{0}' tienen restricciones incoherentes para el parámetro de tipo '{1}'

Cannot implicitly convert type '{0}' to '{1}'. An explicit conversion exists (are you missing a cast?) No se puede convertir implícitamente el tipo '{0}' en '{1}'. Ya existe una conversión explícita (compruebe si le falta una conversión)

The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or 'void' El modificador 'partial' solo puede aparecer inmediatamente antes de 'class', 'struct', 'interface' o 'void'

Imported type '{0}' is invalid. It contains a circular base type dependency. El tipo importado '{0}' no es válido. Contiene una dependencia de clase base circular.

Use of unassigned out parameter '{0}' Uso del parámetro out sin asignar '{0}'

Array size cannot be specified in a variable declaration (try initializing with a 'new' expression) El tamaño de la matriz no se puede especificar en una declaración de variable (intente inicializar con una expresión 'new')

The property or indexer '{0}' cannot be used in this context because the get accessor is inaccessible La propiedad o el indizador '{0}' no se pueden usar en este contexto porque el descriptor de acceso get es inaccesible

The property or indexer '{0}' cannot be used in this context because the set accessor is inaccessible La propiedad o el indizador '{0}' no se pueden usar en este contexto porque el descriptor de acceso set es inaccesible

The accessibility modifier of the '{0}' accessor must be more restrictive than the property or indexer '{1}' El modificador de accesibilidad del descriptor de acceso '{0}' debe ser más restrictivo que la propiedad o el indizador '{1}'

Cannot specify accessibility modifiers for both accessors of the property or indexer '{0}' No se pueden especificar modificadores de accesibilidad para ambos descriptores de acceso de la propiedad o del indizador '{0}'

'{0}': accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor '{0}': los modificadores de accesibilidad de los descriptores de acceso solo se pueden usar si la propiedad o el indizador tienen un descriptor de acceso get y set

'{0}' does not implement interface member '{1}'. '{2}' is not public. '{0}' no implementa el miembro de interfaz '{1}'. '{2}' no es público.

'{0}' does not implement the '{1}' pattern. '{2}' is ambiguous with '{3}'. '{0}' no implementa el patrón '{1}'. '{2}' es ambiguo con '{3}'.

Type does not implement the collection pattern; members are ambiguous El tipo no implementa la trama de colección. Los miembros son ambiguos

'{0}' does not implement the '{1}' pattern. '{2}' has the wrong signature. '{0}' no implementa el patrón '{1}'. '{2}' tiene una firma incorrecta.

Type does not implement the collection pattern; member has the wrong signature El tipo no implementa la trama de colección. El miembro tiene la firma incorrecta

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. “{0}” ha concedido acceso de confianza, pero la clave pública del ensamblado de salida ({1}) no coincide con la especificada por el atributo InternalsVisibleTo en el ensamblado de concesión.

Friend access was granted by '{0}', but the strong name signing state of the output assembly does not match that of the granting assembly. {0}' ha concedido acceso de confianza, pero el nombre seguro que firma el estado del ensamblado de salida no coincide con el del ensamblado de concesión.

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. No hay ningún orden definido entre campos en varias declaraciones de estructura parcial '{0}'. Para especificar un orden, todos los campos de instancia deben estar en la misma declaración.

There is no defined ordering between fields in multiple declarations of partial struct No hay un orden específico entre los campos en declaraciones múltiples de la estructura parcial

The type '{0}' cannot be declared const El tipo '{0}' no se puede declarar como const

Cannot create an instance of the variable type '{0}' because it does not have the new() constraint No se puede crear una instancia del tipo de variable '{0}' porque no tiene la restricción new()

Using the generic {1} '{0}' requires {2} type arguments El uso de {1} de tipo genérico '{0}' requiere argumentos de tipo {2}

The type '{0}' may not be used as a type argument El tipo '{0}' no se puede usar como argumento de tipo

The {1} '{0}' cannot be used with type arguments {1} '{0}' no se puede usar con argumentos de tipo

The non-generic {1} '{0}' cannot be used with type arguments El {1} '{0}' no genérico no se puede usar con 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}' debe ser un tipo no abstracto con un constructor público sin parámetros para poder usarlo como parámetro '{1}' en el tipo o 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}'. El tipo '{3}' no se puede usar como parámetro de tipo '{2}' en el tipo o método genérico '{0}'. No hay ninguna conversión de referencia implícita de '{3}' a '{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}'. El tipo '{3}' no se puede usar como parámetro de tipo '{2}' en el tipo o método genérico '{0}'. El tipo que acepta valores NULL '{3}' no cumple la restricción 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. El tipo '{3}' no se puede usar como parámetro de tipo '{2}' en el tipo o método genérico '{0}'. El tipo que acepta valores NULL '{3}' no cumple la restricción de '{1}'. Los tipos que aceptan valores NULL no pueden cumplir restricciones de interfaz.

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}'. El tipo '{3}' no se puede usar como parámetro de tipo '{2}' en el tipo o método genérico '{0}'. No hay conversión boxing ni conversión de parámetro de tipo de '{3}' a '{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}'. El tipo '{3}' no se puede usar como parámetro de tipo '{2}' en el tipo o método genérico '{0}'. No hay conversión boxing de '{3}' a '{1}'.

The parameter name '{0}' conflicts with an automatically-generated parameter name El nombre de parámetro '{0}' entra en conflicto con un nombre de parámetro generado automáticamente

The type or namespace name '{0}' could not be found in the global namespace (are you missing an assembly reference?) El nombre del tipo o del espacio de nombres '{0}' no se encontró en el espacio de nombres global (¿falta alguna referencia de ensamblado?)

The new() constraint must be the last constraint specified La restricción new() debe ser la última restricción especificada

'{0}': an entry point cannot be generic or in a generic type '{0}': un punto de entrada no puede ser genérico ni estar en un tipo genérico

An entry point cannot be generic or in a generic type Un punto de entrada no puede ser genérico ni estar en un tipo genérico

Cannot convert null to type parameter '{0}' because it could be a non-nullable value type. Consider using 'default({0})' instead. No se puede convertir NULL en el parámetro de tipo '{0}' porque podría ser un tipo de valor que no acepta valores NULL. Use 'default({0})' en su lugar.

Cannot apply attribute class '{0}' because it is generic No se puede aplicar la clase de atributo '{0}' porque es genérica

Duplicate constraint '{0}' for type parameter '{1}' Restricción '{0}' duplicada para el tipo de parámetro '{1}'

The class type constraint '{0}' must come before any other constraints La restricción de tipo de clase '{0}' debe preceder a cualquier otra restricción

'{1} {0}' has the wrong return type '{1} {0}' tiene un tipo de valor devuelto equivocado

Ref mismatch between '{0}' and delegate '{1}' Referencia no coincidente entre "{0}" y el 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. Ya se ha especificado una cláusula de restricciones para el parámetro de tipo '{0}'. Todas las restricciones correspondientes a un parámetro de tipo se deben especificar en una sola cláusula where.

The type arguments for method '{0}' cannot be inferred from the usage. Try specifying the type arguments explicitly. Los argumentos de tipo para el método '{0}' no se pueden inferir a partir del uso. Pruebe a especificar los argumentos de tipo explícitamente.

'{0}': a parameter, local variable, or local function cannot have the same name as a method type parameter '{0}': un parámetro o una variable o función local no pueden tener el mismo nombre que un 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 El parámetro de tipo '{0}' no se puede utilizar con el operador 'as' porque no tiene ninguna restricción de tipo de clase ni una restricción 'class'

The field '{0}' is assigned but its value is never used El campo '{0}' está asignado pero su valor nunca se usa

Field is assigned but its value is never used El campo está asignado pero nunca se usa su valor

The '{0}' attribute is valid only on an indexer that is not an explicit interface member declaration El atributo '{0}' solo es válido en un indizador que no sea una declaración de miembro de interfaz explícita

'{0}': an attribute argument cannot use type parameters '{0}': un argumento de atributo no puede usar parámetros de tipo

'{0}': cannot provide arguments when creating an instance of a variable type '{0}': no se pueden proporcionar argumentos al crear una instancia de un tipo variable

'{0}': an abstract type cannot be sealed or static '{0}': una clase abstracta no puede estar sellada ni ser estática

Ambiguous reference in cref attribute: '{0}'. Assuming '{1}', but could have also matched other overloads including '{2}'. Referencia ambigua en el atributo cref: '{0}'. Se supone '{1}', pero también podría haber coincidido con otras sobrecargas que incluyen '{2}'.

Ambiguous reference in cref attribute Referencia ambigua en el atributo cref

'{0}': a reference to a volatile field will not be treated as volatile '{0}': una referencia a un campo volátil no se tratará como tal

A reference to a volatile field will not be treated as volatile Una referencia a un campo volátil no se tratará 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. Normalmente, no debe usarse un campo volátil como valor ref o out, porque no se tratará como volátil. Pero hay excepciones, como cuando se llama a una API entrelazada.

Since '{1}' has the ComImport attribute, '{0}' must be extern or abstract Como '{1}' tiene el atributo ComImport, '{0}' debe ser externo o abstracto

'{0}': a class with the ComImport attribute cannot specify a base class '{0}': una clase con el atributo ComImport no puede especificar ninguna clase base

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. Las restricciones para el parámetro de tipo '{0} del método '{1} deben coincidir con las restricciones del parámetro de tipo '{2} del método de interfaz '{3}. Si lo prefiere, puede usar una implementación de interfaz 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). Los nombres de elementos de tupla en la firma del método '{0}' deben coincidir con los del método de interfaz '{1}' (que se incluye en el tipo de valor devuelto).

The type name '{0}' does not exist in the type '{1}' El nombre de tipo '{0}' no existe en el tipo '{1}'

Cannot convert method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method? No se puede convertir el grupo de métodos '{0}' en el tipo no delegado '{1}'. ¿Intentó invocar el método?

The extern alias '{0}' was not specified in a /reference option El alias externo '{0}' no se especificó en una opción /reference

Cannot use alias '{0}' with '::' since the alias references a type. Use '.' instead. No se puede usar el alias '{0}' con '::' porque el alias hace referencia a un tipo. Use '.'.

Alias '{0}' not found Alias '{0}' no encontrado

The type '{1}' exists in both '{0}' and '{2}' El tipo '{1}' existe en '{0}' y en '{2}'

The namespace '{1}' in '{0}' conflicts with the type '{3}' in '{2}' El espacio de nombres '{1}' de '{0}' está en conflicto con el tipo '{3}' de '{2}'

The namespace '{1}' in '{0}' conflicts with the imported type '{3}' in '{2}'. Using the namespace defined in '{0}'. El espacio de nombres '{1}' de '{0}' está en conflicto con el tipo importado '{3}' de '{2}'. Se usará el espacio de nombres definido en '{0}'.

Namespace conflicts with imported type El espacio de nombres entra en conflicto con un tipo importado

The type '{1}' in '{0}' conflicts with the imported type '{3}' in '{2}'. Using the type defined in '{0}'. El tipo '{1}' de '{0}' está en conflicto con el tipo importado '{3}' de '{2}'. Se usará el tipo definido en '{0}'.

Type conflicts with imported type El tipo entra en conflicto con un tipo importado

The type '{1}' in '{0}' conflicts with the imported namespace '{3}' in '{2}'. Using the type defined in '{0}'. El tipo '{1}' de '{0}' está en conflicto con el espacio de nombres importado '{3}' de '{2}'. Se usará el tipo definido en '{0}'.

Type conflicts with imported namespace El tipo entra en conflicto con un espacio de nombres importado

The type '{1}' in '{0}' conflicts with the namespace '{3}' in '{2}' El tipo '{1}' de '{0}' está en conflicto con el espacio de nombres '{3}' de '{2}'

An extern alias declaration must precede all other elements defined in the namespace La declaración de un alias externo debe preceder a los demás elementos definidos en el espacio de nombres

Defining an alias named 'global' is ill-advised since 'global::' always references the global namespace and not an alias No es aconsejable definir ningún alias denominado 'global' porque 'global::' siempre hace referencia al espacio de nombres global y no a un alias

Defining an alias named 'global' is ill-advised No se recomienda definir un alias con el nombre 'global'

'{0}': a type cannot be both static and sealed '{0}': una clase no puede ser estática y sellada

'{0}': abstract properties cannot have private accessors '{0}': las propiedades abstractas no pueden tener descriptores de acceso privados

Syntax error; value expected Error de sintaxis; se esperaba un valor

Cannot modify the result of an unboxing conversion No se puede modificar el resultado de una conversión unboxing

Foreach cannot operate on a '{0}'. Did you intend to invoke the '{0}'? Foreach no puede funcionar en un '{0}'. ¿Intentó invocar el '{0}'?

The return type for ++ or -- operator must match the parameter type or be derived from the parameter type El tipo de valor devuelto para los operadores ++ o -- debe coincidir con el tipo de parámetro o derivarse de este

'{0}': cannot specify both a constraint class and the 'class' or 'struct' constraint '{0}': no se puede especificar a la vez una clase de restricción y la restricción 'class' o 'struct'

The 'new()' constraint cannot be used with the 'struct' constraint La restricción 'new()' no se puede utilizar con la restricción 'struct'

The type '{2}' must be a reference type in order to use it as parameter '{1}' in the generic type or method '{0}' El tipo '{2}' debe ser un tipo de referencia para poder usarlo como parámetro '{1}' en el tipo o 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}' El tipo '{2}' debe ser un tipo de valor que no acepte valores NULL para poder usarlo como parámetro '{1}' en el tipo o método genérico '{0}'

Circular constraint dependency involving '{0}' and '{1}' Dependencia de restricción circular que implica '{0}' y '{1}'

Type parameter '{0}' inherits conflicting constraints '{1}' and '{2}' El parámetro de tipo '{0}' hereda las restricciones conflictivas '{1}' y '{2}'

Type parameter '{1}' has the 'struct' constraint so '{1}' cannot be used as a constraint for '{0}' El parámetro de tipo '{1}' tiene la restricción 'struct'; por tanto, '{1}' no se puede usar como restricción para '{0}'

Ambiguous user defined conversions '{0}' and '{1}' when converting from '{2}' to '{3}' Conversiones ambiguas definidas por el usuario '{0}' y '{1}' al convertir de '{2}' a '{3}'

The result of the expression is always 'null' of type '{0}' El resultado de la expresión siempre es 'NULL' de tipo '{0}'

The result of the expression is always 'null' El resultado de la expresión siempre es 'null'

Cannot return 'this' by reference. No se puede devolver "this" por referencia.

Cannot use attribute constructor '{0}' because it has 'in' parameters. No se puede utilizar el constructor del atributo "{0}" porque tiene parámetros "in".

Constraints for override and explicit interface implementation methods are inherited from the base method, so they cannot be specified directly, except for either a 'class', or a 'struct' constraint. Las restricciones para métodos de invalidación y de implementación de interfaz explícita se heredan del método base; por tanto, no se pueden especificar directamente, excepto para una restricción de tipo "class" o "struct".

The inherited members '{0}' and '{1}' have the same signature in type '{2}', so they cannot be overridden Los miembros heredados '{0}' y '{1}' tienen la misma firma en el tipo '{2}', por lo que no se pueden reemplazar

Evaluation of the decimal constant expression failed No se pudo realizar la evaluación de la expresión de la constante decimal y se produjo un error

Comparing with null of type '{0}' always produces 'false' La comparación con NULL de tipo '{0}' siempre genera 'false'

Comparing with null of struct type always produces 'false' Comparar con tipos de estructura o nulos siempre produce 'false'

Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor? La introducción de un método 'Finalize' puede afectar a la invocación del destructor. ¿Quería declarar un destructor?

Introducing a 'Finalize' method can interfere with destructor invocation Introducir un método 'Finalize' afectar a la invocación del destructor

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. Esta advertencia se produce cuando crea una clase con un método cuya firma es public virtual void Finalize. Si se utiliza una clase de este tipo como clase base y si la clase derivada define un destructor, este reemplazará al método Finalize de la clase base, no a Finalize.

'{0}' should not have a params parameter since '{1}' does not '{0}' no debe tener un parámetro params porque '{1}' tampoco lo tiene

The 'goto case' value is not implicitly convertible to type '{0}' El valor 'goto case' no se puede convertir implícitamente en el tipo '{0}'

The 'goto case' value is not implicitly convertible to the switch type El valor "goto case" no es implícitamente convertible al tipo switch

Method '{0}' cannot implement interface accessor '{1}' for type '{2}'. Use an explicit interface implementation. El método '{0}' no puede implementar el descriptor de acceso de la interfaz '{1}' para el tipo '{2}'. Use una implementación de interfaz explícita.

The result of the expression is always '{0}' since a value of type '{1}' is never equal to 'null' of type '{2}' El resultado de la expresión siempre es '{0}' porque un valor del tipo '{1}' nunca es igual a 'NULL' de tipo '{2}'

The result of the expression is always the same since a value of this type is never equal to 'null' El resultado de la expresión siempre es el mismo ya que un valor de este tipo siempre es igual a "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. La implementación de interfaz explícita '{0}' coincide con más de un miembro de interfaz. El miembro de interfaz que se elige depende de la implementación. Si quiere, puede usar una implementación no explícita.

Explicit interface implementation matches more than one interface member La implementación de la interfaz explícita coincide con más de un miembro de la interfaz

'{0}' cannot declare a body because it is marked abstract '{0}' no puede declarar un cuerpo porque está marcado como abstracto

'{0}' must declare a body because it is not marked abstract, extern, or partial '{0}' debe declarar un cuerpo porque no se marcó como abstracto, externo o parcial

'{0}' cannot be both abstract and sealed '{0}' no puede ser abstracto y estar sellado a la vez

The abstract {0} '{1}' cannot be marked virtual El objeto {0} abstracto "{1}" no se puede marcar como virtual.

The constant '{0}' cannot be marked static La constante '{0}' no se puede marcar como estática

'{0}': cannot override because '{1}' is not a function '{0}': no se puede invalidar porque '{1}' no es una función

'{0}': cannot override inherited member '{1}' because it is not marked virtual, abstract, or override '{0}': no se puede invalidar el miembro heredado '{1}' porque no está marcado como virtual, abstract ni override

'{0}': cannot change access modifiers when overriding '{1}' inherited member '{2}' '{0}': no se pueden cambiar los modificadores de acceso al invalidar el miembro heredado '{2}' de '{1}'

'{0}': cannot change tuple element names when overriding inherited member '{1}' '{0}': no se pueden cambiar los nombres de elementos de tupla al reemplazar el miembro heredado '{1}'

'{0}': return type must be '{2}' to match overridden member '{1}' '{0}': el tipo de valor devuelto debe ser '{2}' para que coincida con el miembro invalidado '{1}'

'{0}': cannot derive from sealed type '{1}' '{0}': no puede derivar del tipo sellado '{1}'

'{0}' is abstract but it is contained in non-abstract type '{1}' '{0}' es abstracto pero está contenido en la clase no abstracta '{1}'

'{0}': static constructor cannot have an explicit 'this' or 'base' constructor call '{0}': el constructor estático no puede tener ninguna llamada de constructor 'this' o 'base' explícita

'{0}': access modifiers are not allowed on static constructors '{0}': no se permiten modificadores de acceso en constructores estáticos

Constructor '{0}' cannot call itself El constructor '{0}' no se puede llamar a sí mismo

Constructor '{0}' cannot call itself through another constructor El constructor '{0}' no puede llamarse a sí mismo a través de otro constructor

'{0}' has no base class and cannot call a base constructor '{0}' no tiene clase base y no puede llamar a un constructor base

Predefined type '{0}' is not defined or imported El tipo predefinido '{0}' no está definido ni importado

Predefined type '{0}' is declared in multiple referenced assemblies: '{1}' and '{2}' El tipo "{0}" predefinido se declara en varios ensamblados a los que se hace referencia: "{1}" y "{2}"

'{0}': structs cannot call base class constructors '{0}': las estructuras no pueden llamar a constructores de clase base

Struct member '{0}' of type '{1}' causes a cycle in the struct layout El miembro de estructura '{0}' de tipo '{1}' crea un ciclo en el diseño de la estructura

Interfaces cannot contain instance fields Las interfaces no pueden incluir campos de instancia

Interfaces cannot contain instance constructors Las interfaces no pueden incluir constructores de instancia

Type '{0}' in interface list is not an interface El tipo '{0}' de la lista de interfaces no es una interfaz

'{0}' is already listed in interface list '{0}' ya aparece en la lista de interfaces

'{0}' is already listed in the interface list on type '{2}' with different tuple element names, as '{1}'. '{0}' ya se muestra en la lista de interfaces en el tipo '{2}' con nombres de elementos de tupla diferentes, como '{1}'.

Inherited interface '{1}' causes a cycle in the interface hierarchy of '{0}' La interfaz heredada '{1}' crea un ciclo en la jerarquía de interfaz de '{0}'

'{0}' hides inherited abstract member '{1}' '{0}' oculta el miembro abstracto heredado '{1}'

'{0}' does not implement inherited abstract member '{1}' '{0}' no implementa el miembro abstracto heredado '{1}'

'{0}' does not implement interface member '{1}' '{0}' no implementa el miembro de interfaz '{1}'

The class System.Object cannot have a base class or implement an interface La clase System.Object no puede tener una clase base o implementar una interfaz

'{0}' in explicit interface declaration is not an interface '{0}' en la declaración explícita de la interfaz no es una interfaz

'{0}' in explicit interface declaration is not found among members of the interface that can be implemented No se encuentra "{0}" en la declaración de interfaz explícita entre los miembros de la interfaz que se pueden implementar

'{0}': containing type does not implement interface '{1}' '{0}': el tipo contenedor no implementa la interfaz '{1}'

'{0}': explicit interface declaration can only be declared in a class, record, struct or interface "{0}": la declaración explícita de la interfaz solo se puede declarar en una clase, estructura o interfaz

'{0}': member names cannot be the same as their enclosing type '{0}': los nombres de los miembros no pueden coincidir con sus tipos envolventes

'{0}': the enumerator value is too large to fit in its type '{0}': el valor del enumerador es demasiado grande para ajustarse a su tipo

'{0}': cannot override because '{1}' is not a property '{0}': no se puede invalidar porque '{1}' no es una propiedad

'{0}': cannot override because '{1}' does not have an overridable get accessor '{0}': no se puede invalidar porque '{1}' no tiene un descriptor de acceso get invalidable

'{0}': cannot override because '{1}' does not have an overridable set accessor '{0}': no se puede invalidar porque '{1}' no tiene un descriptor de acceso set invalidable

'{0}': property or indexer cannot have void type '{0}': la propiedad o el indizador no pueden tener el tipo void

'{0}': property or indexer must have at least one accessor '{0}': la propiedad o el indizador deben tener, al menos, un descriptor de acceso

'{0}' is a new virtual member in sealed type '{1}' '{0}' es un nuevo miembro virtual en una clase sellada '{1}'

'{0}' adds an accessor not found in interface member '{1}' '{0}' agrega un descriptor de acceso que no se encuentra en el miembro de interfaz '{1}'

Explicit interface implementation '{0}' is missing accessor '{1}' A la implementación de interfaz explícita '{0}' le falta el descriptor de acceso '{1}'

'{0}': user-defined conversions to or from an interface are not allowed '{0}': no se permiten conversiones definidas por el usuario ni a una interfaz ni desde ella

'{0}': user-defined conversions to or from a base type are not allowed '{0}': no se permiten conversiones definidas por el usuario ni a una clase base ni desde ella

'{0}': user-defined conversions to or from a derived type are not allowed '{0}': no se permiten conversiones definidas por el usuario ni a una clase derivada ni desde ella

User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type Un operador definido por el usuario no puede adquirir un objeto de tipo envolvente ni convertirlo en un objeto de tipo envolvente

User-defined conversion must convert to or from the enclosing type La conversión definida por el usuario debe realizarse en el tipo envolvente o desde este

Duplicate user-defined conversion in type '{0}' Conversión definida por el usuario duplicada en el tipo '{0}'

User-defined operator '{0}' must be declared static and public El operador '{0}' definido por el usuario debe declararse estático y público

The parameter type for ++ or -- operator must be the containing type El tipo de parámetro para el operador ++ o -- debe ser el tipo contenedor

The parameter of a unary operator must be the containing type El parámetro de un operador unario debe ser el tipo contenedor

One of the parameters of a binary operator must be the containing type Uno de los parámetros de un operador binario debe ser el tipo contenedor

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 El primer operando de un operador de desplazamiento sobrecargado debe tener el mismo tipo que el tipo contenedor, y el tipo del segundo operando debe ser int

Structs cannot contain explicit parameterless constructors Los structs no pueden contener constructores explícitos sin parámetros

Enums cannot contain explicit parameterless constructors Las enumeraciones no pueden contener constructores explícitos sin parámetros

'{0}': cannot override '{1}' because it is not supported by the language '{0}': no se puede invalidar '{1}' porque el lenguaje no lo admite

'{0}' is not supported by the language '{0}' no es compatible con el idioma

'{0}': cannot explicitly call operator or accessor '{0}': no se puede llamar explícitamente al operador ni al descriptor de acceso

'{0}': cannot reference a type through an expression; try '{1}' instead '{0}': no se puede hacer referencia a un tipo a través de una expresión; pruebe con '{1}'

'{0}': cannot have instance property or field initializers in structs '{0}': no se pueden tener propiedades de instancia o inicializadores de campo en estructuras

Name of destructor must match name of type El nombre del destructor debe coincidir con el nombre de la clase

Only class types can contain destructors Solo los tipos de clase pueden contener destructores

Namespace '{1}' contains a definition conflicting with alias '{0}' El espacio de nombres '{1}' contiene una definición que entra en conflicto con el alias '{0}'

Alias '{0}' conflicts with {1} definition El alias '{0}' entra en conflicto con {1} definición

The Conditional attribute is not valid on '{0}' because it is a constructor, destructor, operator, or explicit interface implementation El atributo Conditional no es válido en '{0}' porque es un constructor, destructor, operador o la implementación de interfaz explícita

The Conditional attribute is not valid on '{0}' because its return type is not void El atributo Conditional no es válido en '{0}' porque su tipo de valor devuelto no es void

Duplicate '{0}' attribute Atributo '{0}' duplicado

Duplicate '{0}' attribute in '{1}' Atributo '{0}' duplicado en '{1}'

The Conditional attribute is not valid on interface members El atributo Conditional no es válido en miembros de interfaz

User-defined operators cannot return void Los operadores definidos por el usuario no pueden devolver un valor void

'{0}': user-defined conversions to or from the dynamic type are not allowed '{0}': no se permiten conversiones definidas por el usuario ni al tipo dinámico ni desde él.

Invalid value for argument to '{0}' attribute Valor no válido para el argumento del atributo '{0}'

Parameter not valid for the specified unmanaged type. Parámetro no válido para el tipo no administrado especificado.

Attribute parameter '{0}' must be specified. Hay que especificar el parámetro de atributo '{0}'.

Attribute parameter '{0}' or '{1}' must be specified. Hay que especificar el parámetro de atributo '{0}' o '{1}'.

Unmanaged type '{0}' not valid for fields. El tipo '{0}' sin administrar no es válido para los campos.

Unmanaged type '{0}' is only valid for fields. El tipo '{0}' sin administrar solo es válido para los campos.

Attribute '{0}' is not valid on this declaration type. It is only valid on '{1}' declarations. El atributo '{0}' no es válido en este tipo de declaración. Solo es válido en declaraciones '{1}'.

Floating-point constant is outside the range of type '{0}' La constante de punto flotante está fuera del intervalo del tipo '{0}'

The Guid attribute must be specified with the ComImport attribute El atributo Guid se debe especificar con el atributo ComImport

Invalid value for named attribute argument '{0}' Valor no válido para el argumento '{0}' del atributo con nombre

The DllImport attribute must be specified on a method marked 'static' and 'extern' El atributo DllImport se debe especificar en un método marcado como 'static' y 'extern'

Cannot update '{0}'; attribute '{1}' is missing. No se puede actualizar '{0}'; falta el atributo '{1}'.

The DllImport attribute cannot be applied to a method that is generic or contained in a generic method or type. El atributo DllImport no se puede aplicar a un método que sea genérico o esté contenido en un tipo genérico.

Field or property cannot be of type '{0}' El campo o la propiedad no pueden ser del tipo '{0}'

Field or auto-implemented property cannot be of type '{0}' unless it is an instance member of a ref struct. Un campo o una propiedad implementada automáticamente no pueden ser de tipo "{0}", a menos que sea un miembro de instancia de una estructura ref.

Array elements cannot be of type '{0}' Los elementos de matriz no pueden ser del tipo '{0}'

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

Type or member is obsolete El tipo o el miembro están obsoletos

'{0}' is not an attribute class '{0}' no es una clase de atributos

'{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}' no es un argumento de atributo con nombre válido. Los argumentos de atributo con nombre deben ser campos que no sean readonly, static ni const, o bien propiedades read-write que sean public y no static.

'{0}' is obsolete: '{1}' '{0}' está obsoleto: '{1}'

Type or member is obsolete El tipo o el miembro están obsoletos

'{0}' is obsolete: '{1}' '{0}' está obsoleto: '{1}'

Indexers cannot have void type Los indizadores no pueden tener un tipo void

'{0}': virtual or abstract members cannot be private '{0}': los miembros virtuales o abstractos no pueden ser privados

Can only use array initializer expressions to assign to array types. Try using a new expression instead. Solo se pueden usar expresiones de inicializador de matriz como asignación a tipos de matriz. Pruebe a utilizar una expresión new en su lugar.

Array initializers can only be used in a variable or field initializer. Try using a new expression instead. Los inicializadores de matriz solo se pueden utilizar en un inicializador de variable o campo. Pruebe a usar una expresión new en su lugar.

'{0}': instance field in types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute "{0}": el campo de instancia en tipos marcados con StructLayout(LayoutKind.Explicit) debe tener un 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. El método, operador o descriptor de acceso '{0}' está marcado como externo y no tiene atributos. Puede agregar un atributo DllImport para especificar la implementación externa.

Method, operator, or accessor is marked external and has no attributes on it El método, el operador o el descriptor de acceso están marcados como externos y no tienen atributos

'{0}': new protected member declared in sealed type '{0}': nuevo miembro protegido declarado en clase sellada

New protected member declared in sealed type Nuevo miembro protegido declarado en la clase sealed

Conditional member '{0}' cannot implement interface member '{1}' in type '{2}' El miembro condicional '{0}' no puede implementar el miembro de interfaz '{1}' en el tipo '{2}'

ref and out are not valid in this context ref y out no son válidos en este contexto

The argument to the '{0}' attribute must be a valid identifier El argumento pasado al atributo '{0}' debe ser un identificador válido

The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit) El atributo FieldOffset solo se puede colocar en miembros de tipos marcados con StructLayout(LayoutKind.Explicit)

The FieldOffset attribute is not allowed on static or const fields El atributo FieldOffset no se permite en campos static ni const

Attribute '{0}' is only valid on classes derived from System.Attribute El atributo '{0}' solo es válido en clases derivadas de System.Attribute

Possible mistaken empty statement Posible instrucción vacía errónea

'{0}' duplicate named attribute argument '{0}' es un argumento de atributo con nombre duplicado

'{0}' cannot derive from special class '{1}' '{0}' no se puede derivar de la clase especial '{1}'

Cannot specify the DefaultMember attribute on a type containing an indexer No se puede especificar el atributo DefaultMember en un tipo que contenga un indizador

'{0}' is a type not supported by the language 'El idioma no admite el tipo '{0}'

Field '{0}' is never assigned to, and will always have its default value {1} El campo '{0}' nunca se asigna y siempre tendrá el valor predeterminado {1}

Field is never assigned to, and will always have its default value El campo nunca se asigna y siempre tendrá su valor predeterminado

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 erróneo. Para declarar una matriz administrada, el especificador de rango precede al identificador de la variable. Para declarar un campo de búfer de tamaño fijo, use la palabra clave fixed delante del tipo de campo.

Comparison to integral constant is useless; the constant is outside the range of type '{0}' La comparación con la constante integral no es válida; la constante está fuera del intervalo del tipo '{0}'

Comparison to integral constant is useless; the constant is outside the range of the type La comparación con la constante integral es inútil. La constante está fuera del intervalo del tipo

Cannot apply attribute class '{0}' because it is abstract No se puede aplicar la clase de atributo '{0}' porque es abstracta

'{0}' is not a valid named attribute argument because it is not a valid attribute parameter type '{0}' no es un argumento de atributo con nombre válido porque no es un tipo de parámetro de atributo válido

Missing compiler required member '{0}.{1}' Falta el miembro '{0}.{1}' que requiere el compilador

'{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}' no es una ubicación de atributos válida para esta declaración. Las ubicaciones de atributos válidas son '{1}'. Todos los atributos de este bloque se omitirán.

Not a valid attribute location for this declaration No hay ninguna ubicación de atributo válida para esta declaración

'{0}' is not a recognized attribute location. Valid attribute locations for this declaration are '{1}'. All attributes in this block will be ignored. '{0}' no es una ubicación de atributo reconocida. Las ubicaciones de atributo para esta declaración son '{1}'. Todos los atributos de este bloque se omitirán.

Not a recognized attribute location No es una ubicación de atributo reconocida

'{0}' overrides Object.Equals(object o) but does not override Object.GetHashCode() '{0}' invalida Object.Equals(object o) pero no invalida Object.GetHashCode()

Type overrides Object.Equals(object o) but does not override Object.GetHashCode() El tipo reemplaza a Object.Equals(object o), pero no reemplaza a Object.GetHashCode()

'{0}' defines operator == or operator != but does not override Object.Equals(object o) '{0}' define el operador == o el operador != pero no invalida Object.Equals(object o)

Type defines operator == or operator != but does not override Object.Equals(object o) El tipo define operator == or operator !=, pero no reemplaza a override Object.Equals(object o)

'{0}' defines operator == or operator != but does not override Object.GetHashCode() '{0}' define el operador == o el operador != pero no invalida Object.GetHashCode()

Type defines operator == or operator != but does not override Object.GetHashCode() El tipo define operator == or operator !=, pero no reemplaza a Object.GetHashCode()

Cannot specify the Out attribute on a ref parameter without also specifying the In attribute. No se puede especificar el atributo Out en un parámetro ref sin especificar también el atributo In.

'{0}' cannot define an overloaded {1} that differs only on parameter modifiers '{2}' and '{3}' '"{0}" no puede definir un elemento {1} sobrecargado que difiere solo en los modificadores de parámetro "{2}" y "{3}".

Literal of type double cannot be implicitly converted to type '{1}'; use an '{0}' suffix to create a literal of this type El literal de tipo double no se puede convertir implícitamente en el tipo '{1}'; use un sufijo '{0}' para crear un literal de este tipo

Assignment in conditional expression is always constant; did you mean to use == instead of = ? La asignación en la expresión condicional siempre es constante; ¿quería utilizar == en lugar de = ?

Assignment in conditional expression is always constant La asignación en una expresión condicional siempre es constante

'{0}': new protected member declared in struct '{0}': nuevo miembro protegido declarado en estructura

Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type Dos indizadores tienen nombres distintos; el atributo IndexerName se debe utilizar con el mismo nombre en todos los indizadores de un tipo

A class with the ComImport attribute cannot have a user-defined constructor Una clase con el atributo ComImport no puede tener un constructor definido por el usuario

Field cannot have void type El campo no puede tener un tipo void

Member '{0}' overrides obsolete member '{1}'. Add the Obsolete attribute to '{0}'. El miembro '{0}' invalida el miembro obsoleto '{1}'. Agregue el atributo Obsolete a '{0}'.

Member overrides obsolete member El miembro invalida los miembros obsoletos

System.Void cannot be used from C# -- use typeof(void) to get the void type object System.Void no se puede usar en C#; use typeof(void) para obtener el objeto de tipo void

Do not use 'System.ParamArrayAttribute'. Use the 'params' keyword instead. No use 'System.ParamArrayAttribute'. Use la palabra clave 'params' en su lugar.

Bitwise-or operator used on a sign-extended operand; consider casting to a smaller unsigned type first Operador OR bit a bit usado en un operando con extensión de signo; puede convertir primero a un tipo sin signo más pequeño

Bitwise-or operator used on a sign-extended operand Operador OR bit a bit utilizado en un operando de extensión de signo

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. El compilador amplió y extendió el signo de una variable. Luego, utilizó el valor resultante en una operación OR bit a bit. Esto puede provocar un comportamiento inesperado.

'{0}': a volatile field cannot be of the type '{1}' '{0}': un campo volátil no puede ser del tipo '{1}'

'{0}': a field cannot be both volatile and readonly '{0}': un campo no puede ser tanto volátil como de solo lectura

The modifier 'abstract' is not valid on fields. Try using a property instead. El modificador 'abstract' no es válido en los campos. Pruebe a usar una propiedad en su lugar.

'{0}' cannot implement '{1}' because it is not supported by the language '{0}' no puede implementar '{1}' porque el idioma no lo admite

'{0}' explicit method implementation cannot implement '{1}' because it is an accessor 'La implementación del método explícito '{0}' no puede implementar '{1}' porque es un descriptor de acceso

'{0}' interface marked with 'CoClassAttribute' not marked with 'ComImportAttribute' 'La interfaz '{0}' marcada con 'CoClassAttribute' no está marcada con 'ComImportAttribute'

Interface marked with 'CoClassAttribute' not marked with 'ComImportAttribute' La interfaz marcada con el atributo 'CoClassAttribute' no está marcada con el atributo 'ComImportAttribute'

Conditional member '{0}' cannot have an out parameter El miembro condicional '{0}' no puede tener ningún parámetro out

Accessor '{0}' cannot implement interface member '{1}' for type '{2}'. Use an explicit interface implementation. El descriptor de acceso '{0}' no puede implementar el miembro de interfaz '{1}' para el tipo '{2}'. Use una implementación de interfaz explícita.

The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead. El calificador de alias del espacio de nombres '::' siempre se resuelve en un tipo o espacio de nombres, por tanto, aquí no es válido. En su lugar puede usar '.'.

Cannot derive from '{0}' because it is a type parameter No puede derivar de '{0}' porque es un parámetro de tipo

Duplicate type parameter '{0}' Parámetro de tipo duplicado '{0}'

Type parameter '{0}' has the same name as the type parameter from outer type '{1}' El parámetro de tipo '{0}' tiene el mismo nombre que el parámetro de tipo del tipo externo '{1}'

Type parameter has the same name as the type parameter from outer type El parámetro de tipo tiene el mismo nombre que el parámetro de tipo de un tipo externo

Type parameter '{0}' has the same name as the containing type, or method El parámetro de tipo '{0}' tiene el mismo nombre que el tipo contenedor o el método

'{0}' cannot implement both '{1}' and '{2}' because they may unify for some type parameter substitutions '{0}' no puede implementar '{1}' y '{2}' a la vez porque se pueden unificar para algunas sustituciones de parámetros de tipo

A generic type cannot derive from '{0}' because it is an attribute class Un tipo genérico no puede derivar de '{0}' porque es una clase de atributos

'{1}' does not define type parameter '{0}' '{1}' no define el 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}' no es una restricción válida. Un tipo usado como restricción debe ser una interfaz, una clase no sellada o un parámetro de tipo.

Constraint cannot be special class '{0}' La restricción no puede ser la clase especial '{0}'

Inconsistent accessibility: constraint type '{1}' is less accessible than '{0}' Incoherencia de accesibilidad: el tipo de restricción '{1}' es menos accesible que '{0}'

Cannot do member lookup in '{0}' because it is a type parameter No se pueden buscar miembros en '{0}' porque es un 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 restricción no válida. Un tipo utilizado como restricción debe ser una interfaz, una clase no sellada o un parámetro de tipo.

'{0}': cannot declare instance members in a static class '{0}': no se puede declarar miembros de instancia en una clase estática

'{1}': cannot derive from static class '{0}' '{1}': no se puede derivar de la clase estática '{0}'

Static classes cannot have instance constructors Las clases estáticas no pueden tener constructores de instancia

Static classes cannot contain destructors Las clases estáticas no pueden contener destructores

Cannot create an instance of the static class '{0}' No se puede crear ninguna instancia de la clase estática '{0}'

Static class '{0}' cannot derive from type '{1}'. Static classes must derive from object. La clase estática '{0}' no se puede derivar del tipo '{1}'. Las clases estáticas se deben derivar del objeto.

'{0}': static classes cannot implement interfaces '{0}': las clases estáticas no pueden implementar interfaces

'{0}': ref structs cannot implement interfaces '"{0}": las estructuras ref no pueden implementar interfaces.

'{0}': static classes cannot contain user-defined operators '{0}': las clases estáticas no pueden contener operadores definidos por el usuario

Cannot convert to static type '{0}' No se puede convertir en el tipo estático '{0}'

'{0}': static classes cannot be used as constraints '{0}': las clases estáticas no se pueden usar como restricciones

'{0}': static types cannot be used as type arguments '{0}': los tipos estáticos no se pueden usar como argumentos de tipo

'{0}': array elements cannot be of static type '{0}': los elementos de matriz no pueden ser de tipo estático

'{0}': cannot declare indexers in a static class '{0}': no se pueden declarar indizadores en una clase estática

'{0}': static types cannot be used as parameters '{0}': los tipos estáticos no se pueden usar como parámetros

'{0}': static types cannot be used as return types '{0}': los tipos estáticos no se pueden usar como tipos de valores devueltos

Cannot declare a variable of static type '{0}' No se puede declarar una variable de tipo estático '{0}'

A throw statement with no arguments is not allowed in a finally clause that is nested inside the nearest enclosing catch clause No se permite una instrucción throw sin argumentos en una cláusula finally anidada en la cláusula catch más cercana

'{0}' is not a valid format specifier '{0}' no es un 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. Asignación posiblemente incorrecta a la variable local '{0}', que es el argumento pasado a una instrucción using o lock. La llamada Dispose o el desbloqueo se producirán en el valor original de la variable local.

Possibly incorrect assignment to local which is the argument to a using or lock statement Posiblemente una asignación incorrecta a local, que es el argumento a una instrucción using o lock

Type '{0}' is defined in this assembly, but a type forwarder is specified for it El tipo '{0}' está definido en este ensamblado, pero se ha especificado un reenviador de tipos para él

Cannot forward type '{0}' because it is a nested type of '{1}' El tipo '{0}' no se puede reenviar porque es un tipo anidado de '{1}'

The type forwarder for type '{0}' in assembly '{1}' causes a cycle El reenviador del tipo '{0}' en el ensamblado '{1}' crea un ciclo

The /moduleassemblyname option may only be specified when building a target type of 'module' La opción /moduleassemblyname únicamente se puede especificar cuando cree un tipo de destino de 'module'

Assembly reference '{0}' is invalid and cannot be resolved La referencia de ensamblado '{0}' no es válida y no se puede resolver

Invalid type specified as an argument for TypeForwardedTo attribute Tipo no válido especificado como argumento para el atributo TypeForwardedTo

'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static. '{0}' no implementa el miembro de interfaz '{1}'. '{2}' no puede implementar un miembro de interfaz porque es estático.

'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is not public. '{0}' no implementa el miembro de interfaz '{1}'. '{2}' no puede implementar un miembro de interfaz porque no es 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}' no implementa el miembro de interfaz '{1}'. '{2}' no puede implementar '{1}' porque no tiene el tipo de valor devuelto coincidente de '{3}'.

'{0}' duplicate TypeForwardedToAttribute 'Elemento TypeForwardedToAttribute duplicado en '{0}'

A query body must end with a select clause or a group clause El cuerpo de una consulta debe terminar con una cláusula select o group

Expected contextual keyword 'on' Se esperaba la palabra clave contextual 'on'

Expected contextual keyword 'equals' Se esperaba la palabra clave contextual 'equals'

Expected contextual keyword 'by' Se esperaba la palabra clave contextual 'by'

Invalid anonymous type member declarator. Anonymous type members must be declared with a member assignment, simple name or member access. Declarador de miembro de tipo anónimo no válido. Los miembros de tipo anónimo deben declararse con una asignación de miembro, un nombre simple o un acceso al miembro.

Invalid initializer member declarator Declarador de miembro de inicializador no válido

Inconsistent lambda parameter usage; parameter types must be all explicit or all implicit Uso incoherente del parámetro lambda; los tipos de parámetro deben ser todos explícitos o todos implícitos

A partial method cannot have the 'abstract' modifier Un método parcial no puede tener modificadores de acceso ni los modificadores virtual, abstracto, invalidación, nuevo, sellado o externo

A partial method must be declared within a partial type Un método parcial debe declararse dentro de una clase parcial, una estructura parcial o una interfaz parcial

A partial method may not explicitly implement an interface method Un método parcial no puede implementar explícitamente un método de interfaz

Both partial method declarations must be extension methods or neither may be an extension method Ambas declaraciones de método parcial deben ser métodos de extensión; si no, no puede serlo ninguna de las dos

A partial method may not have multiple defining declarations Un método parcial no puede tener varias declaraciones de definición

A partial method may not have multiple implementing declarations Un método parcial no puede tener varias declaraciones de implementación

Both partial method declarations must use a params parameter or neither may use a params parameter Ambas declaraciones de métodos parciales deben usar un parámetro params; si no, ninguna podrá usarlo

No defining declaration found for implementing declaration of partial method '{0}' No se encontró ninguna declaración de definición para la declaración de implementación del método parcial '{0}'

Both partial method declarations, '{0}' and '{1}', must use the same tuple element names. Ambas declaraciones de método parcial, '{0}' y '{1}', deben usar los mismos nombres de elementos de tupla.

Partial method declarations of '{0}' have inconsistent constraints for type parameter '{1}' Las declaraciones de métodos parciales de "{0}" tienen restricciones incoherentes para el parámetro de tipo "{1}"

Cannot create delegate from method '{0}' because it is a partial method without an implementing declaration No se puede crear un delegado a partir del método '{0}' porque es un método parcial sin declaración de implementación

Both partial method declarations must be static or neither may be static Ambas declaraciones de método parcial deben ser estáticas o ninguna de ellas puede ser estática

Both partial method declarations must be unsafe or neither may be unsafe Ambas declaraciones de métodos parciales deben ser no seguras o ninguna de ellas puede ser no segura

Partial methods with only a defining declaration or removed conditional methods cannot be used in expression trees En los árboles de expresión no se pueden usar métodos parciales con solo una declaración de definición ni métodos condicionales quitados

Obsolete member '{0}' overrides non-obsolete member '{1}' El miembro obsoleto '{0}' invalida el miembro no obsoleto '{1}'

Obsolete member overrides non-obsolete member El miembro obsoleto invalida un miembro no obsoleto

The fully qualified name for '{0}' is too long for debug information. Compile without '/debug' option. El nombre completo de '{0}' es demasiado largo para la información de depuración. Compile sin la opción '/debug'.

Fully qualified name is too long for debug information El nombre completo es demasiado largo para la información de depuración

Cannot assign {0} to an implicitly-typed variable No se puede asignar {0} a una variable con tipo implícito

Implicitly-typed variables must be initialized Las variables con tipo implícito se deben inicializar

Implicitly-typed variables cannot have multiple declarators Las variables con tipo implícito no pueden tener varios declaradores

Cannot initialize an implicitly-typed variable with an array initializer Una variable con tipo implícito no se puede inicializar con un inicializador de matriz

Implicitly-typed local variables cannot be fixed Las variables locales con tipo implícito no pueden ser fijas

Implicitly-typed variables cannot be constant Las variables con tipo implícito no pueden ser constantes

Constructor '{0}' is marked external El constructor '{0}' está marcado como externo

Constructor is marked external El constructor está marcado como externo

The contextual keyword 'var' may only appear within a local variable declaration or in script code La palabra clave contextual 'var' solo puede aparecer dentro de una declaración de variable local o en código de script

No best type found for implicitly-typed array No se encontró el mejor tipo para la matriz con tipo implícito

Cannot assign '{0}' to anonymous type property No se puede asignar "{0}" a una propiedad de tipo anónimo

An expression tree may not contain a base access Un árbol de expresión no puede contener un acceso base

An expression tree may not contain an assignment operator Un árbol de expresión no puede contener un operador de asignación

An anonymous type cannot have multiple properties with the same name Un tipo anónimo no puede tener varias propiedades con el mismo nombre

A lambda expression with a statement body cannot be converted to an expression tree Una expresión lambda con un cuerpo de instrucción no se puede convertir en un árbol de expresión

Cannot convert lambda to an expression tree whose type argument '{0}' is not a delegate type No se puede convertir una expresión lambda en un árbol de expresión cuyo argumento de tipo '{0}' no sea un tipo delegado

Cannot use anonymous type in a constant expression No se puede usar un tipo anónimo en una expresión constante

The first operand of an 'is' or 'as' operator may not be a lambda expression, anonymous method, or method group. Es posible que el primer operando de un operador 'is' o 'as' no sea una expresión lambda, un método anónimo ni un grupo de métodos.

The first operand of an 'as' operator may not be a tuple literal without a natural type. El primer operando de un operador "as" no puede ser un literal de tupla sin un tipo natural.

An expression tree may not contain a multidimensional array initializer Un árbol de expresión no puede contener un inicializador de matriz multidimensional

Argument missing Falta un argumento

Cannot use local variable '{0}' before it is declared No se puede usar la variable local '{0}' antes de declararla

Type of '{0}' cannot be inferred since its initializer directly or indirectly refers to the definition. El tipo de '{0}' no se puede inferir porque su inicializador hace referencia, directa o indirectamente, a la definición.

Auto-implemented property '{0}' must be fully assigned before control is returned to the caller. La propiedad '{0}' implementada automáticamente se debe asignar completamente antes de devolver el control al llamador.

Cannot use local variable '{0}' before it is declared. The declaration of the local variable hides the field '{1}'. No se puede usar la variable local '{0}' antes de declararla. La declaración de la variable local oculta el campo '{1}'.

An expression tree lambda may not contain a coalescing operator with a null or default literal left-hand side Un elemento lambda de árbol de expresión no puede contener un operador de incorporación con un literal predeterminado o nulo en la parte izquierda

Identifier expected Se esperaba un identificador

; expected Se esperaba ;

Syntax error, '{0}' expected Error de sintaxis, se esperaba '{0}'

Duplicate '{0}' modifier Modificador '{0}' duplicado

Property accessor already defined Ya se ha definido el descriptor de acceso de la propiedad

Type byte, sbyte, short, ushort, int, uint, long, or ulong expected Se esperaba el tipo byte, sbyte, short, ushort, int, uint, long o ulong

Unrecognized escape sequence Secuencia de escape no reconocida

Newline in constant Nueva línea en constante

Empty character literal Literal de carácter vacío

Too many characters in character literal Demasiados caracteres en literal de carácter

Invalid number Número no válido

A get or set accessor expected Se esperaba un descriptor de acceso get o set

An object, string, or class type expected Un objeto, una cadena o un tipo de clase esperados

Named attribute argument expected Se esperaba un argumento de atributo con nombre

Catch clauses cannot follow the general catch clause of a try statement No puede haber cláusulas catch después de la cláusula catch general de una instrucción try

Keyword 'this' or 'base' expected Se esperaba la palabra clave 'this' o 'base'

Overloadable unary operator expected Se esperaba un operador unario sobrecargable

Overloadable binary operator expected Se esperaba un operador binario sobrecargable

Integral constant is too large La constante integral es demasiado extensa

Type or namespace definition, or end-of-file expected Se esperaba una definición de tipo o espacio de nombres, o el fin del archivo

Member definition, statement, or end-of-file expected Se esperaba una definición, una instrucción o un fin de archivo

Embedded statement cannot be a declaration or labeled statement Una instrucción incrustada no puede ser una declaración o una instrucción con etiqueta

Preprocessor directive expected Se esperaba una directiva de preprocesador

Single-line comment or end-of-line expected Se esperaba un comentario de una línea o un fin de línea

) expected Se esperaba )

#endif directive expected Se esperaba la directiva #endif

Unexpected preprocessor directive Directiva de preprocesador inesperada

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

#warning: '{0}' #advertencia: '{0}'

#warning directive Directiva #warning

Type expected Se esperaba un tipo

Cannot define/undefine preprocessor symbols after first token in file No se puede definir o anular la definición de símbolos de preprocesador después del primer token del archivo

Cannot use #r after first token in file No se puede usar #r después del primer token del archivo

End-of-file found, '*/' expected Se encontró el fin del archivo y se esperaba '*/'

Merge conflict marker encountered Se encontró un marcador de conflicto de fusión mediante combinación

Do not use refout when using refonly. No use refout si utiliza refonly.

Cannot compile net modules when using /refout or /refonly. No se pueden compilar módulos al usar /refout o /refonly.

Overloadable operator expected Se esperaba un operador sobrecargable

#endregion directive expected Se esperaba la directiva #endregion

Unterminated string literal Literal de cadena no terminado

Preprocessor directives must appear as the first non-whitespace character on a line Las directivas de preprocesador deben ser el primer carácter de una línea que no sea un espacio en blanco

Identifier expected; '{1}' is a keyword Se esperaba un identificador; '{1}' es una palabra clave

{ or ; expected Se esperaba { o ;

Cannot use more than one type in a for, using, fixed, or declaration statement No se puede usar más de un tipo en una instrucción for, using, fixed o de declaración

An add or remove accessor expected Se esperaba un descriptor de acceso add o remove

Unexpected character '{0}' Carácter '{0}' inesperado

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

'{0}': static classes cannot contain protected members '{0}': las clases estáticas no pueden contener miembros protegidos

A previous catch clause already catches all exceptions. All non-exceptions thrown will be wrapped in a System.Runtime.CompilerServices.RuntimeWrappedException. Una cláusula catch previa ya detecta todas las excepciones. Las no excepciones producidas se incluirán en System.Runtime.CompilerServices.RuntimeWrappedException.

A previous catch clause already catches all exceptions Una cláusula catch ya abarca todas las excepciones

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. Esta advertencia se produce cuando un bloque catch() no tiene especificado un tipo de excepción después de un bloque catch (System.Exception e). La advertencia avisa de que el bloque catch() no abarcará ninguna excepción. Un bloque catch() después de un bloque catch (System.Exception e) puede abarcar excepciones que no sean CLS si RuntimeCompatibilityAttribute se establece como falso en el archivo AssemblyInfo.cs: [assembly: RuntimeCompatibilityAttribute(WrapNonExceptionThrows = false)]. Si este atributo no se establece explícitamente como falso, todas las excepciones que no sean CLS lanzadas se ajustarán como Excepciones y el bloque catch (System.Exception e) las abarcará.

The operand of an increment or decrement operator must be a variable, property or indexer El operando de un operador de incremento o decremento debe ser una variable, una propiedad o un indizador

'{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}" no contiene una definición para "{1}" ni un método de extensión accesible "{1}" que acepte un primer argumento del tipo "{0}" (¿falta alguna directiva using o una referencia de ensamblado?)

'{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}' no contiene una definición para '{1}' y no se encontró ningún método de extensión '{1}' que acepte un primer argumento de tipo '{0}' (¿falta alguna directiva using para '{2}'?)

Method '{0}' has a parameter modifier 'this' which is not on the first parameter El método '{0}' tiene un modificador de parámetro 'this' que no está en el primer parámetro

The parameter modifier '{0}' cannot be used with '{1}' El modificador de parámetro "{0}" no se puede usar con "{1}".

The first parameter of an extension method cannot be of type '{0}' El primer parámetro de un método de extensión no puede ser del tipo '{0}'

A parameter array cannot be used with 'this' modifier on an extension method Una matriz de parámetros no se puede usar con el modificador 'this' en un método de extensión

Extension method must be static Un método de extensión debe ser estático

Extension method must be defined in a non-generic static class Un método de extensión debe definirse en una clase estática no genérica

A parameter can only have one '{0}' modifier Un parámetro solo puede tener un modificador '{0}'

Extension methods must be defined in a top level static class; {0} is a nested class Los métodos de extensión deben definirse en una clase estática de nivel superior; {0} es una clase anidada

Cannot define a new extension method because the compiler required type '{0}' cannot be found. Are you missing a reference to System.Core.dll? No se puede definir un nuevo método de extensión porque no se encontró el tipo '{0}' requerido por el compilador. ¿Falta alguna referencia a System.Core.dll?

Do not use 'System.Runtime.CompilerServices.ExtensionAttribute'. Use the 'this' keyword instead. No use 'System.Runtime.CompilerServices.ExtensionAttribute'. Use la palabra clave 'this' en su lugar.

Do not use 'System.Runtime.CompilerServices.DynamicAttribute'. Use the 'dynamic' keyword instead. No use 'System.Runtime.CompilerServices.DynamicAttribute'. Use la palabra clave 'dynamic' en su lugar.

The constructor call needs to be dynamically dispatched, but cannot be because it is part of a constructor initializer. Consider casting the dynamic arguments. La llamada de constructor debe enviarse de forma dinámica, pero no se puede porque forma parte de un inicializador de constructor. Puede convertir los argumentos dinámicos.

Extension method '{0}' defined on value type '{1}' cannot be used to create delegates Los métodos de extensión '{0}' definidos en el tipo de valor '{1}' no se pueden usar para crear delegados

No overload for method '{0}' takes {1} arguments Ninguna sobrecarga para el método '{0}' toma {1} argumentos

Argument {0}: cannot convert from '{1}' to '{2}' Argumento {0}: no se puede convertir de '{1}' a '{2}'

Source file '{0}' could not be opened -- {1} No se pudo abrir el archivo de origen '{0}': {1}

Cannot link resource files when building a module No se puede vincular archivos de recursos al compilar un módulo

Resource identifier '{0}' has already been used in this assembly El identificador de recurso '{0}' ya se ha usado en este ensamblado

Each linked resource and module must have a unique filename. Filename '{0}' is specified more than once in this assembly Los recursos y módulos vinculados deben tener un nombre de archivo único. El nombre de archivo '{0}' se ha especificado más de una vez en este ensamblado

The referenced file '{0}' is not an assembly El archivo '{0}' al que se hace referencia no es un ensamblado

A ref or out value must be an assignable variable Un valor out o ref debe ser una variable asignable.

Keyword 'base' is not available in a static method La palabra clave 'base' no está disponible en ningún método estático

Keyword 'base' is not available in the current context La palabra clave 'base' no está disponible en el contexto actual

} expected Se esperaba }

{ expected Se esperaba {

'in' expected 'Se esperaba 'in'

Invalid preprocessor expression Expresión de preprocesador no válida

Invalid token '{0}' in class, record, struct, or interface member declaration El token '{0}' no es válido en una clase, una estructura o una declaración de miembro de interfaz

Method must have a return type El método debe tener un tipo de valor devuelto

Invalid base type Tipo base no válido

Empty switch block Bloque switch vacío

Expected catch or finally Se esperaba catch o finally

Invalid expression term '{0}' El término de expresión '{0}' no es válido

A new expression requires an argument list or (), [], or {} after type Una expresión new requiere (), [] o {} después del tipo

Elements defined in a namespace cannot be explicitly declared as private, protected, protected internal, or private protected Los elementos definidos en un espacio de nombres no se pueden declarar explícitamente como private, protected, protected internal o private protected.

Expected ; or = (cannot specify constructor arguments in declaration) Se esperaba ; o = (no se pueden especificar argumentos de constructor en la declaración)

A using clause must precede all other elements defined in the namespace except extern alias declarations Una cláusula using debe preceder al resto de elementos definidos en el espacio de nombres, excepto las declaraciones de alias externos

Overloaded binary operator '{0}' takes two parameters El operador binario sobrecargado '{0}' toma dos parámetros

Overloaded unary operator '{0}' takes one parameter El operador unario sobrecargado '{0}' toma un parámetro

Invalid parameter type 'void' El tipo de parámetro 'void' no es válido

The using alias '{0}' appeared previously in this namespace El alias using '{0}' aparece previamente en este espacio de nombres

Cannot access protected member '{0}' via a qualifier of type '{1}'; the qualifier must be of type '{2}' (or derived from it) No se puede obtener acceso al miembro protegido '{0}' a través de un calificador del tipo '{1}'; el calificador debe ser del tipo '{2}' (o derivado de este)

'{0}' cannot be added to this assembly because it already is an assembly '{0}' no se puede agregar a este ensamblado porque ya es un ensamblado

Property, indexer, or event '{0}' is not supported by the language; try directly calling accessor methods '{1}' or '{2}' El idioma no admite la propiedad, el indizador o el evento '{0}'; intente llamar directamente a los métodos del descriptor de acceso '{1}' o '{2}'

Property, indexer, or event '{0}' is not supported by the language; try directly calling accessor method '{1}' El idioma no admite la propiedad, el indizador o el evento '{0}'; intente llamar directamente al método del descriptor de acceso '{1}'

Keyword 'void' cannot be used in this context La palabra clave 'void' no se puede usar en este contexto

Indexers must have at least one parameter Los indizadores deben tener al menos un parámetro

Array type specifier, [], must appear before parameter name El especificador de tipo de matriz, [], debe ir delante del nombre del parámetro

Declaration is not valid; use '{0} operator <dest-type> (...' instead La declaración no es válida; en su lugar, use 'operador {0} <tipo de destino> (...'

Could not find '{0}' specified for Main method No se encontró '{0}' especificado para el método Main

'{0}' specified for Main method must be a non-generic class, record, struct, or interface La "{0}" especificada para el método Main debe ser una clase, estructura o interfaz no genérica

'{0}' does not have a suitable static 'Main' method "{0}" no tiene un método "Main" estático adecuado.

Cannot use '{0}' for Main method because it is imported No se puede usar '{0}' para el método Main porque se ha importado

Outputs without source must have the /out option specified Los resultados sin origen deben tener la opción /out especificada

Conflicting options specified: Win32 resource file; Win32 manifest Se especificaron opciones que están en conflicto: archivo de recursos de Win32; manifiesto de Win32

Conflicting options specified: Win32 resource file; Win32 icon Se especificaron opciones conflictivas: archivo de recursos de Win32; icono de Win32

Error reading resource '{0}' -- '{1}' Error al leer el recurso '{0}': '{1}'

Error writing to XML documentation file: {0} Error al escribir en el archivo de documentación XML: {0}

XML comment has badly formed XML -- '{0}' El comentario XML tiene código XML con formato incorrecto: '{0}'

XML comment has badly formed XML El comentario XML tiene XML formado incorrectamente

XML comment has a duplicate param tag for '{0}' El comentario XML tiene una etiqueta param duplicada para '{0}'

XML comment has a duplicate param tag El comentario XML tiene una etiqueta de parámetro duplicada

XML comment has a param tag for '{0}', but there is no parameter by that name El comentario XML tiene una etiqueta param para '{0}', pero no hay ningún parámetro con ese nombre

XML comment has a param tag, but there is no parameter by that name El comentario XML tiene una etiqueta param, pero no hay ningún parámetro con ese nombre

XML comment on '{1}' has a paramref tag for '{0}', but there is no parameter by that name El comentario XML de '{1}' tiene una etiqueta paramref para '{0}', pero no hay ningún parámetro con ese nombre

XML comment has a paramref tag, but there is no parameter by that name El comentario XML tiene una etiqueta paramref, pero no hay ningún parámetro con ese nombre

Parameter '{0}' has no matching param tag in the XML comment for '{1}' (but other parameters do) El parámetro '{0}' no tiene la etiqueta param correspondiente en el comentario XML para '{1}' (pero otros parámetros sí)

Parameter has no matching param tag in the XML comment (but other parameters do) El parámetro no tiene una etiqueta param coincidente en el comentario XML (pero otros parámetros sí)

XML comment has cref attribute '{0}' that could not be resolved El comentario XML tiene un atributo cref '{0}' que no se pudo resolver

XML comment has cref attribute that could not be resolved El comentario XML tiene un atributo cref que no se pudo resolver

A stackalloc expression requires [] after type Una expresión stackalloc requiere [] después del tipo

The line number specified for #line directive is missing or invalid Falta el número de línea especificado para la directiva #line o no es válido

Quoted file name, single-line comment or end-of-line expected Se esperaba un nombre de archivo entre comillas, un comentario de una línea o un fin de línea

Quoted file name expected Se esperaba un nombre de archivo entre comillas

#r is only allowed in scripts #r solo se puede usar en scripts

foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a public instance or extension definition for '{1}' La instrucción foreach no puede funcionar en variables de tipo "{0}" porque "{0}" no contiene ninguna definición de instancia pública para "{1}"

Invalid type for parameter {0} in XML comment cref attribute: '{1}' Tipo no válido para el parámetro {0} en el atributo cref del comentario XML: '{1}'

Invalid type for parameter in XML comment cref attribute Tipo no válido para el parámetro en el atributo cref del comentario XML

Invalid return type in XML comment cref attribute Tipo de valor devuelto no válido en el atributo cref del comentario XML

Error reading Win32 resources -- {0} Error al leer los recursos de Win32: {0}

XML comment has syntactically incorrect cref attribute '{0}' El comentario XML tiene un atributo cref '{0}' con sintaxis incorrecta

XML comment has syntactically incorrect cref attribute El comentario XML tiene un atributo cref sintácticamente incorrecto

Member modifier '{0}' must precede the member type and name El modificador de miembro '{0}' debe ir delante del tipo y nombre de miembro

Array creation must have array size or array initializer La creación de matriz debe disponer de un tamaño de matriz o un inicializador de matriz

XML comment is not placed on a valid language element El comentario XML no está situado en un elemento válido del idioma

Unable to include XML fragment '{1}' of file '{0}' -- {2} No se puede incluir el fragmento de código XML '{1}' del archivo '{0}': {2}

Unable to include XML fragment No se puede incluir el fragmento XML

Invalid XML include element -- {0} Elemento de inclusión XML no válido: {0}

Invalid XML include element Elemento de inclusión XML no válido

Missing XML comment for publicly visible type or member '{0}' Falta el comentario XML para el tipo o miembro visible de forma pública '{0}'

Missing XML comment for publicly visible type or member Falta el comentario XML para el tipo o miembro visible públicamente

The /doc compiler option was specified, but one or more constructs did not have comments. Se especificó la opción del compilador /doc, pero una o más construcciones no tenían comentarios.

Badly formed XML in included comments file -- '{0}' XML con formato incorrecto en el archivo de comentarios de inclusión: '{0}'

Badly formed XML in included comments file Hay XML formado incorrectamente en el archivo de comentarios incluido

Delegate '{0}' does not take {1} arguments El delegado '{0}' no toma {1} argumentos

Semicolon after method or accessor block is not valid El punto y coma después del bloque de métodos o de descriptores de acceso no es válido

The return type of a method, delegate, or function pointer cannot be '{0}' El método o el delegado no pueden devolver el tipo '{0}'

Compilation cancelled by user Compilación cancelada por el usuario

Cannot make reference to variable of type '{0}' No se puede establecer una referencia a una variable de tipo '{0}'

Cannot assign to '{0}' because it is read-only No se puede asignar a '{0}' porque es de solo lectura

Cannot use '{0}' as a ref or out value because it is read-only No se puede usar '{0}' como valor out o ref porque es de solo lectura.

The RequiredAttribute attribute is not permitted on C# types No se permite el atributo RequiredAttribute en tipos C#

Modifiers cannot be placed on event accessor declarations No se pueden colocar modificadores en declaraciones de descriptores de acceso de eventos

The params parameter cannot be declared as {0} El parámetro params no se puede declarar como {0}.

Cannot modify the return value of '{0}' because it is not a variable No se puede modificar el valor devuelto de '{0}' porque no es una variable

The managed coclass wrapper class '{0}' for interface '{1}' cannot be found (are you missing an assembly reference?) No se encuentra la clase contenedora '{0}' de la coclase administrada para la interfaz '{1}' (¿falta alguna referencia de ensamblado?)

'{0}' is ambiguous between '{1}' and '{2}'; use either '@{0}' or '{0}Attribute' '{0}' es ambiguo entre '{1}' y '{2}'; use '@{0}' o '{0}Attribute'

Argument {0} may not be passed with the '{1}' keyword El argumento {0} no se debe pasar con la palabra clave '{1}'

Option '{0}' overrides attribute '{1}' given in a source file or added module La opción '{0}' invalida el atributo '{1}' especificado en un archivo de código fuente o en un módulo agregado

Option overrides attribute given in a source file or added module La opción reemplaza el atributo proporcionado en el archivo de origen o en el módulo añadido

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. Esta advertencia se emite cuando los atributos AssemblyKeyFileAttribute o AssemblyKeyNameAttribute del ensamblador encontrados en el origen entran en conflicto con las opciones de línea de comando /keyfile o /keycontainer o con el nombre del archivo de clave o con el contenedor de claves especificados en las propiedades del proyecto.

Invalid option '{0}' for /langversion. Use '/langversion:?' to list supported values. Opción "{0}" no válida para /langversion. Use "/langversion:?" para enumerar los valores admitidos.

Cannot create delegate with '{0}' because it or a method it overrides has a Conditional attribute No se puede crear un delegado con '{0}' porque él mismo o un método que él invalida tiene un atributo Conditional

Cannot create temporary file -- {0} No se puede crear el archivo temporal: {0}

Argument {0} must be passed with the '{1}' keyword El argumento {0} se debe pasar con la palabra clave '{1}'

The yield statement cannot be used inside an anonymous method or lambda expression La instrucción yield no se puede usar dentro de un método anónimo o una expresión lambda

Cannot return a value from an iterator. Use the yield return statement to return a value, or yield break to end the iteration. No se puede devolver un valor a partir de un iterador. Utilice la instrucción yield return para devolver un valor o yield break para terminar la iteración.

Iterators cannot have ref, in or out parameters Los iteradores no pueden tener parámetros ref, in ni out

The body of '{0}' cannot be an iterator block because '{1}' is not an iterator interface type El cuerpo de '{0}' no puede ser un bloque de iteradores porque '{1}' no es un tipo de interfaz de iteradores

Cannot yield in the body of a finally clause No se pueden proporcionar resultados en el cuerpo de una cláusula finally

Cannot yield a value in the body of a try block with a catch clause No se puede proporcionar un valor en el cuerpo de un bloque try con una cláusula catch

Expression expected after yield return Se esperaba una expresión tras la instrucción yield return

Cannot use ref, out, or in parameter '{0}' inside an anonymous method, lambda expression, query expression, or local function No se puede usar el parámetro ref, out o in "{0}" dentro de un método anónimo, una expresión lambda, una expresión de consulta o una función local

Unsafe code may not appear in iterators No puede aparecer código no seguro en iteradores

Cannot yield a value in the body of a catch clause No se puede proporcionar ningún valor en el cuerpo de una cláusula catch

Control cannot leave the body of an anonymous method or lambda expression El control no puede abandonar el cuerpo de un método anónimo o de una expresión lambda

Unrecognized #pragma directive Directiva #pragma no reconocida

Expected 'disable' or 'restore' Se esperaba "disable" o "restore"

Expected 'disable' or 'restore' after #pragma warning Se esperaba "disable" o "restore" después de la advertencia de #pragma

Cannot restore warning 'CS{0}' because it was disabled globally No se puede restaurar la advertencia 'CS{0}' porque estaba deshabilitada globalmente

Cannot restore warning because it was disabled globally No se puede restaurar la advertencia porque se ha deshabilitado globalmente

__arglist is not allowed in the parameter list of iterators __arglist no se permite en la lista de parámetros de iteradores

Iterators cannot have unsafe parameters or yield types Los iteradores no pueden tener parámetros no seguros o tipos yield

The managed coclass wrapper class signature '{0}' for interface '{1}' is not a valid class name signature La firma de la clase contenedora de coclases administradas '{0}' para la interfaz '{1}' no es una signatura de nombre de clase 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 La instrucción foreach no puede funcionar en variables de tipo '{0}' porque implementa varias creaciones de instancias de "{1}"; intente convertirla en una creación de una instancia de interfaz específica

A fixed size buffer field must have the array size specifier after the field name Un campo de búfer de tamaño fijo debe tener el especificador de tamaño de matriz detrás del nombre de campo

Fixed size buffer fields may only be members of structs Los campos de búfer de tamaño fijo solo pueden ser miembros de estructuras

Not all code paths return a value in {0} of type '{1}' No todas las rutas de acceso de código devuelven un valor en {0} de tipo '{1}'

Feature '{0}' is not part of the standardized ISO C# language specification, and may not be accepted by other compilers La funcionalidad '{0}' no forma parte de la especificación de idioma C# ISO normalizado y puede que otros compiladores no la admitan

Feature is not part of the standardized ISO C# language specification, and may not be accepted by other compilers La funcionalidad no es parte de la especificación de lenguaje C# estandarizada por ISO y puede no estar aceptada en otros compiladores

Keyword, identifier, or string expected after verbatim specifier: @ Se esperaba una palabra clave, un identificador o una cadena detrás del especificador textual: @

A readonly field cannot be used as a ref or out value (except in a constructor) No se puede usar un campo de solo lectura como valor out o ref (excepto en un constructor).

Members of readonly field '{0}' cannot be used as a ref or out value (except in a constructor) No se pueden usar miembros del campo de solo lectura '{0}' como valores out o ref (excepto en un constructor).

A readonly field cannot be assigned to (except in a constructor or init-only setter of the type in which the field is defined or a variable initializer) No se puede asignar a un campo de solo lectura un valor (excepto en un constructor o un establecedor solo de inicialización de la clase en la que se define el campo o un inicializador de variable)

Members of readonly field '{0}' cannot be modified (except in a constructor or a variable initializer) Los miembros del campo de solo lectura '{0}' no se pueden modificar (excepto en un constructor o inicializador de variable)

Cannot use {0} '{1}' as a ref or out value because it is a readonly variable No se puede usar {0} "{1}" como valor out o ref porque es una variable readonly.

Members of {0} '{1}' cannot be used as a ref or out value because it is a readonly variable Los miembros de {0} "{1}" no se pueden usar como valor out o ref porque es una variable readonly.

Cannot assign to {0} '{1}' because it is a readonly variable No se puede asignar a {0} "{1}" porque es una variable readonly.

Cannot assign to a member of {0} '{1}' because it is a readonly variable No se puede asignar a un miembro de {0} "{1}" porque es una variable readonly.

Cannot return {0} '{1}' by writable reference because it is a readonly variable No se puede devolver {0} "{1}" por referencia grabable porque es una variable readonly.

Members of {0} '{1}' cannot be returned by writable reference because it is a readonly variable Los miembros de {0} "{1}" no se pueden devolver por referencia grabable porque es una variable readonly.

Fields of static readonly field '{0}' cannot be assigned to (except in a static constructor or a variable initializer) No se puede asignar a los campos del campo estático de solo lectura '{0}' (excepto en un constructor estático o un inicializador de variable)

Fields of static readonly field '{0}' cannot be used as a ref or out value (except in a static constructor) No se pueden usar campos del campo estático de solo lectura '{0}' como valores out o ref (excepto en un constructor estático).

Cannot modify members of '{0}' because it is a '{1}' Los miembros de '{0}' no se pueden modificar porque es un '{1}'

Cannot use fields of '{0}' as a ref or out value because it is a '{1}' No se pueden usar campos de '{0}' como valores out o ref porque es un '{1}'.

Cannot assign to '{0}' because it is a '{1}' No se puede asignar a '{0}' porque es '{1}'

Cannot use '{0}' as a ref or out value because it is a '{1}' No se puede usar '{0}' como valor out o ref porque es un '{1}'.

{0}. See also error CS{1}. {0}. Vea también el error CS{1}.

Warning is overriding an error La advertencia está remplazando a un error

The compiler emits this warning when it overrides an error with a warning. For information about the problem, search for the error code mentioned. El compilador emite esta advertencia cuando reemplaza un error con una advertencia. Para obtener información sobre el problema, busque el código de error mencionado.

Cannot convert {0} to type '{1}' because it is not a delegate type No se puede convertir {0} en el tipo '{1}' porque no es un tipo delegado

Cannot convert {0} to type '{1}' because the parameter types do not match the delegate parameter types No se puede convertir {0} en el tipo "{1}" porque los tipos de parámetros no coinciden con los tipos de parámetros 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 No se puede convertir {0} en el tipo delegado indicado porque algunos de los tipos de valores devueltos del bloque no se pueden convertir implícitamente en el tipo de valor devuelto del delegado

Since this is an async method, the return expression must be of type '{0}' rather than 'Task<{0}>' Como este es un método asincrónico, la expresión devuelta debe ser de tipo '{0}' en lugar 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}'. No se puede convertir el elemento {0} asincrónico en el tipo delegado '{1}'. Un elemento {0} asincrónico puede devolver void, Task o Task<T>, ninguno de los cuales se puede convertir en '{1}'.

Fixed size buffer type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double El tipo de búfer de tamaño fijo debe pertenecer a uno de los tipos siguientes: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float o double

Fixed size buffer of length {0} and type '{1}' is too big El búfer de tamaño fijo de longitud {0} y tipo '{1}' es demasiado grande

Fixed size buffers must have a length greater than zero Los búferes de tamaño fijo deben tener una longitud mayor que cero

You cannot use fixed size buffers contained in unfixed expressions. Try using the fixed statement. No puede utilizar los búferes de tamaño fijo contenidos en expresiones de tipo unfixed. Pruebe a usar la instrucción "fixed".

Attribute '{0}' is not valid on property or event accessors. It is only valid on '{1}' declarations. El atributo '{0}' no es válido en descriptores de acceso de propiedades o eventos. Solo es válido en declaraciones '{1}'.

Invalid search path '{0}' specified in '{1}' -- '{2}' Se ha especificado una ruta de acceso de búsqueda '{0}' no válida en '{1}': '{2}'

Invalid search path specified Ruta de búsqueda especificada no válida

__arglist is not valid in this context __arglist no es válido en este contexto

params is not valid in this context params no es válido en este contexto

A namespace declaration cannot have modifiers or attributes Una declaración de espacio de nombres no puede tener modificadores ni atributos

Invalid option '{0}' for /platform; must be anycpu, x86, Itanium, arm, arm64 or x64 Opción "{0}" no válida para /platform; debe ser anycpu, x86, Itanium, arm, arm64 o x64

Anonymous methods, lambda expressions, query expressions, and local functions inside structs cannot access instance members of 'this'. Consider copying 'this' to a local variable outside the anonymous method, lambda expression, query expression, or local function and using the local instead. Los métodos anónimos, las expresiones lambda y las expresiones de consulta incluidos en estructuras no pueden obtener acceso a miembros de instancia de 'this'. Puede copiar 'this' en una variable local fuera del método anónimo, la expresión lambda o la expresión de consulta y usar la variable local en su lugar.

'{0}': type used in a using statement must be implicitly convertible to 'System.IDisposable'. "{0}": el tipo usado en una instrucción using debe poder convertirse implícitamente en "System.IDisposable".

Parameter {0} must be declared with the '{1}' keyword El parámetro {0} se debe declarar con la palabra clave '{1}'

Parameter {0} should not be declared with the '{1}' keyword El parámetro {0} no se debe declarar con la palabra clave '{1}'

Parameter {0} is declared as type '{1}{2}' but should be '{3}{4}' El parámetro {0} se declara como tipo '{1}{2}', pero debería ser '{3}{4}'

Invalid extern alias for '/reference'; '{0}' is not a valid identifier Alias externo no válido para '/reference'; '{0}' no es un identificador válido

Invalid reference alias option: '{0}=' -- missing filename Opción de alias de referencia no válida: '{0}=', falta el nombre de archivo

You cannot redefine the global extern alias No se puede definir de nuevo el 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 La referencia al tipo '{0}' confirma que está definida en este ensamblado, pero no lo está ni en el código fuente ni en los módulos agregados

Reference to type '{0}' claims it is defined in '{1}', but it could not be found La referencia al tipo '{0}' confirma que está definida en '{1}', pero no se encontró

The predefined type '{0}' is defined in multiple assemblies in the global alias; using definition from '{1}' El tipo predefinido '{0}' está definido en varios ensamblados del alias global; se usa la definición de '{1}'

Predefined type is defined in multiple assemblies in the global alias El tipo predefinido está definido en varios ensamblajes en el 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 error se produce cuando un tipo de sistema predefinido como System.Int32 se encuentra en dos ensamblajes. Una forma de que esto suceda es si hace referencia a mscorlib o System.Runtime.dll desde dos lugares diferentes, como si intentase ejecutar dos versiones de .NET Framework en paralelo.

Local '{0}' or its members cannot have their address taken and be used inside an anonymous method or lambda expression La variable local '{0}' o sus miembros no pueden ceder su dirección para usarse en un método anónimo o una expresión lambda

Source file has exceeded the limit of 16,707,565 lines representable in the PDB; debug information will be incorrect El archivo de código fuente ha superado el límite de 16.707.565 líneas representables en el PDB. La información de depuración no será correcta.

Cannot convert anonymous method block without a parameter list to delegate type '{0}' because it has one or more out parameters No se puede convertir el bloque de método anónimo sin una lista de parámetros en el tipo delegado '{0}' porque tiene uno o varios parámetros out

Attribute '{0}' is only valid on methods or attribute classes El atributo '{0}' solo es válido en métodos o clases de atributos

Accessing a member on '{0}' may cause a runtime exception because it is a field of a marshal-by-reference class El acceso a un miembro en '{0}' podría provocar una excepción en tiempo de ejecución, ya que es un campo de una clase de serialización por referencia.

Accessing a member on a field of a marshal-by-reference class may cause a runtime exception El acceso a un miembro en un campo de una clase de serialización por referencia puede causar una excepción en tiempo de ejecución.

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. Esta advertencia se produce cuando intenta llamar a un método, a una propiedad o a un indizador en un miembro de una clase que deriva de MarshalByRefObject y el miembro es un tipo de valor. Los objetos que se heredan de MarshallByRefObject suelen estar diseñados para serializarse por referencia a través del dominio de una aplicación. Si, alguna vez, algún tipo de código intenta acceder directamente al miembro del tipo de valor de un objeto así a través del dominio de una aplicación, se producirá una excepción en tiempo de ejecución. Para resolver la advertencia, primero debe copiar el miembro en una variable local y llamar al método en esa variable.

'{0}' is not a valid warning number '{0}' no es un número de advertencia válido

Not a valid warning number Número de advertencia no 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. Un número que se aprobó en la directiva de preprocesador de advertencia #pragma no es un número de advertencia válido. Verifique que ese número representa una advertencia y no un error.

Invalid number Número no válido

Invalid filename specified for preprocessor directive. Filename is too long or not a valid filename. Nombre de archivo no válido especificado para la directiva del preprocesador. Nombre de archivo demasiado largo o no válido.

Invalid filename specified for preprocessor directive Se ha especificado un nombre de archivo no válido para la directiva de preprocesador

Invalid #pragma checksum syntax; should be #pragma checksum "filename" "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" "XXXX..." Sintaxis de #pragma checksum no válida; debe ser #pragma checksum "nombre de archivo" "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" "XXXX..."

Invalid #pragma checksum syntax Sintaxis de suma de comprobación de #pragma no válida

Single-line comment or end-of-line expected Se esperaba un comentario de una línea o un fin de línea

Single-line comment or end-of-line expected after #pragma directive Se esperaba un comentario de una línea o un fin de línea después de la directiva #pragma

Different checksum values given for '{0}' Se han proporcionado distintos valores de suma de comprobación para '{0}'

Different #pragma checksum values given Se han proporcionado diferentes valores de suma de comprobación de #pragma

Assembly reference '{0}' is invalid and cannot be resolved La referencia de ensamblado '{0}' no es válida y no se puede resolver

Assembly reference is invalid and cannot be resolved La referencia de ensamblado no es válida y no se puede resolver

This warning indicates that an attribute, such as InternalsVisibleToAttribute, was not specified correctly. Esta advertencia indica que un atributo, como InternalsVisibleToAttribute, no se especificó correctamente.

Assuming assembly reference '{0}' used by '{1}' matches identity '{2}' of '{3}', you may need to supply runtime policy Suponiendo que la referencia del ensamblado '{0}' usada por '{1}' coincide con la identidad '{2}' de '{3}', puede que necesite proporcionar la directiva en tiempo de ejecución

Assuming assembly reference matches identity Asumiendo que la referencia al ensamblaje coincide con la identidad

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. Los dos ensamblajes difieren en el número de versión y/o compilación. Para que haya unificación, debe especificar directivas en el archivo .config de la aplicación y debe proveer el nombre seguro correcto de un ensamblaje.

Assuming assembly reference matches identity Asumiendo que la referencia al ensamblaje coincide con la identidad

Multiple assemblies with equivalent identity have been imported: '{0}' and '{1}'. Remove one of the duplicate references. Se han importado varios ensamblados con identidad equivalente: '{0}' y '{1}'. Quite una de las referencias 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. Ya se ha importado un ensamblado con el mismo nombre sencillo '{0}'. Intente quitar una de las referencias (por ej., '{1}') o fírmelas para habilitar la función en paralelo.

Assembly '{0}' with identity '{1}' uses '{2}' which has a higher version than referenced assembly '{3}' with identity '{4}' El ensamblado '{0}' con la identidad '{1}' usa '{2}', que tiene una versión superior a la del ensamblado '{3}' al que se hace referencia y que tiene la identidad '{4}'

Fixed size buffers can only be accessed through locals or fields Solo se puede tener acceso a los búferes de tamaño fijo mediante variables locales o campos

XML comment has a duplicate typeparam tag for '{0}' El comentario XML tiene una etiqueta typeparam duplicada para '{0}'

XML comment has a duplicate typeparam tag El comentario XML tiene una etiqueta typeparam duplicada

XML comment has a typeparam tag for '{0}', but there is no type parameter by that name El comentario XML tiene una etiqueta typeparam para '{0}', pero no hay ningún parámetro con ese nombre

XML comment has a typeparam tag, but there is no type parameter by that name El comentario XML tiene una etiqueta typeparam, pero no hay ningún parámetro de tipo con ese nombre

XML comment on '{1}' has a typeparamref tag for '{0}', but there is no type parameter by that name El comentario XML de '{1}' tiene una etiqueta typeparamref para '{0}', pero no hay ningún parámetro con ese nombre

XML comment has a typeparamref tag, but there is no type parameter by that name El comentario XML tiene una etiqueta typeparamref, pero no hay ningún parámetro de tipo con ese nombre

Type parameter '{0}' has no matching typeparam tag in the XML comment on '{1}' (but other type parameters do) El parámetro de tipo '{0}' no tiene ninguna etiqueta typeparam correspondiente en el comentario XML en '{1}' (pero otros parámetros de tipo sí)

Type parameter has no matching typeparam tag in the XML comment (but other type parameters do) El parámetro de tipo no tiene una etiqueta typeparam coincidente en el comentario XML (pero otros parámetros de tipo sí)

'{0}': type must be '{2}' to match overridden member '{1}' '{0}': el tipo debe ser '{2}' para que coincida con el miembro invalidado '{1}'

Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead. No utilice el atributo 'System.Runtime.CompilerServices.FixedBuffer'. En su lugar, use el modificador de campo 'fixed'.

Assignment made to same variable; did you mean to assign something else? Asignación a la misma variable. ¿Quería asignar otro elemento?

Assignment made to same variable Se ha asignado a la misma variable

Comparison made to same variable; did you mean to compare something else? La comparación se ha hecho con la misma variable. ¿Quería comparar otro elemento?

Comparison made to same variable Comparación hecha a la misma variable

Error opening Win32 resource file '{0}' -- '{1}' Error al abrir el archivo de recursos de Win32 '{0}': '{1}'

Expression will always cause a System.NullReferenceException because the default value of '{0}' is null La expresión siempre producirá System.NullReferenceException porque el valor predeterminado de '{0}' es NULL

Expression will always cause a System.NullReferenceException because the type's default value is null La expresión siempre causará una excepción System.NullReferenceException porque el valor por defecto es null

Class '{0}' cannot have multiple base classes: '{1}' and '{2}' La clase '{0}' no puede tener varias clases base: '{1}' y '{2}'

Base class '{0}' must come before any interfaces La clase base '{0}' debe ir antes que cualquier interfaz

XML comment has cref attribute '{0}' that refers to a type parameter El comentario XML tiene un atributo cref '{0}' que hace referencia a un parámetro de tipo

XML comment has cref attribute that refers to a type parameter El comentario XML tiene un atributo cref que hace referencia a un parámetro de tipo

Friend assembly reference '{0}' is invalid. InternalsVisibleTo declarations cannot have a version, culture, public key token, or processor architecture specified. La referencia de ensamblado de confianza '{0}' no es válida. Las declaraciones InternalsVisibleTo no pueden tener especificada una versión, una referencia cultural, un token de clave pública ni una arquitectura de procesador.

Friend assembly reference '{0}' is invalid. Strong-name signed assemblies must specify a public key in their InternalsVisibleTo declarations. La referencia de ensamblado de confianza '{0}' no es válida. Los ensamblados firmados con nombre seguro deben especificar una clave pública en sus declaraciones InternalsVisibleTo.

Cannot bind delegate to '{0}' because it is a member of 'System.Nullable<T>' No se puede enlazar el delegado con '{0}' porque es un miembro de 'System.Nullable<T>'

'{0}' does not contain a constructor that takes {1} arguments '{0}' no contiene un constructor que tome {1} argumentos

Assembly and module attributes must precede all other elements defined in a file except using clauses and extern alias declarations Los atributos de módulo y ensamblado deben ir delante de los demás elementos definidos en un archivo, excepto las cláusulas using y las declaraciones de alias externos

Expected expression Se esperaba una expresión

Invalid version {0} for /subsystemversion. The version must be 6.02 or greater for ARM or AppContainerExe, and 4.00 or greater otherwise Versión {0} no válida para /subsystemversion. La versión debe ser 6.02 o posterior para ARM o AppContainerExe, y 4.00 o posterior en caso contrario

Embedded interop method '{0}' contains a body. El método de interoperabilidad incrustado '{0}' contiene un cuerpo.

Warning level must be zero or greater El nivel de advertencia debe estar en el intervalo 0-4

Invalid option '{0}' for /debug; must be 'portable', 'embedded', 'full' or 'pdbonly' Opción '{0}' no válida para /debug; debe ser 'portable', 'embedded', 'full' o 'pdbonly'

Invalid option '{0}'; Resource visibility must be either 'public' or 'private' Opción '{0}' no válida; la visibilidad de los recursos debe ser 'public' o 'private'

The type of the argument to the DefaultParameterValue attribute must match the parameter type El tipo de argumento para el atributo DefaultParameterValue debe coincidir con el tipo de parámetro

Argument of type '{0}' is not applicable for the DefaultParameterValue attribute El argumento de tipo '{0}' no se puede aplicar al atributo DefaultParameterValue

Duplicate initialization of member '{0}' Inicialización del miembro '{0}' duplicada

Member '{0}' cannot be initialized. It is not a field or property. No se puede inicializar el miembro '{0}'. No es un campo ni una propiedad.

Static field or property '{0}' cannot be assigned in an object initializer No se puede asignar la propiedad o campo estático '{0}' en un 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 Los miembros del campo de solo lectura '{0}' de tipo '{1}' no se pueden asignar con un inicializador de objeto porque es de un tipo de valor

Members of property '{0}' of type '{1}' cannot be assigned with an object initializer because it is of a value type Los miembros de la propiedad '{0}' de tipo '{1}' no se pueden asignar con un inicializador de objeto porque es de un tipo de valor

Unsafe type '{0}' cannot be used in object creation El tipo '{0}' no seguro no se puede usar para crear un objeto

Element initializer cannot be empty El inicializador de elemento no puede estar vacío

The best overloaded method match for '{0}' has wrong signature for the initializer element. The initializable Add must be an accessible instance method. La mejor coincidencia de método sobrecargado para '{0}' tiene una firma errónea para el elemento inicializador. El elemento Add inicializable debe ser un método de instancia accesible.

Cannot initialize type '{0}' with a collection initializer because it does not implement 'System.Collections.IEnumerable' No se puede inicializar el tipo '{0}' con un inicializador de colección porque no implementa 'System.Collections.IEnumerable'

Error reading Win32 manifest file '{0}' -- '{1}' Error al leer el archivo de manifiesto '{0}' de Win32: '{1}'

Ignoring /win32manifest for module because it only applies to assemblies Se omitirá /win32manifest para el módulo porque solo se aplica a ensamblados

'{0}' does not contain a definition for '{1}' and the best extension method overload '{2}' requires a receiver of type '{3}' '{0}' no contiene una definición para '{1}' y la mejor sobrecarga del método de extensión '{2}' requiere un receptor del tipo '{3}'

The range variable '{0}' has already been declared La variable de rango '{0}' ya se ha declarado

The range variable '{0}' conflicts with a previous declaration of '{0}' La variable de rango '{0}' entra en conflicto con una declaración anterior de '{0}'

Cannot assign {0} to a range variable No se puede asignar {0} a una variable de rango

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}'. No se encontró ninguna implementación del patrón de consulta para el tipo de origen '{0}'. No se encontró '{1}'. Puede especificar de forma explícita el tipo de la variable de rango '{2}'.

Could not find an implementation of the query pattern for source type '{0}'. '{1}' not found. Are you missing required assembly references or a using directive for 'System.Linq'? No se encontró ninguna implementación del patrón de consulta para el tipo de origen '{0}'. No se encontró '{1}'. ¿Falta alguna referencia a 'System.Core.dll' o alguna directiva using para 'System.Linq'?

Could not find an implementation of the query pattern for source type '{0}'. '{1}' not found. No se encontró ninguna implementación del patrón de consulta para el tipo de origen '{0}'. No se encontró '{1}'.

The name '{0}' is not in scope on the left side of 'equals'. Consider swapping the expressions on either side of 'equals'. El nombre '{0}' no está dentro del ámbito en el lado izquierdo de 'equals'. Puede intercambiar las expresiones en cualquier 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'. El nombre '{0}' no está dentro del ámbito en el lado derecho de 'equals'. Puede cambiar las expresiones en cualquier lado de 'equals'.

Cannot pass the range variable '{0}' as an out or ref parameter No se puede pasar la variable de rango '{0}' como parámetro out o ref

Multiple implementations of the query pattern were found for source type '{0}'. Ambiguous call to '{1}'. Se encontraron varias implementaciones del patrón de consulta para el tipo de origen '{0}'. Llamada ambigua a '{1}'.

The type of one of the expressions in the {0} clause is incorrect. Type inference failed in the call to '{1}'. El tipo de una de las expresiones de la cláusula {0} es incorrecto. No se pudo realizar la inferencia de tipos en la llamada a '{1}'.

The type of the expression in the {0} clause is incorrect. Type inference failed in the call to '{1}'. El tipo de la expresión de la cláusula {0} es incorrecto. No se pudo realizar la inferencia de tipos en la llamada a '{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}'. No se permiten expresiones de tipo '{0}' en una cláusula from siguiente incluida en una expresión de consulta con el tipo de origen '{1}'. No se pudo realizar la inferencia de tipos en la llamada a '{2}'.

An expression tree may not contain an unsafe pointer operation Un árbol de expresión no puede contener una operación de puntero no segura

An expression tree may not contain an anonymous method expression Un árbol de expresión no puede contener una expresión de método anónimo

An anonymous method expression cannot be converted to an expression tree Una expresión de método anónimo no se puede convertir en un árbol de expresión

Range variable '{0}' cannot be assigned to -- it is read only La variable de rango '{0}' no se puede asignar: es de solo lectura

The range variable '{0}' cannot have the same name as a method type parameter La variable de rango '{0}' no puede tener el mismo nombre que un parámetro de tipo de método

The contextual keyword 'var' cannot be used in a range variable declaration La palabra clave contextual 'var' no se puede usar en una declaración de variable de rango

The best overloaded Add method '{0}' for the collection initializer has some invalid arguments El mejor método Add sobrecargado '{0}' del inicializador de colecciones tiene algunos argumentos no válidos

An expression tree lambda may not contain a ref, in or out parameter Una expresión lambda de árbol de expresión no puede contener un parámetro ref, in ni out

An expression tree lambda may not contain a method with variable arguments Una expresión lambda de árbol de expresión no puede contener un método con argumentos variables

An expression tree lambda may not contain a method group Una expresión lambda de árbol de expresión no puede contener un 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. La mejor coincidencia de método sobrecargado '{0}' para el elemento inicializador de la colección no se puede usar. Los métodos 'Add' inicializadores de colección no pueden tener parámetros out ni ref.

Non-invocable member '{0}' cannot be used like a method. No se puede usar como método el miembro '{0}' no invocable.

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. El miembro '{0}' implementa el miembro de interfaz '{1}' en el tipo '{2}'. Hay varias coincidencias para el miembro de interfaz en tiempo de ejecución. El método que se llamará depende de la implementación.

Member implements interface member with multiple matches at run-time El miembro implementa el miembro de la interfaz con varias coincidencias en el tiempo de ejecución

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. Esta advertencia puede producirse cuando dos métodos de interfaz solo se diferencian por la marca de un parámetro particular con ref o out. Es mejor cambiar su código para evitar esta advertencia porque no es obvio ni se garantiza qué método se llamará en el tiempo de ejecución. A pesar de que C# distingue entre out y ref, el CLR los ve como iguales. Cuando decida qué método implementa la interfaz, el CLR escoge uno. Indique al compilador alguna forma de diferenciar los métodos. Por ejemplo, puede darles nombres diferentes o dar un parámetro adicional a uno de ellos.

Member '{1}' overrides '{0}'. There are multiple override candidates at run-time. It is implementation dependent which method will be called. Please use a newer runtime. El miembro '{1}' invalida '{0}'. Hay varios candidatos de invalidación en tiempo de ejecución. El método que se llamará depende de la implementación.

Member overrides base member with multiple override candidates at run-time El miembro invalida los miembros base con varios candidatos de invalidación en el tiempo de ejecución

Object and collection initializer expressions may not be applied to a delegate creation expression No se pueden aplicar expresiones de inicializador de objeto y colección a una expresión de creación de delegado

'{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}' es de tipo '{1}'. El tipo especificado en una declaración de constantes debe ser sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, string, un tipo de enumeración o un tipo de referencia.

Source file '{0}' could not be found. No se encontró el archivo de origen '{0}'.

Source file '{0}' specified multiple times El archivo de código fuente '{0}' se especificó varias veces

Source file specified multiple times Se especificó el archivo de origen varias veces

Missing file specification for '{0}' option Falta la especificación de archivo de la opción '{0}'

Command-line syntax error: Missing '{0}' for '{1}' option Error de sintaxis de línea de comandos: falta '{0}' para la opción '{1}'

Unrecognized option: '{0}' Opción no reconocida: '{0}'

No source files specified. No se especificaron archivos de código fuente.

No source files specified No se especificaron archivos de origen

Expected a script (.csx file) but none specified Se esperaba un script (archivo .csx), pero no se especificó ninguno

Error opening response file '{0}' Error al abrir el archivo de respuesta '{0}'

Cannot open '{0}' for writing -- '{1}' No se puede abrir '{0}' para escribir: '{1}'

Invalid image base number '{0}' El número base de la imagen '{0}' no es válido

'{0}' is a binary file instead of a text file '{0}' es un archivo binario en vez de uno de texto

Code page '{0}' is invalid or not installed La página de código '{0}' no es válida o no está instalada

Algorithm '{0}' is not supported No se admite el algoritmo '{0}'

Cannot specify /main if building a module or library No se puede especificar /main si se compila un módulo o una biblioteca

Invalid target type for /target: must specify 'exe', 'winexe', 'library', or 'module' Tipo de destino no válido para /target: se debe especificar 'exe', 'winexe', 'library' o 'module'

Ignoring /noconfig option because it was specified in a response file Omitiendo la opción /noconfig porque se especificó en un archivo de respuesta

Invalid file section alignment '{0}' Alineación de sección de archivo no válida "{0}"

Invalid output name: {0} Nombre de archivo salida no válido: {0}

Invalid debug information format: {0} Formato de la información de depuración no válido: {0}

'id#' syntax is no longer supported. Use '$id' instead. 'Ya no se admite la sintaxis 'id#'. En su lugar, use '$id'.

Invalid name for a preprocessing symbol; '{0}' is not a valid identifier Nombre no válido para un símbolo de preprocesamiento; "{0}" no es un identificador válido

Invalid name for a preprocessing symbol; not a valid identifier Nombre no válido para un símbolo de preprocesamiento; no es un identificador válido

Cannot create short filename '{0}' when a long filename with the same short filename already exists No se puede crear el nombre de archivo corto '{0}' cuando ya existe un nombre de archivo largo con el mismo nombre de archivo corto

A /reference option that declares an extern alias can only have one filename. To specify multiple aliases or filenames, use multiple /reference options. Una opción /reference que declara un alias externo solo puede tener un nombre de archivo. Para especificar varios alias o nombres de archivo, utilice varias opciones /reference.

Command-line syntax error: Missing ':<number>' for '{0}' option Error de sintaxis de línea de comandos: falta ':<número>' para la opción '{0}'

The /pdb option requires that the /debug option also be used La opción /pdb requiere que se use también la opción /debug

An expression tree lambda may not contain a COM call with ref omitted on arguments Una expresión lambda de árbol de expresión no puede contener una llamada COM con ref omitido en argumentos

Command-line syntax error: Invalid Guid format '{0}' for option '{1}' Error de sintaxis de línea de comandos: formato de GUID '{0}' no válido para la opción '{1}'

Command-line syntax error: Missing Guid for option '{1}' Error de sintaxis de línea de comandos: falta el GUID para la opción '{1}'

Methods with variable arguments are not CLS-compliant Los métodos con argumentos de variable no son conformes a CLS

Argument type '{0}' is not CLS-compliant El tipo de argumento '{0}' no es conforme a CLS

Argument type is not CLS-compliant El tipo de argumento no es conforme a CLS

Return type of '{0}' is not CLS-compliant El tipo de valor devuelto de '{0}' no es conforme a CLS

Return type is not CLS-compliant El tipo de retorno no es conforme a CLS

Type of '{0}' is not CLS-compliant El tipo de '{0}' no es conforme a CLS

Type is not CLS-compliant El tipo no es conforme a CLS

A public, protected, or protected internal variable must be of a type that is compliant with the Common Language Specification (CLS). Una variable interna pública o protegida debe ser de un tipo conforme a Common Language Specification (CLS).

Identifier '{0}' differing only in case is not CLS-compliant El identificador '{0}' que solo se diferencia por el uso de mayúsculas o minúsculas no es conforme a CLS

Identifier differing only in case is not CLS-compliant El identificador difiere solo en caso de que no sea conforme a CLS

Overloaded method '{0}' differing only in ref or out, or in array rank, is not CLS-compliant El método sobrecargado '{0}' que solo se diferencia en out o ref, o en el rango de matriz, no es conforme a CLS

Overloaded method differing only in ref or out, or in array rank, is not CLS-compliant El método sobrecargado solo difiere en ref o out, o bien en el rango de matriz. No es conforme a CLS

Overloaded method '{0}' differing only by unnamed array types is not CLS-compliant El método sobrecargado '{0}' que solo se diferencia por tipos de matriz sin nombre no es conforme a CLS

Overloaded method differing only by unnamed array types is not CLS-compliant El método sobrecargado que solo difiere por tipos de matriz sin nombre no es conforme a 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 error se produce cuando tiene un método sobrecargado que toma una matriz escalonada y cuando la única diferencia entre firmas del método es el tipo de elemento del rango. Para evitar este error, considere utilizar una matriz rectangular en vez de una matriz escalonada. Utilice un parámetro adicional para desambiguar la función de llamada. Cambie el nombre de uno o de varios métodos sobrecargados. Si no necesita la conformidad a CLS, elimine el atributo CLSCompliantAttribute.

Identifier '{0}' is not CLS-compliant El identificador '{0}' no es conforme a CLS

Identifier is not CLS-compliant El identificador no es conforme a CLS

'{0}': base type '{1}' is not CLS-compliant '{0}': el tipo base '{1}' no es conforme a CLS

Base type is not CLS-compliant El tipo de base no es conforme a 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. Se ha marcado al tipo de base para que no tenga que ser conforme a Common Language Specification (CLS) en un ensamblador que se ha marcado como conforme a CLS. Elimine el atributo que especifica que el ensamblador es conforme a CLS o elimine el atributo que indica que el tipo no es conforme a CLS.

'{0}': CLS-compliant interfaces must have only CLS-compliant members '{0}': las interfaces conformes a CLS solo pueden tener miembros conformes a CLS

CLS-compliant interfaces must have only CLS-compliant members Las interfaces conformes a CLS solo pueden contener miembros conformes a CLS

'{0}': only CLS-compliant members can be abstract '{0}': solo los miembros conformes a CLS pueden ser abstractos

Only CLS-compliant members can be abstract Solo los miembros conformes a CLS pueden ser abstractos

You must specify the CLSCompliant attribute on the assembly, not the module, to enable CLS compliance checking Debe especificar el atributo CLSCompliant en el ensamblado, no en el módulo, para habilitar la comprobación de conformidad con CLS

Added modules must be marked with the CLSCompliant attribute to match the assembly Los módulos agregados se deben marcar con el atributo CLSCompliant para que coincidan con el ensamblado

'{0}' cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute '{0}' no se puede marcar como conforme a CLS porque el ensamblado no tiene ningún atributo CLSCompliant

Type or member cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute No se puede marcar al tipo o al miembro como conformes a CLS porque el ensamblador no tiene un atributo CLSCompliant

'{0}' has no accessible constructors which use only CLS-compliant types '{0}' no tiene constructores accesibles que usen solo tipos conformes a CLS

Type has no accessible constructors which use only CLS-compliant types EL tipo no tiene constructores accesibles que solo usen tipos conforme a CLS

Arrays as attribute arguments is not CLS-compliant El uso de matrices como argumentos de atributo no es conforme a CLS

You cannot specify the CLSCompliant attribute on a module that differs from the CLSCompliant attribute on the assembly No se puede especificar el atributo CLSCompliant en un módulo que sea distinto del atributo CLSCompliant del ensamblado

'{0}' cannot be marked as CLS-compliant because it is a member of non-CLS-compliant type '{1}' '{0}' no se puede marcar como conforme a CLS porque es miembro del tipo '{1}' no conforme a CLS

Type cannot be marked as CLS-compliant because it is a member of non-CLS-compliant type No se puede marcar al tipo como conforme a CLS porque es miembro de un tipo no conforme a CLS

CLS compliance checking will not be performed on '{0}' because it is not visible from outside this assembly La comprobación de conformidad con CLS no se realizará en '{0}' porque no es visible desde fuera de este ensamblado

CLS compliance checking will not be performed because it is not visible from outside this assembly No se puede realizar la comprobación de conformidad a CLS porque no es visible fuera de este ensamblador

'{0}' does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute '{0}' no necesita ningún atributo CLSCompliant porque el ensamblado no tiene ningún atributo CLSCompliant

Type or member does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute El tipo o el miembro no necesitan un atributo CLSCompliant porque el ensamblador no tiene un atributo CLSCompliant

CLSCompliant attribute has no meaning when applied to parameters. Try putting it on the method instead. El atributo CLSCompliant no tiene ningún significado cuando se aplica a parámetros. Pruebe a incluirlo en el método.

CLSCompliant attribute has no meaning when applied to parameters El atributo CLSCompliant no tiene ningún significado cuando se aplica a parámetros

CLSCompliant attribute has no meaning when applied to return types. Try putting it on the method instead. El atributo CLSCompliant no tiene ningún significado cuando se aplica a tipos de valor devuelto. Pruebe a incluirlo en el método.

CLSCompliant attribute has no meaning when applied to return types El atributo CLSCompliant no tiene ningún significado cuando se aplica tipos de retorno

Constraint type '{0}' is not CLS-compliant El tipo de restricción '{0}' no es conforme a CLS

Constraint type is not CLS-compliant El tipo de restricción no es conforme a CLS

CLS-compliant field '{0}' cannot be volatile El campo '{0}' conforme a CLS no puede ser volátil

CLS-compliant field cannot be volatile El campo no conforme a CLS no puede ser volátil

'{0}' is not CLS-compliant because base interface '{1}' is not CLS-compliant '{0}' no es conforme a CLS porque la interfaz base '{1}' no lo es

Type is not CLS-compliant because base interface is not CLS-compliant El tipo no es conforme a CLS porque la interfaz base no es conforme a CLS

'await' requires that the type {0} have a suitable 'GetAwaiter' method "await" requiere que el tipo {0} tenga un método "GetAwaiter" adecuado.

Cannot await '{0}' No se puede usar await con '{0}'

'await' requires that the return type '{0}' of '{1}.GetAwaiter()' have suitable 'IsCompleted', 'OnCompleted', and 'GetResult' members, and implement 'INotifyCompletion' or 'ICriticalNotifyCompletion' "await" requiere que el tipo de valor devuelto "{0}" de "{1}.GetAwaiter()" tenga miembros "IsCompleted", "OnCompleted" y "GetResult" adecuados y que implemente "INotifyCompletion" o "ICriticalNotifyCompletion".

'await' requires that the type '{0}' have a suitable 'GetAwaiter' method. Are you missing a using directive for 'System'? "await" requiere que el tipo "{0}" tenga un método "GetAwaiter" adecuado. ¿Falta una directiva "using" para "System"?

Cannot await 'void' No se puede usar await con 'void'

'await' cannot be used as an identifier within an async method or lambda expression 'await' no se puede usar como identificador dentro de un método asincrónico o expresión lambda

'{0}' does not implement '{1}' '{0}' no 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}' es un método asincrónico que devuelve 'Task', una palabra clave return no debe ir seguida de una expresión de objeto. ¿Intentó devolver 'Task<T>'?

The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T> El tipo de valor devuelto de un método asincrónico debe ser void, Task, Task<T>, una variante del tipo Task, IAsyncEnumerable<T> o IAsyncEnumerator<T>.

Cannot return an expression of type 'void' No se puede devolver una expresión de tipo 'void'

__arglist is not allowed in the parameter list of async methods No se permite __arglist en la lista de parámetros de métodos asincrónicos

'await' cannot be used in an expression containing the type '{0}' 'await' no se puede usar en una expresión que contenga el tipo '{0}'

Async methods cannot have unsafe parameters or return types Los métodos asincrónicos no pueden tener parámetros no seguros o tipos de valor devuelto

Async methods cannot have ref, in or out parameters Los métodos asincrónicos no pueden tener parámetros ref, in ni out

The 'await' operator can only be used when contained within a method or lambda expression marked with the 'async' modifier El operador 'await' solo se puede usar cuando está contenido dentro de un método o una expresión lambda marcada con el modificador 'async'

The 'await' operator can only be used within an async {0}. Consider marking this {0} with the 'async' modifier. El operador 'await' solo se puede usar dentro de un {0} asincrónico. Puede marcar este {0} con el 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}>'. El operador 'await' solo se puede usar dentro de un método asincrónico. Puede marcar este método con el modificador 'async' y cambiar su tipo de valor devuelto a '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'. El operador 'await' solo se puede usar dentro de un método asincrónico. Puede marcar este método con el modificador 'async' y cambiar su tipo de valor devuelto a 'Task'.

Cannot await in the body of a finally clause No se puede usar await en el cuerpo de una cláusula finally

Cannot await in a catch clause No se puede usar await en una cláusula catch

Cannot await in the filter expression of a catch clause No se puede usar await en la expresión de filtro de una cláusula catch

Cannot await in the body of a lock statement No se puede usar await en el cuerpo de una instrucción lock

The 'await' operator cannot be used in a static script variable initializer. El operador 'await' no se puede usar en un inicializador de variable de script estático.

Cannot await in an unsafe context No se puede usar await en un contexto no seguro.

The 'async' modifier can only be used in methods that have a body. El modificador 'async' solo se puede usar en métodos que tengan un cuerpo.

Parameters or locals of type '{0}' cannot be declared in async methods or lambda expressions. Los parámetros o las variables locales de tipo '{0}' no se pueden declarar en métodos asincrónicos o expresiones lambda.

foreach statement cannot operate on enumerators of type '{0}' in async or iterator methods because '{0}' is a ref struct. La instrucción foreach no puede funcionar en enumeradores de tipo "{0}" en métodos async o iterator porque "{0}" es una estructura ref.

Security attribute '{0}' cannot be applied to an Async method. El atributo de seguridad '{0}' no se puede aplicar a un método Async.

Async methods are not allowed in an Interface, Class, or Structure which has the 'SecurityCritical' or 'SecuritySafeCritical' attribute. Los métodos Async no se permiten en interfaces, clases ni estructuras que tienen el atributo 'SecurityCritical' o '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 El operador 'await' solo se puede usar en una expresión de consulta dentro de la primera expresión de colección de la cláusula 'from' inicial o de la expresión de colección de una 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. El método asincrónico carece de operadores "await" y se ejecutará de forma sincrónica. Puede usar el operador 'await' para esperar llamadas API que no sean de bloqueo o 'await Task.Run(...)' para hacer tareas enlazadas a la CPU en un subproceso en segundo plano.

Async method lacks 'await' operators and will run synchronously El método asincrónico carece de operadores "await" y se ejecutará de forma sincrónica

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 llamada no es 'awaited', la ejecución del método actual continuará antes de que se complete la llamada. Puede aplicar el operador 'await' al resultado de la llamada.

Because this call is not awaited, execution of the current method continues before the call is completed Dado que no se esperaba esta llamada, la ejecución del método actual continuará antes de que se complete la llamada

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. El método actual llama a un método asincrónico que devuelve una tarea o un Task<TResult>, y no aplica el operador Await al resultado. La llamada al método asincrónico inicia una tarea asincrónica. Sin embargo, debido a que no se aplica ningún operador Await, el programa continúa sin esperar a que finalice la tarea. En la mayoría de los casos, este comportamiento no es el esperado. Generalmente, otros aspectos del método de llamada dependen de los resultados de la llamada. O bien, se espera como mínimo que el método al que se llama se complete antes de volver al método que contiene la llamada. Un problema de igual importancia es el que se genera con las excepciones que se producen en el método asincrónico al que se llama. Las excepciones que se producen en un método que devuelve una tarea o un Task<TResult> se almacenan en la tarea devuelta. Si no espera por la tarea o no realiza una comprobación explícita de excepciones, la excepción se pierde. Si espera por la tarea, su excepción se vuelve a producir. Como procedimiento recomendado, siempre debe esperar por la llamada. Considere la posibilidad de suprimir la advertencia solo si tiene la seguridad de que no desea esperar a que la llamada asincrónica se complete y que el método al que se llama no producirá excepciones. En ese caso, puede suprimir la advertencia asignando el resultado de la tarea de la llamada a una variable.

'MethodImplOptions.Synchronized' cannot be applied to an async method 'MethodImplOptions.Synchronized' no se puede aplicar a un método asincrónico

CallerLineNumberAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}' CallerLineNumberAttribute no se puede aplicar porque no hay conversiones estándar del tipo '{0}' al tipo '{1}'

CallerFilePathAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}' CallerFilePathAttribute no se puede aplicar porque no hay conversiones estándar del tipo '{0}' al tipo '{1}'

CallerMemberNameAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}' CallerMemberNameAttribute no se puede aplicar porque no hay conversiones estándar del tipo '{0}' al tipo '{1}'

The CallerLineNumberAttribute may only be applied to parameters with default values CallerLineNumberAttribute solo se puede aplicar a parámetros con valores predeterminados

The CallerFilePathAttribute may only be applied to parameters with default values CallerFilePathAttribute solo se puede aplicar a parámetros con valores predeterminados

The CallerMemberNameAttribute may only be applied to parameters with default values CallerMemberNameAttribute solo se puede aplicar a parámetros con valores predeterminados

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 El CallerLineNumberAttribute aplicado al parámetro '{0}' no tendrá efecto porque se aplica a un miembro que se usa en contextos que no permiten argumentos opcionales

The CallerLineNumberAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments El atributo CallerLineNumberAttribute no tendrá efecto porque se aplica a un miembro que se utiliza en contextos que no permiten argumentos opcionales

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 El CallerFilePathAttribute aplicado al parámetro '{0}' no tendrá efecto porque se aplica a un miembro que se usa en contextos que no permiten argumentos opcionales

The CallerFilePathAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments El CallerFilePathAttribute no tendrá efecto porque se aplica a un miembro que se usa en contextos que no permiten argumentos opcionales

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 El CallerMemberNameAttribute aplicado al parámetro '{0}' no tendrá efecto porque se aplica a un miembro que se usa en contextos que no permiten argumentos opcionales

The CallerMemberNameAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments El atributo CallerMemberNameAttribute no tendrá efecto porque se aplica a un miembro que se utiliza en contextos que no permiten argumentos opcionales

Program does not contain a static 'Main' method suitable for an entry point El programa no contiene ningún método 'Main' estático adecuado para un punto de entrada

An array initializer of length '{0}' is expected Se espera un inicializador de matriz con la longitud '{0}'

A nested array initializer is expected Se espera un inicializador de matriz anidada

Invalid variance modifier. Only interface and delegate type parameters can be specified as variant. Modificador de varianza no válido. Solo se pueden especificar como variantes parámetros de tipo de interfaz y delegado.

Unexpected use of an aliased name Uso inesperado de un nombre con alias

Unexpected use of a generic name Uso inesperado de un nombre genérico

Unexpected use of an unbound generic name Uso inesperado de un nombre genérico sin enlazar

Expressions and statements can only occur in a method body Las expresiones y las instrucciones solo pueden aparecer en un cuerpo de método

An array access may not have a named argument specifier Un acceso de matriz no puede tener un especificador de argumento con nombre

This language feature ('{0}') is not yet implemented. Esta funcionalidad de idioma ('{0}') todavía no está implementada.

Default values are not valid in this context. Los valores predeterminados no son válidos en este contexto.

Error opening icon file {0} -- {1} Error al abrir el archivo de icono {0}: {1}

Error opening Win32 manifest file {0} -- {1} Error al abrir el archivo de manifiesto de Win32 {0}: {1}

Error building Win32 resources -- {0} Error al compilar recursos de Win32: {0}

Optional parameters must appear after all required parameters Los parámetros opcionales deben aparecer después de todos los parámetros necesarios

Cannot inherit interface '{0}' with the specified type parameters because it causes method '{1}' to contain overloads which differ only on ref and out No se puede heredar la interfaz '{0}' con los parámetros de tipo especificados porque da lugar a que el método '{1}' contenga sobrecargas que difieren solo en ref y out

Partial declarations of '{0}' must have the same type parameter names and variance modifiers in the same order Las declaraciones parciales de '{0}' deben tener los mismos nombres de parámetro de tipo y modificadores de varianza en el mismo orden

Invalid variance: The type parameter '{1}' must be {3} valid on '{0}'. '{1}' is {2}. Varianza no válida: el parámetro de tipo '{1}' debe ser un {3} válido en '{0}'. '{1}' es {2}.

'{0}': cannot derive from the dynamic type '{0}': no se puede derivar del tipo dinámico

'{0}': cannot implement a dynamic interface '{1}' '{0}': no puede implementar una interfaz dinámica '{1}'

Constraint cannot be the dynamic type La restricción no puede ser el tipo dinámico

Constraint cannot be a dynamic type '{0}' La restricción no puede ser un tipo dinámico '{0}'

One or more types required to compile a dynamic expression cannot be found. Are you missing a reference? No se encuentran uno o varios tipos necesarios para compilar una expresión dinámica. ¿Falta alguna referencia?

Name '{0}' exceeds the maximum length allowed in metadata. El nombre '{0}' supera la longitud máxima permitida en los metadatos.

Attributes are not valid in this context. Los atributos no son válidos en este contexto.

'extern alias' is not valid in this context 'extern alias' no es válido en este 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 probar la compatibilidad con '{1}' es, básicamente, lo mismo que probar la compatibilidad con '{2}' y surtirá efecto para todos los valores distintos de NULL

Using 'is' to test compatibility with 'dynamic' is essentially identical to testing compatibility with 'Object' Usar "is" para comprobar la compatibilidad con "dynamic" es idéntico a comprobar la compatibilidad con "Object"

Cannot use 'yield' in top-level script code No se puede usar 'yield' en el código de script de nivel superior

Cannot declare namespace in script code No se puede declarar un espacio de nombres en el código del script

Assembly and module attributes are not allowed in this context En este contexto no se permiten atributos de ensamblado y módulo

Delegate '{0}' has no invoke method or an invoke method with a return type or parameter types that are not supported. El delegado '{0}' no tiene método 'invoke' o tiene un método 'invoke' con un tipo de valor devuelto o unos tipos de parámetro que no son compatibles.

The entry point of the program is global code; ignoring '{0}' entry point. El punto de entrada del programa es código de script global: se omite el punto de entrada '{0}'.

The entry point of the program is global code; ignoring entry point El punto de entrada del programa es código de script global. Ignorando punto de entrada

Inconsistent accessibility: event type '{1}' is less accessible than event '{0}' Incoherencia de accesibilidad: el tipo de evento '{1}' es menos accesible que el 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. Las especificaciones de argumento con nombre deben aparecer después de haber especificado todos los argumentos fijos. Use la versión {0} del lenguaje, o una posterior, para permitir argumentos con nombre que no sean finales.

Named argument specifications must appear after all fixed arguments have been specified in a dynamic invocation. Las especificaciones de argumento con nombre deben aparecer después de haber especificado todos los argumentos fijos en una invocación dinámica.

The best overload for '{0}' does not have a parameter named '{1}' La mejor sobrecarga para '{0}' no tiene un parámetro denominado '{1}'

The delegate '{0}' does not have a parameter named '{1}' El delegado '{0}' no tiene un parámetro denominado '{1}'

Named argument '{0}' cannot be specified multiple times El argumento con nombre '{0}' no se puede especificar varias veces

Named argument '{0}' specifies a parameter for which a positional argument has already been given El argumento con nombre '{0}' especifica un parámetro para el que ya se ha proporcionado un argumento posicional

Named argument '{0}' is used out-of-position but is followed by an unnamed argument El argumento "{0}" con nombre se usa fuera de posición, pero va seguido de un argumento sin nombre.

Cannot specify default parameter value in conjunction with DefaultParameterAttribute or OptionalAttribute No se puede especificar un valor de parámetro predeterminado junto con DefaultParameterAttribute u OptionalAttribute

Default parameter value for '{0}' must be a compile-time constant El valor de parámetro predeterminado para '{0}' debe ser una constante en tiempo de compilación

A ref or out parameter cannot have a default value Un parámetro ref o out no puede tener un valor predeterminado

Cannot specify a default value for the 'this' parameter No se puede especificar un valor predeterminado para el parámetro 'this'

Cannot specify a default value for a parameter array No se puede especificar un valor predeterminado para una 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}' Un valor de tipo '{0}' no se puede usar como parámetro predeterminado porque no hay conversiones estándar al tipo '{1}'

A value of type '{0}' cannot be used as default parameter for nullable parameter '{1}' because '{0}' is not a simple type Un valor de tipo '{0}' no se puede usar como parámetro predeterminado para el parámetro '{1}' que acepta valores NULL porque '{0}' no es un tipo simple

'{0}' is of type '{1}'. A default parameter value of a reference type other than string can only be initialized with null '{0}' es de tipo '{1}'. Un valor de parámetro predeterminado de un tipo de referencia que no sea de cadena solo se puede inicializar con 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 El valor predeterminado especificado para el parámetro '{0}' no tendrá efecto porque se aplica a un miembro que se usa en contextos que no permiten argumentos opcionales

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 El valor por defecto especificado no tendrá efecto porque se aplica a un miembro que se utiliza en contextos que no permiten argumentos opcionales

Error signing output with public key from file '{0}' -- {1} Error al firmar la salida con una clave pública del archivo '{0}': {1}

Error signing output with public key from container '{0}' -- {1} Error al firmar la salida con una clave pública del contenedor '{0}': {1}

The typeof operator cannot be used on the dynamic type El operador typeof no se puede usar en el tipo dinámico

An expression tree may not contain a dynamic operation Un árbol de expresión no puede contener una operación dinámica

Async lambda expressions cannot be converted to expression trees Las expresiones lambda asincrónicas no se pueden convertir en árboles de expresión

Cannot define a class or member that utilizes 'dynamic' because the compiler required type '{0}' cannot be found. Are you missing a reference? No se puede definir una clase o un miembro que use 'dynamic', porque no se encuentra el tipo '{0}' requerido por el compilador. ¿Falta alguna referencia?

Cannot pass null for friend assembly name No se puede pasar un valor NULL como nombre de ensamblado de confianza

Key file '{0}' is missing the private key needed for signing Al archivo de clave '{0}' le falta la clave privada necesaria para firmar

Public signing was specified and requires a public key, but no public key was specified. Se especificó la firma pública y se requiere una clave pública, pero no se ha especificado ninguna.

Public signing is not supported for netmodules. No se admite la firma pública para netmodules.

Delay signing was specified and requires a public key, but no public key was specified Se especificó un retraso en la firma y esto requiere una clave pública, pero no se ha especificado ninguna

The specified version string does not conform to the required format - major[.minor[.build[.revision]]] La cadena de versión especificada no se ajusta al formato requerido: principal[.secundaria[.compilación[.revisión]]]

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 La versión especificada contiene comodines, que no son compatibles con la determinación. Quite los comodines de la cadena de versión o deshabilite la determinación para esta compilación.

The specified version string does not conform to the required format - major.minor.build.revision (without wildcards) La cadena de versión especificada no se ajusta al formato requerido: principal.secundaria.compilación.revisión (sin comodines)

The specified version string does not conform to the recommended format - major.minor.build.revision La cadena de versión especificada no se ajusta al formato recomendado: principal,secundaria,compilación,revisión

Executables cannot be satellite assemblies; culture should always be empty Los archivos ejecutables no pueden ser ensamblados satélite y no deben tener referencia cultural

There is no argument given that corresponds to the required formal parameter '{0}' of '{1}' No se ha dado ningún argumento que corresponda al parámetro formal requerido '{0}' de '{1}'

The command line switch '{0}' is not yet implemented and was ignored. El modificador de línea de comandos '{0}' todavía no se ha implementado y se ha omitido.

Command line switch is not yet implemented El switch de la línea de comandos aún no está implementado

Failed to emit module '{0}': {1} No se pudo emitir el módulo "{0}": {1}

Cannot use fixed local '{0}' inside an anonymous method, lambda expression, or query expression No se puede usar el valor local fijo '{0}' dentro de un método anónimo, una expresión lambda o una expresión de consulta

An expression tree may not contain a named argument specification Un árbol de expresión no puede contener una especificación de argumento con nombre

An expression tree may not contain a call or invocation that uses optional arguments Un árbol de expresión no puede contener una llamada o invocación que use argumentos opcionales

An expression tree may not contain an indexed property Un árbol de expresión no puede contener una propiedad indizada

Indexed property '{0}' has non-optional arguments which must be provided La propiedad indizada '{0}' tiene argumentos no opcionales que se deben proporcionar

Indexed property '{0}' must have all arguments optional La propiedad indizada '{0}' debe tener todos los argumentos opcionales

Instance of type '{0}' cannot be used inside a nested function, query expression, iterator block or async method La instancia de tipo "{0}" no se puede usar dentro de una función anidada, una expresión de consulta, un bloque iterador ni un método asincrónico.

First argument to a security attribute must be a valid SecurityAction El primer argumento de un atributo de seguridad debe ser una SecurityAction válida

Security attribute '{0}' has an invalid SecurityAction value '{1}' El atributo de seguridad '{0}' tiene un valor '{1}' de SecurityAction no válido

SecurityAction value '{0}' is invalid for security attributes applied to an assembly El valor '{0}' de SecurityAction no es válido para los atributos de seguridad aplicados a un ensamblado

SecurityAction value '{0}' is invalid for security attributes applied to a type or a method El valor '{0}' de SecurityAction no es válido para los atributos de seguridad aplicados a un tipo o método

SecurityAction value '{0}' is invalid for PrincipalPermission attribute El valor '{0}' de SecurityAction no es válido para el atributo PrincipalPermission

An expression tree may not contain '{0}' Un árbol de expresión no puede contener '{0}'

Unable to resolve file path '{0}' specified for the named argument '{1}' for PermissionSet attribute No se pudo resolver la ruta de acceso de archivo '{0}' especificada para el argumento con nombre '{1}' del atributo PermissionSet

Error reading file '{0}' specified for the named argument '{1}' for PermissionSet attribute: '{2}' Error al leer el archivo '{0}' especificado para el argumento con nombre '{1}' del 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. No se encuentra el nombre de tipo '{0}' en el espacio de nombres global. Este tipo se ha reenviado al ensamblado '{1}'. Puede agregar una referencia a ese ensamblado.

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. No se encuentra el nombre de tipo '{0}' en el espacio de nombres '{1}'. Este tipo se ha reenviado al ensamblado '{2}'. Puede agregar una referencia a ese ensamblado.

The type name '{0}' could not be found. This type has been forwarded to assembly '{1}'. Consider adding a reference to that assembly. No se encontró el nombre del tipo '{0}'. Este tipo se ha reenviado al ensamblado '{1}'. Puede agregar una referencia a ese ensamblado.

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. Los ensamblados '{0}' y '{1}' hacen referencia a los mismos metadatos, pero solo uno es una referencia vinculada (especificada con la opción /link): puede quitar una de las referencias.

The best overloaded Add method '{0}' for the collection initializer element is obsolete. El mejor método Add sobrecargado '{0}' para el elemento inicializador de la colección está obsoleto.

The best overloaded Add method for the collection initializer element is obsolete El mejor método Add sobrecargado para el elemento inicializador de la colección está obsoleto

The best overloaded Add method '{0}' for the collection initializer element is obsolete. {1} El mejor método Add sobrecargado '{0}' para el elemento inicializador de la colección está obsoleto. {1}

The best overloaded Add method for the collection initializer element is obsolete El mejor método Add sobrecargado para el elemento inicializador de la colección está obsoleto

Yield statements may not appear at the top level in interactive code. Las instrucciones yield pueden no aparecer en el nivel superior del código interactivo.

Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations. El valor '{0}' de SecurityAction no es válido en este tipo de declaración. Los atributos de seguridad solo son válidos en las declaraciones de ensamblado, de tipo y de método.

Cannot use an expression of type '{0}' as an argument to a dynamically dispatched operation. No se puede usar una expresión del tipo '{0}' como argumento de una operación enviada de forma dinámica.

Cannot use a lambda expression as an argument to a dynamically dispatched operation without first casting it to a delegate or expression tree type. No se puede usar una expresión lambda como argumento de una operación enviada de forma dinámica sin convertirla antes en un tipo delegado o de árbol de expresión.

Cannot use a method group as an argument to a dynamically dispatched operation. Did you intend to invoke the method? No se puede usar un grupo de métodos como argumento de una operación enviada de forma dinámica. ¿Quería invocar el 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. La llamada al método '{0}' debe enviarse de forma dinámica, pero no se puede porque forma parte de una expresión de acceso base. Puede convertir los argumentos dinámicos o eliminar el acceso base.

Query expressions over source type 'dynamic' or with a join sequence of type 'dynamic' are not allowed No se permiten expresiones de consulta con el tipo de origen 'dynamic' o con una secuencia de unión de 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. El acceso de indizador debe enviarse de forma dinámica, pero no se puede porque forma parte de una expresión de acceso base. Puede convertir los argumentos dinámicos o eliminar el acceso base.

The dynamically dispatched call to method '{0}' may fail at runtime because one or more applicable overloads are conditional methods. La llamada al método '{0}' enviada de forma dinámica puede dar error en tiempo de ejecución porque una o varias sobrecargas aplicables son métodos condicionales.

Dynamically dispatched call may fail at runtime because one or more applicable overloads are conditional methods La llamada distribuida dinámicamente puede fallar en el tiempo de ejecución porque una o más sobrecargas aplicables son métodos condicionales

'{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}' no tiene ningún método aplicable denominado '{1}', pero tiene un método de extensión con ese nombre. Los métodos de extensión no se pueden enviar de forma dinámica. Puede convertir los argumentos dinámicos o llamar al método de extensión sin la sintaxis de método de extensión.

The CallerMemberNameAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerFilePathAttribute. El CallerMemberNameAttribute aplicado al parámetro '{0}' no tendrá efecto. Lo invalida el CallerFilePathAttribute.

The CallerMemberNameAttribute will have no effect; it is overridden by the CallerFilePathAttribute El atributo CallerMemberNameAttribute no tendrá efecto: lo reemplaza el atributo CallerFilePathAttribute

The CallerMemberNameAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerLineNumberAttribute. El CallerMemberNameAttribute aplicado al parámetro '{0}' no tendrá efecto. Lo invalida el CallerLineNumberAttribute.

The CallerMemberNameAttribute will have no effect; it is overridden by the CallerLineNumberAttribute El atributo CallerMemberNameAttribute no tendrá efecto: lo reemplaza el atributo CallerLineNumberAttribute

The CallerFilePathAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerLineNumberAttribute. El CallerFilePathAttribute aplicado al parámetro '{0}' no tendrá efecto. Lo invalida el CallerLineNumberAttribute.

The CallerFilePathAttribute will have no effect; it is overridden by the CallerLineNumberAttribute El atributo CallerFilePathAttribute no tendrá efecto: lo reemplaza el atributo CallerLineNumberAttribute

Expression must be implicitly convertible to Boolean or its type '{0}' must define operator '{1}'. La expresión se debe poder convertir implícitamente en 'Boolean' o su tipo '{0}' debe definir el operador '{1}'.

'{0}' cannot implement '{1}' because '{2}' is a Windows Runtime event and '{3}' is a regular .NET event. '{0}' no puede implementar '{1}' porque '{2}' es un evento de Windows Runtime y '{3}' es un evento normal de .NET.

Call System.IDisposable.Dispose() on allocated instance of {0} before all references to it are out of scope. Llame a System.IDisposable.Dispose() en la instancia asignada de {0} antes de que todas las referencias a él estén fuera de ámbito.

Call System.IDisposable.Dispose() on allocated instance before all references to it are out of scope Llame a System.IDisposable.Dispose() en una instancia asignada antes de que todas sus referencias estén fuera de ámbito

Allocated instance of {0} is not disposed along all exception paths. Call System.IDisposable.Dispose() before all references to it are out of scope. La instancia asignada de {0} no se desecha en todas las rutas de acceso de excepciones. Llame a System.IDisposable.Dispose() antes de que todas las referencias a él estén fuera de ámbito.

Allocated instance is not disposed along all exception paths La instancia asignada no está eliminada en todas las rutas de acceso de excepción

Object '{0}' can be disposed more than once. El objeto '{0}' se puede desechar más de una vez.

Object can be disposed more than once Se puede eliminar el objeto más de una vez

Interop type '{0}' cannot be embedded. Use the applicable interface instead. El tipo de interoperabilidad '{0}' no se puede incrustar. En su lugar, use la interfaz aplicable.

Type '{0}' cannot be embedded because it is a nested type. Consider setting the 'Embed Interop Types' property to false. El tipo '{0}' no se puede incrustar porque es un tipo anidado. Puede establecer la propiedad 'Incrustar tipos de interoperabilidad' en false.

Type '{0}' cannot be embedded because it has a generic argument. Consider setting the 'Embed Interop Types' property to false. El tipo '{0}' no se puede incrustar porque tiene un argumento genérico. Puede establecer la propiedad 'Incrustar tipos de interoperabilidad' en false.

Embedded interop struct '{0}' can contain only public instance fields. La estructura de interoperabilidad incrustada '{0}' solo puede contener campos de instancia públicos.

A Windows Runtime event may not be passed as an out or ref parameter. Un evento de Windows Runtime no se puede pasar como parámetro out o ref.

Source interface '{0}' is missing method '{1}' which is required to embed event '{2}'. A la interfaz de origen '{0}' le falta el método '{1}', que es necesario para incrustar el evento '{2}'.

Interface '{0}' has an invalid source interface which is required to embed event '{1}'. La interfaz '{0}' tiene una interfaz de origen no válida necesaria para incrustar el evento '{1}'.

Interop type '{0}' cannot be embedded because it is missing the required '{1}' attribute. El tipo de interoperabilidad '{0}' no se puede incrustar porque le falta el atributo '{1}' requerido.

Cannot embed interop types from assembly '{0}' because it is missing the '{1}' attribute. No se pueden incrustar tipos de interoperabilidad desde el ensamblado '{0}' porque no tiene el atributo '{1}'.

Cannot embed interop types from assembly '{0}' because it is missing either the '{1}' attribute or the '{2}' attribute. No se pueden incrustar tipos de interoperabilidad desde el ensamblado '{0}' porque le falta el atributo '{1}' o '{2}'.

Cannot embed interop type '{0}' found in both assembly '{1}' and '{2}'. Consider setting the 'Embed Interop Types' property to false. No se puede incrustar el tipo de interoperabilidad '{0}' encontrado en los ensamblados '{1}' y '{2}'. Puede establecer la propiedad 'Incrustar tipos de interoperabilidad' en false.

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. Si se incrusta el tipo de interoperabilidad '{0}' desde el ensamblado '{1}', se producirá un conflicto de nombre en el ensamblado actual. Puede establecer la propiedad 'Incrustar tipos de interoperabilidad' en false.

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. Se creó una referencia al ensamblado de interoperabilidad '{0}' incrustado debido a una referencia indirecta a ese ensamblado creado por el ensamblado '{1}'. Puede cambiar la propiedad 'Incrustar tipos de interoperabilidad' en cualquiera de los ensamblados.

A reference was created to embedded interop assembly because of an indirect assembly reference Se creó una referencia para el ensamblaje de interoperabilidad incrustado debido a una referencia al ensamblaje indirecta

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. Ha añadido una referencia a un ensamblado con /link (con la propiedad Embed Interop Types establecida como verdadera). Esto instruye al compilador para que inserte información del tipo de interoperabilidad desde ese ensamblado. Sin embargo, el compilador no puede insertar información del tipo de interoperabilidad desde ese ensamblado porque hay otro ensamblado que ha referenciado que hace referencia a ese ensamblado con /reference (con la propiedad Embed Interop Types establecida como falsa). Para insertar información del tipo de interoperabilidad en ambos ensamblados, use /link para las referencias de ambos ensamblados (establezca la propiedad Embed Interop Types como verdadera). Para eliminar la advertencia puede usar /reference (establezca la propiedad Embed Interop Types como falsa). En este caso, un ensamblado de interoperabilidad primario (PIA) provee información del tipo de interoperabilidad.

Type '{0}' from assembly '{1}' cannot be used across assembly boundaries because it has a generic type argument that is an embedded interop type. El tipo "{0}" del ensamblado "{1}" no se puede usar en los distintos límites de ensamblado porque tiene un argumento de tipo genérico que es un tipo de interoperabilidad incrustado.

Cannot find the interop type that matches the embedded interop type '{0}'. Are you missing an assembly reference? No se encuentra el tipo de interoperabilidad que coincide con el tipo de interoperabilidad incrustado '{0}'. ¿Falta alguna referencia de ensamblado?

By-reference return type 'ref {0}' is not supported. El tipo de valor devuelto por referencia 'ref {0}' no es compatible.

Module name '{0}' stored in '{1}' must match its filename. El nombre de archivo '{0}' almacenado en '{1}' debe coincidir con su nombre de archivo.

Invalid module name: {0} Nombre de módulo no válido: {0}

Invalid '{0}' value: '{1}'. Valor de '{0}' no válido: '{1}'.

AppConfigPath must be absolute. AppConfigPath debe ser absoluto.

Attribute '{0}' from module '{1}' will be ignored in favor of the instance appearing in source El atributo '{0}' del módulo '{1}' se omitirá a favor de la instancia que aparece en el origen

Attribute will be ignored in favor of the instance appearing in source Se ignorará el atributo en beneficio de la instancia que aparece en la fuente

Attribute '{0}' given in a source file conflicts with option '{1}'. El atributo '{0}' indicado en un archivo de origen entra en conflicto con la opción '{1}'.

A fixed buffer may only have one dimension. Un búfer fijo solo puede tener una dimensión.

Referenced assembly '{0}' does not have a strong name. El ensamblado '{0}' al que se hace referencia no tiene un nombre seguro.

Referenced assembly does not have a strong name El ensamblado al que se hace referencia no tiene un nombre seguro

Invalid signature public key specified in AssemblySignatureKeyAttribute. Se especificó una clave pública de firma no válida en AssemblySignatureKeyAttribute.

Type '{0}' exported from module '{1}' conflicts with type declared in primary module of this assembly. El tipo '{0}' exportado del módulo '{1}' entra en conflicto con el tipo declarado en el módulo primario de este ensamblado.

Type '{0}' exported from module '{1}' conflicts with type '{2}' exported from module '{3}'. El tipo '{0}' exportado del módulo '{1}' entra en conflicto con el tipo '{2}' exportado del módulo '{3}'.

Forwarded type '{0}' conflicts with type declared in primary module of this assembly. El tipo reenviado '{0}' entra en conflicto con el tipo declarado en el módulo primario de este ensamblado.

Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' forwarded to assembly '{3}'. El tipo '{0}' reenviado al ensamblado '{1}' entra en conflicto con el tipo '{2}' reenviado al ensamblado '{3}'.

Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' exported from module '{3}'. El tipo '{0}' reenviado al ensamblado '{1}' entra en conflicto con el tipo '{2}' exportado del módulo '{3}'.

Referenced assembly '{0}' has different culture setting of '{1}'. El ensamblado '{0}' al que se hace referencia tiene una configuración de referencia cultural distinta de '{1}'.

Referenced assembly has different culture setting El ensamblaje referenciado tiene una configuración de cultura diferente

Agnostic assembly cannot have a processor specific module '{0}'. El ensamblado válido no puede tener un módulo específico de procesador '{0}'.

Assembly and module '{0}' cannot target different processors. El ensamblado y el módulo '{0}' no pueden tener como destino procesadores distintos.

Referenced assembly '{0}' targets a different processor. El ensamblado '{0}' al que se hace referencia está destinado a un procesador diferente.

Referenced assembly targets a different processor El ensamblador al que se hace referencia tiene como objetivo a otro procesador

Cryptographic failure while creating hashes. Error criptográfico al crear hashes.

Reference to '{0}' netmodule missing. Falta la referencia al netmodule '{0}'.

Module '{0}' is already defined in this assembly. Each module must have a unique filename. El módulo '{0}' ya está definido en este ensamblado. Cada módulo debe tener un nombre de archivo único.

Cannot read config file '{0}' -- '{1}' No se puede leer el archivo de configuración '{0}': '{1}'

Cannot continue since the edit includes a reference to an embedded type: '{0}'. No se puede continuar porque la edición incluye una referencia a un tipo incrustado: '{0}'.

Member '{0}' added during the current debug session can only be accessed from within its declaring assembly '{1}'. Al miembro '{0}' agregado durante la sesión de depuración actual solo se puede acceder desde el ensamblado donde se declara, '{1}'.

Compilation options '{0}' and '{1}' can't both be specified at the same time. No se pueden especificar a la vez las opciones de compilación '{0}' y '{1}'.

Linked netmodule metadata must provide a full PE image: '{0}'. El metadato netmodule vinculado debe proporcionar una imagen PE completa: '{0}'.

/platform:anycpu32bitpreferred can only be used with /t:exe, /t:winexe and /t:appcontainerexe /platform:anycpu32bitpreferred solamente se puede usar con /t:exe, /t:winexe y /t:appcontainerexe

null propagating operator operador de propagación nulo

expression-bodied method método con forma de expresión

expression-bodied property propiedad con forma de expresión

expression-bodied indexer indexador con forma de expresión

auto property initializer inicializador de propiedad automático

byref locals and returns variables locales y devoluciones por referencia

readonly references referencias readonly

ref structs estructuras ref

Compilation (C#): Compilación (C#):

Syntax node is not within syntax tree El nodo de sintaxis no está dentro del árbol de sintaxis

Location must be provided in order to provide minimal type qualification. La ubicación se debe indicar para proporcionar una cualificación de tipo mínima.

SyntaxTreeSemanticModel must be provided in order to provide minimal type qualification. Se debe indicar SyntaxTreeSemanticModel para proporcionar una cualificación de tipo mínima.

Can't reference compilation of type '{0}' from {1} compilation. No se puede hacer referencia a la compilación de tipo '{0}' desde {1} compilación.

Syntax tree already present Ya hay un árbol de sintaxis

Submission can only include script code. El envío solo puede incluir código de script.

Submission can have at most one syntax tree. El envío puede tener, como máximo, un árbol de sintaxis.

tree must have a root node with SyntaxKind.CompilationUnit el árbol debe tener un nodo raíz con SyntaxKind.CompilationUnit

Type argument cannot be null El argumento de tipo no puede ser NULL

Wrong number of type arguments Número de argumentos de tipo incorrecto

Name conflict for name {0} Conflicto de nombre en el nombre {0}

LookupOptions has an invalid combination of options LookupOptions tiene una combinación de opciones no válida

items: must be non-empty elementos: no pueden estar vacíos

Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier or Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier to create identifier tokens. Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier o Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier para crear tokens de identificador.

Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal to create character literal tokens. Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal para crear tokens literales de carácter.

Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal to create numeric literal tokens. Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal para crear tokens literales numéricos.

This method can only be used to create tokens - {0} is not a token kind. Este método solo se puede usar para crear tokens: {0} no es un tipo de token.

Generic parameter is definition when expected to be reference {0} El parámetro genérico es definición cuando se espera que sea la referencia {0}

Called GetDeclarationName for a declaration node that can possibly contain multiple variable declarators. Se ha llamado a GetDeclarationName para un nodo de declaración que puede contener varios declaradores de variables.

tree not part of compilation el árbol no forma parte de la compilación

Position is not within syntax tree with full span {0} La posición no está dentro del árbol de sintaxis con el intervalo completo {0}

The language name '{0}' is invalid. El nombre de idioma '{0}' no es válido.

The language name is invalid El nombre de idioma no es válido

Transparent identifier member access failed for field '{0}' of '{1}'. Does the data being queried implement the query pattern? Error en el acceso del miembro de identificador transparente para el campo '{0}' de '{1}'. ¿Los datos consultados implementan el patrón de consulta?

The parameter has multiple distinct default values. El parámetro tiene varios valores predeterminados distintos.

The field has multiple distinct constant values. El campo tiene varios valores constantes distintos.

Within cref attributes, nested types of generic types should be qualified. Dentro de los atributos cref, se deben calificar los tipos anidados de los tipos genéricos.

Within cref attributes, nested types of generic types should be qualified Entre los atributos cref, los tipos anidados de tipos genéricos deberían ser cualificados

Not a C# symbol. No es un símbolo C#.

Unnecessary using directive. Directiva Using innecesaria.

Unused extern alias. Alias externo sin usar.

Elements cannot be null. Los elementos no pueden ser NULL.

LIB environment variable variable de entorno LIB

/LIB option opción /LIB

/REFERENCEPATH option opción /REFERENCEPATH

directory does not exist el directorio no existe

path is too long or invalid la ruta de acceso es demasiado larga o no es válida

No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options. No se encontró ningún valor para RuntimeMetadataVersion. No se encontró ningún ensamblado que contuviese System.Object ni se especificó ningún valor para RuntimeMetadataVersion a través de las opciones.

No value for RuntimeMetadataVersion found No se encontró ningún valor para RuntimeMetadataVersion

Expected a {0} SemanticModel. Se esperaba un SemanticModel de {0}.

lambda expression expresión lambda

Feature '{0}' is not available in C# 1. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 1. Use la versión de lenguaje {1} u otra superior.

Feature '{0}' is not available in C# 2. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 2. Use la versión de lenguaje {1} u otra superior.

Feature '{0}' is not available in C# 3. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 3. Use la versión de lenguaje {1} u otra superior.

Feature '{0}' is not available in C# 4. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 4. Use la versión de lenguaje {1} u otra superior.

Feature '{0}' is not available in C# 5. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 5. Use la versión de lenguaje {1} u otra superior.

Feature '{0}' is not available in C# 6. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 6. Use la versión de lenguaje {1} u otra superior.

Feature '{0}' is not available in C# 7.0. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 7.0. Use la versión del lenguaje {1} u otra posterior.

'experimental' 'experimental'

Position must be within span of the syntax tree. La posición debe estar dentro del intervalo del árbol de sintaxis.

Syntax node to be speculated cannot belong to a syntax tree from the current compilation. El nodo de sintaxis que se va a especular no puede pertenecer a un árbol de sintaxis de la compilación actual.

Chaining speculative semantic model is not supported. You should create a speculative model from the non-speculative ParentModel. No se puede encadenar el modelo semántico especulativo. Tiene que crear un modelo especulativo desde el modelo principal no especulativo.

Microsoft (R) Visual C# Compiler Compilador de Microsoft (R) Visual C#

{0} version {1} {0} versión {1}

Supported language versions: Versiones de lenguaje admitidas:

'{0}': a class with the ComImport attribute cannot specify field initializers. "{0}": una clase con el atributo ComImport no puede especificar inicializadores de campo.

Local name '{0}' is too long for PDB. Consider shortening or compiling without /debug. El nombre local '{0}' es demasiado largo para PDB. Puede acortar o compilar sin /debug.

Local name is too long for PDB El nombre local es demasiado largo para PDB

Anonymous function converted to a void returning delegate cannot return a value Una función anónima convertida en un delegado que devuelve void no puede devolver un valor

Async lambda expression converted to a 'Task' returning delegate cannot return a value. Did you intend to return 'Task<T>'? Una expresión lambda asincrónica convertida en un delegado que devuelve 'Task' no puede devolver un valor. ¿Intentó devolver 'Task<T>'?

An instance of analyzer {0} cannot be created from {1} : {2}. No se puede crear una instancia de analizador {0} desde {1} : {2}.

An analyzer instance cannot be created No se puede crear una instancia de analizador

The assembly {0} does not contain any analyzers. El ensamblado {0} no contiene ningún analizador.

Assembly does not contain any analyzers El ensamblado no contiene ningún analizador

Unable to load Analyzer assembly {0} : {1} No se puede cargar el ensamblado del analizador {0}: {1}

Unable to load Analyzer assembly No es posible cargar el ensamblaje del analizador

Skipping some types in analyzer assembly {0} due to a ReflectionTypeLoadException : {1}. Omisión de algunos tipos en el ensamblado de analizador {0} por una ReflectionTypeLoadException: {1}.

Error reading ruleset file {0} - {1} Error al leer el archivo de conjunto de reglas {0}: {1}

Error reading debug information for '{0}' Error al leer información de depuración de '{0}'

Operation caused a stack overflow. La operación ha provocado un desbordamiento de pila.

Expected identifier or numeric literal. Se esperaba un identificador o un literal numérico.

Expected identifier or numeric literal Identificador o literal numérico esperado

Only auto-implemented properties can have initializers. Solo las propiedades implementadas automáticamente pueden tener inicializadores.

Auto-implemented properties must have get accessors. Las propiedades implementadas automáticamente deben tener descriptores de acceso get.

Auto-implemented properties must override all accessors of the overridden property. Las propiedades implementadas automáticamente deben invalidar todos los descriptores de acceso de la propiedad invalidada.

Structs without explicit constructors cannot contain members with initializers. Las estructuras sin constructores explícitos no pueden contener miembros con inicializadores.

Cannot emit debug information for a source text without encoding. No se puede emitir información de depuración para un texto de origen sin descodificar.

Block bodies and expression bodies cannot both be provided. No se pueden proporcionar tanto los cuerpos de bloque como los cuerpos de expresión.

Control cannot fall out of switch from final case label ('{0}') El control no puede quedar fuera del modificador de la etiqueta de caso final ('{0}')

Type arguments are not allowed in the nameof operator. Los argumentos de tipo no están permitidos en el nombre del operador.

An expression tree lambda may not contain a null propagating operator. Una expresión lambda de árbol de expresión no puede contener un operador de propagación NULL.

An expression tree lambda may not contain a dictionary initializer. Una expresión lambda de árbol de expresión no puede contener un inicializador de diccionarios.

An extension Add method is not supported for a collection initializer in an expression lambda. No se admite un método Add de extensión para un inicializador de colección en un lambda de expresión.

nameof operator nombre de operador

dictionary initializer inicializador de diccionarios

Missing close delimiter '}' for interpolated expression started with '{'. Falta el delimitador de cierre '}' de la expresión interpolada que empieza por '{'.

A single-line comment may not be used in an interpolated string. Es posible que no se use un comentario de una sola línea en una cadena interpolada.

An expression is too long or complex to compile Una expresión es demasiado larga o compleja para compilarla

Expression does not have a name. La expresión no tiene un nombre.

Sub-expression cannot be used in an argument to nameof. La subexpresión no se puede usar en un argumento de nameof.

An alias-qualified name is not an expression. Un nombre calificado con el alias no es una expresión.

Type parameters are not allowed on a method group as an argument to 'nameof'. Los parámetros de tipo no se permiten en un grupo de método como argumento de "nameof".

SearchCriteria is expected. Se espera SearchCriteria.

Assembly culture strings may not contain embedded NUL characters. Las cadenas de referencia cultural de ensamblado no pueden contener caracteres NULL incrustados.

using static uso de versión estática

interpolated strings cadenas interpoladas

await in catch blocks and finally blocks await en bloques catch y finally

binary literals literales binarios

digit separators separadores de dígitos

local functions funciones locales

A '{0}' character must be escaped (by doubling) in an interpolated string. El carácter '{0}' se debe escapar (duplicándose) en las cadenas interpoladas.

A '{0}' character may only be escaped by doubling '{0}{0}' in an interpolated string. El carácter '{0}' solo se puede escapar duplicando '{0}{0}' en una cadena interpolada.

A format specifier may not contain trailing whitespace. Los especificadores de formato no pueden contener espacios en blanco al final.

Empty format specifier. Especificador de formato vacío.

There is an error in a referenced assembly '{0}'. Hay un error en un ensamblado al que se hace referencia: '{0}'.

Expression or declaration statement expected. Se esperaba una instrucción de expresión o de declaración.

Extension method groups are not allowed as an argument to 'nameof'. Los grupos de métodos de extensión como argumento de 'nameof' no están permitidos.

Alignment value {0} has a magnitude greater than {1} and may result in a large formatted string. El valor de alineación {0} tiene una magnitud superior a {1} y puede dar lugar a una cadena con formato grande.

Unused extern alias Alias externo sin usar

Unnecessary using directive Directiva Using innecesaria

Skip loading types in analyzer assembly that fail due to a ReflectionTypeLoadException Omitir la carga de los tipos con errores en el ensamblado de analizador debido a ReflectionTypeLoadException

Alignment value has a magnitude that may result in a large formatted string El valor de alineación tiene una magnitud que puede dar lugar a una cadena con formato grande

Length of String constant resulting from concatenation exceeds System.Int32.MaxValue. Try splitting the string into multiple constants. La longitud de la constante de cadena resultante de la concatenación supera el valor System.Int32.MaxValue. Pruebe a dividir la cadena en varias constantes.

Tuple must contain at least two elements. Una tupla debe contener al menos dos elementos.

Debug entry point must be a definition of a method declared in the current compilation. El punto de entrada de depuración debe ser una definición de un método declarado en la compilación actual.

#load is only allowed in scripts #load solo se permite en scripts

Cannot use #load after first token in file No se puede usar #load después del primer token del archivo

Could not find file. No se encontró el archivo. File path referenced in source (#load) could not be resolved.

SyntaxTree resulted from a #load directive and cannot be removed or replaced directly. SyntaxTree se obtuvo de una directiva #load y no se puede quitar ni reemplazar directamente.

Source file references are not supported. Las referencias de archivo de origen no son compatibles.

The pathmap option was incorrectly formatted. La opción pathmap no tenía el formato correcto.

Invalid real literal. Literal real no válido.

Auto-implemented properties cannot return by reference Las propiedades implementadas automáticamente no pueden devolver datos por referencia.

Properties which return by reference must have a get accessor Las propiedades que devuelven datos por referencia deben tener un descriptor de acceso get.

Properties which return by reference cannot have set accessors Las propiedades que devuelven datos por referencia no pueden tener descriptores de acceso.

'{0}' must match by reference return of overridden member '{1}' '"{0}" debe coincidir por referencia con el tipo de valor devuelto del miembro invalidado "{1}".

By-reference returns may only be used in methods that return by reference Las devoluciones por referencia solo se pueden usar en métodos que devuelven datos por referencia.

By-value returns may only be used in methods that return by value Las devoluciones por valor solo se pueden usar en métodos que devuelven datos por valor.

The return expression must be of type '{0}' because this method returns by reference La expresión return debe ser de tipo '{0}' porque este método devuelve datos por referencia.

'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}' because it does not have matching return by reference. '"{0}" no implementa el miembro de interfaz "{1}". "{2}" no puede implementar "{1}" porque no tiene un tipo de valor devuelto coincidente por referencia.

The body of '{0}' cannot be an iterator block because '{0}' returns by reference El cuerpo de '{0}' no puede ser un bloque de iteradores porque '{0}' devuelve datos por referencia.

Lambda expressions that return by reference cannot be converted to expression trees Las expresiones lambda que devuelven datos por referencia no se pueden convertir en árboles de expresión.

An expression tree lambda may not contain a call to a method, property, or indexer that returns by reference Un lambda de árbol de expresión no puede contener una llamada a un método, una propiedad o un indexador que devuelva datos por referencia.

An expression cannot be used in this context because it may not be passed or returned by reference No se puede usar una expresión en este contexto porque no se puede pasar ni devolver por referencia.

Cannot return '{0}' by reference because it was initialized to a value that cannot be returned by reference No se puede devolver '{0}' por referencia porque se inicializó con un valor que no se puede devolver por referencia.

Cannot return by reference a member of '{0}' because it was initialized to a value that cannot be returned by reference No se puede devolver por referencia un miembro de '{0}' porque se inicializó con un valor que no se puede devolver por referencia.

Cannot return '{0}' by reference because it is read-only {0}' no se puede devolver por referencia porque es de solo lectura.

Cannot return the range variable '{0}' by reference No se puede devolver por referencia la variable de rango '{0}'.

Cannot return '{0}' by reference because it is a '{1}' {0}' no se puede devolver por referencia porque es un '{1}'.

Cannot return fields of '{0}' by reference because it is a '{1}' Los campos de '{0}' no se pueden devolver por referencia porque es un '{1}'.

A readonly field cannot be returned by writable reference No se puede devolver un campo de solo lectura por referencia grabable.

A static readonly field cannot be returned by writable reference No se puede devolver un campo estático de solo lectura por referencia grabable.

Members of readonly field '{0}' cannot be returned by writable reference Los miembros del campo de solo lectura "{0}" no se pueden devolver por referencia grabable.

Fields of static readonly field '{0}' cannot be returned by writable reference Los campos del campo estático de solo lectura "{0}" no se pueden devolver por referencia grabable.

Cannot return a parameter by reference '{0}' because it is not a ref or out parameter No se pude devolver por referencia un parámetro '{0}' porque no es de tipo ref o out.

Cannot return by reference a member of parameter '{0}' because it is not a ref or out parameter No se puede devolver un miembro del parámetro "{0}" por referencia, porque no es un parámetro out o ref.

Cannot return local '{0}' by reference because it is not a ref local No se puede devolver por referencia la variable local '{0}' porque no es de tipo ref.

Cannot return a member of local '{0}' by reference because it is not a ref local No se puede devolver por referencia un miembro de la variable local '{0}' porque no es una variable local de tipo ref.

Struct members cannot return 'this' or other instance members by reference Los miembros de struct no pueden devolver 'this' ni otros miembros de instancia por referencia.

Expression cannot be used in this context because it may indirectly expose variables outside of their declaration scope No se puede usar una expresión en este contexto porque puede exponer variables indirectamente fuera de su ámbito de declaración.

Cannot use local '{0}' in this context because it may expose referenced variables outside of their declaration scope No se puede usar un elemento "{0}" local en este contexto porque puede exponer variables a las que se hace referencia fuera de su ámbito de declaración.

Cannot use a result of '{0}' in this context because it may expose variables referenced by parameter '{1}' outside of their declaration scope No se puede usar un resultado de "{0}" en este contexto porque puede exponer variables a las que el parámetro "{1}" hace referencia fuera de su ámbito de declaración.

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 No se puede usar un miembro del resultado de "{0}" en este contexto porque puede exponer variables a las que el parámetro "{1}" hace referencia fuera de su ámbito de declaración.

This combination of arguments to '{0}' is disallowed because it may expose variables referenced by parameter '{1}' outside of their declaration scope No se permite esta combinación de argumentos para "{0}" porque puede exponer variables a las que el parámetro "{1}" hace referencia fuera de su ámbito de declaración.

Branches of a ref conditional operator cannot refer to variables with incompatible declaration scopes Las ramas de un operador condicional ref no pueden hacer referencia a variables con ámbitos de declaración incompatibles

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 El resultado de una expresión stackalloc de tipo "{0}" no se puede usar en este contexto porque puede exponerse fuera del método contenedor.

Cannot initialize a by-value variable with a reference No se puede inicializar una variable por valor con una referencia.

Cannot initialize a by-reference variable with a value No se puede inicializar una variable por referencia con un valor.

The expression must be of type '{0}' because it is being assigned by reference La expresión debe ser de tipo '{0}' porque se asigna por referencia.

A declaration of a by-reference variable must have an initializer La declaración de una variable por referencia debe tener un inicializador.

Cannot use ref local '{0}' inside an anonymous method, lambda expression, or query expression No se puede usar la variable local de tipo ref '{0}' dentro de un método anónimo, una expresión lambda o una expresión de consulta.

Iterators cannot have by-reference locals Los iteradores no pueden tener variables locales por referencia.

Async methods cannot have by-reference locals Los métodos asincrónicos no pueden tener variables locales por referencia.

'await' cannot be used in an expression containing a call to '{0}' because it returns by reference 'No se puede usar 'await' en una expresión que contiene una llamada a '{0}' porque devuelve datos por referencia.

'await' cannot be used in an expression containing a ref conditional operator 'No se puede usar "await" en una expresión que contiene un operador condicional ref.

Both conditional operator values must be ref values or neither may be a ref value Ambos valores de operador condicional deben ser valores ref o ninguno de ellos debe ser un valor ref.

The expression must be of type '{0}' to match the alternative ref value La expresión debe ser de tipo "{0}" para que coincida con el valor ref alternativo.

An expression tree may not contain a reference to a local function Un árbol de expresión no puede contener una referencia a una función local.

Cannot pass argument with dynamic type to params parameter '{0}' of local function '{1}'. No se puede pasar un argumento de tipo dinámico al parámetro params '{0}' de la función local '{1}'.

Syntax tree should be created from a submission. El árbol de sintaxis debe crearse desde un envío.

Combined length of user strings used by the program exceeds allowed limit. Try to decrease use of string literals. La longitud combinada de las cadenas de usuario que el programa utiliza supera el límite permitido. Intente disminuir el uso de literales de cadena.

It is not legal to use nullable type '{0}?' in a pattern; use the underlying type '{0}' instead. It is not legal to use nullable type '{0}?' in a pattern; use the underlying type '{0}' instead.

An error occurred while writing the output file: {0}. Error al escribir en el archivo de salida: {0}.

Tuple element names must be unique. Los nombres de elemento de tupla deben ser únicos.

Tuple element name '{0}' is only allowed at position {1}. El nombre '{0}' del elemento de tupla solo se permite en la posición {1}.

Tuple element name '{0}' is disallowed at any position. El nombre '{0}' del elemento de tupla no se permite en ninguna posición.

Member '{0}' was not found on type '{1}' from assembly '{2}'. El miembro '{0}' no se encontró en el tipo '{1}' del ensamblado '{2}'.

tuples tuplas

No suitable 'Deconstruct' instance or extension method was found for type '{0}', with {1} out parameters and a void return type. No se encontró un método de extensión o instancia "Deconstruct" adecuado para el tipo "{0}", con {1} parámetros out y un tipo de valor devuelto void.

Deconstruct assignment requires an expression with a type on the right-hand-side. La asignación de deconstrucción requiere una expresión con un tipo en el lado derecho.

The switch expression must be a value; found '{0}'. La expresión switch debe ser un valor. Se encontró {0}.

An expression of type '{0}' cannot be handled by a pattern of type '{1}'. Un patrón de tipo "{1}" no puede controlar una expresión de tipo "{0}".

Attribute '{0}' is ignored when public signing is specified. El atributo "{0}" se ignora cuando se especifica la firma pública.

Attribute is ignored when public signing is specified. El atributo se omite cuando se especifica la firma pública.

Option '{0}' must be an absolute path. La opción '{0}' debe ser una ruta de acceso absoluta.

Tuple with {0} elements cannot be converted to type '{1}'. La tupla con {0} elementos no se puede convertir al tipo '{1}'.

out variable declaration declaración de variable out

Reference to an implicitly-typed out variable '{0}' is not permitted in the same argument list. No se permite la referencia a una variable out con tipo implícito '{0}' en la misma lista de argumentos.

Cannot infer the type of implicitly-typed out variable '{0}'. No se puede inferir el tipo de variable out con tipo implícito '{0}'.

Cannot infer the type of implicitly-typed deconstruction variable '{0}'. No se puede inferir el tipo de variable de desconstrucción con tipo implícito '{0}'.

Cannot infer the type of implicitly-typed discard. No se puede deducir el tipo de descarte con tipo implícito.

Cannot deconstruct a tuple of '{0}' elements into '{1}' variables. No se puede deconstruir una tupla de '{0}' elementos en '{1}' variables.

Cannot deconstruct dynamic objects. No se pueden deconstruir los objetos dinámicos.

Deconstruction must contain at least two variables. La desconstrucción debe contener al menos dos variables.

The tuple element name '{0}' is ignored because a different name or no name is specified by the target type '{1}'. No se tiene en cuenta el nombre de elemento de tupla "{0}" porque el tipo de destino "{1}" ha especificado otro nombre o no ha especificado ninguno.

The tuple element name is ignored because a different name or no name is specified by the assignment target. No se tiene en cuenta el nombre de elemento de tupla porque el destino de la asignación ha especificado otro nombre o no ha especificado ninguno.

Predefined type '{0}' must be a struct. El tipo '{0}' predefinido debe ser un elemento struct.

'new' cannot be used with tuple type. Use a tuple literal expression instead. '"new" no se puede usar con un tipo de tupla. Use una expresión literal de tupla en su lugar.

Deconstruction 'var (...)' form disallows a specific type for 'var'. El formato de desconstrucción 'var (...)' no permite especificar un tipo determinado 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? No se puede definir una clase o un miembro que utiliza tuplas porque no se encuentra el tipo requerido de compilador '{0}'. ¿Falta alguna referencia?

Cannot reference 'System.Runtime.CompilerServices.TupleElementNamesAttribute' explicitly. Use the tuple syntax to define tuple names. No se puede hacer referencia a 'System.Runtime.CompilerServices.TupleElementNamesAttribute' explícitamente. Use la sintaxis de tupla para definir nombres de tupla.

An expression tree may not contain an out argument variable declaration. Un árbol de expresión no puede contener una declaración de variable de argumento out.

An expression tree may not contain a discard. Un árbol de expresión no puede contener un descarte.

An expression tree may not contain an 'is' pattern-matching operator. Un árbol de expresión no puede contener un operador de coincidencia de patrones 'is'.

An expression tree may not contain a tuple literal. Un árbol de expresión no puede contener un literal de tupla.

An expression tree may not contain a tuple conversion. Un árbol de expresión no puede contener una conversión de tupla.

/sourcelink switch is only supported when emitting PDB. El modificador /sourcelink solo se admite al emitir PDB.

/embed switch is only supported when emitting a PDB. El modificador /embed solo se admite al emitir un PDB.

Invalid instrumentation kind: {0} Clase de instrumentación no válida: {0}

The syntax 'var (...)' as an lvalue is reserved. La sintaxis 'var (...)' como valor L está reservada.

{ or ; or => expected Se esperaba { o ; o =>.

A throw expression is not allowed in this context. No se permite una expresión throw en este contexto.

A deconstruction cannot mix declarations and expressions on the left-hand-side. Una deconstrucción no puede mezclar declaraciones y expresiones en el lado izquierdo.

A declaration is not allowed in this context. No se permite una declaración en este contexto.

A foreach loop must declare its iteration variables. Un bucle foreach debe declarar sus variables de iteración.

Tuple element names are not permitted on the left of a deconstruction. No se permiten nombres de elementos de tupla en el lado izquierdo de una deconstrucción.

To cast a negative value, you must enclose the value in parentheses. Para convertir un valor negativo, el valor debe ir entre paréntesis

An expression tree may not contain a throw-expression. Un árbol de expresión no puede contener una expresión throw.

Invalid assembly name: {0} Nombre de ensamblado no vá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 que el tipo "{0}" se utilice como AsyncMethodBuilder para el tipo "{1}", su propiedad Task debe devolver el tipo "{1}" en lugar del tipo "{2}".

Attributes are not allowed on local function parameters or type parameters No se permiten atributos en los parámetros de tipo o parámetros de funciones locales.

Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'. El módulo "{0}" del ensamblado "{1}" va a reenviar el tipo "{2}" a varios ensamblados: "{3}" y "{4}".

It is not legal to use the type 'dynamic' in a pattern. No se puede utilizar el tipo "dynamic" en un patrón.

Provided documentation mode is unsupported or invalid: '{0}'. El modo de documentación proporcionado no se admite o no es válido: "{0}".

Provided source code kind is unsupported or invalid: '{0}' El tipo de código fuente proporcionado no se admite o no es válido: "{0}"

Provided language version is unsupported or invalid: '{0}'. La versión de lenguaje proporcionada no se admite o no es válida: "{0}".

Invalid name for a preprocessing symbol; '{0}' is not a valid identifier Nombre no válido para un símbolo de preprocesamiento; "{0}" no es un identificador válido

Feature '{0}' is not available in C# 7.1. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 7.1. Use la versión de lenguaje {1} u otra superior.

Feature '{0}' is not available in C# 7.2. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 7.2. Use la versión {1} del lenguaje o una posterior.

Specified language version '{0}' cannot have leading zeroes La versión de lenguaje especificada "{0}" no puede tener ceros al principio

A value of type 'void' may not be assigned. No se puede asignar un valor de tipo "void".

'{0}' is for evaluation purposes only and is subject to change or removal in future updates. '"{0}" se incluye con fines de evaluación y está sujeto a cambios o a que se elimine en próximas actualizaciones.

Type is for evaluation purposes only and is subject to change or removal in future updates. Este tipo se incluye solo con fines de evaluación y está sujeto a cambios o a que se elimine en próximas actualizaciones.

Compiler version: '{0}'. Language version: {1}. Versión de compilador: "{0}". Versión de lenguaje: {1}.

async main async main

Tuple element name '{0}' is inferred. Please use language version {1} or greater to access an element by its inferred name. El nombre "{0}" del elemento de tupla se ha deducido. Use la versión {1} del lenguaje, o una versión posterior, para acceder a un elemento por el nombre deducido.

A tuple may not contain a value of type 'void'. Una tupla no puede contener un valor de tipo "void".

A void or int returning entry point cannot be async Un punto de entrada de devolución void o int no puede ser asincrónico

An expression of type '{0}' cannot be handled by a pattern of type '{1}' in C# {2}. Please use language version {3} or greater. Un patrón de tipo "{1}" no puede controlar una expresión de tipo "{0}" en C# {2}. Use la versión {3} del lenguaje o una versión posterior.

The local function '{0}' is declared but never used La función local "{0}" se declara pero nunca se usa.

Local function is declared but never used La función local se declara pero nunca se usa

Local function '{0}' must declare a body because it is not marked 'static extern'. '"{0}" es una función local y, por lo tanto, siempre debe tener un cuerpo.

Unable to read debug information of method '{0}' (token 0x{1:X8}) from assembly '{2}' No se puede leer la información de depuración del método "{0}" (token 0x{1:X8}) desde el ensamblado "{2}".

{0} is not a valid C# conversion expression {0} no es una expresión de conversión de C# válida.

Cannot pass argument with dynamic type to generic local function '{0}' with inferred type arguments. No se puede pasar un argumento con tipo dinámico a función local genérica "{0}" con argumentos de tipo inferido.

leading digit separator separador de dígito inicial

Do not use '{0}'. This is reserved for compiler usage. No use "{0}". Está reservado para uso del compilador.

The type name '{0}' is reserved to be used by the compiler. El nombre de tipo "{0}" está reservado para uso del compilador.

The first parameter of the 'in' extension method '{0}' must be a concrete (non-generic) value type. El primer parámetro del método de extensión "in" "{0}" debe ser un tipo de valor concreto (no genérico).

Instance fields of readonly structs must be readonly. Los campos de instancia de las estructuras readonly deben ser readonly.

Auto-implemented instance properties in readonly structs must be readonly. Las propiedades de instancia implementadas automáticamente en estructuras readonly deben ser readonly.

Field-like events are not allowed in readonly structs. No se admiten eventos de tipo campo en estructuras readonly.

ref extension methods métodos de extensión ref

Conversion of a stackalloc expression of type '{0}' to type '{1}' is not possible. La conversión de una expresión stackalloc del tipo "{0}" al tipo "{1}" no es posible.

The first parameter of a 'ref' extension method '{0}' must be a value type or a generic type constrained to struct. El primer parámetro de un método de extensión "ref" "{0}" debe ser un tipo de valor o un tipo genérico restringido a struct.

An in parameter cannot have the Out attribute. Un parámetro In no puede tener un atributo Out.

{0} is not a valid C# compound assignment operation {0} no es una operación de asignación compuesta de C# válida

Filter expression is a constant 'false', consider removing the catch clause La expresión de filtro es una constante "false", considere quitar la cláusula catch

Filter expression is a constant 'false' La expresión de filtro es una constante "false"

Filter expression is a constant 'false', consider removing the try-catch block La expresión de filtro es una constante "false", considere quitar el bloqueo try-catch

Filter expression is a constant 'false'. La expresión de filtro es una constante "false".

__arglist cannot have an argument of void type __arglist no puede tener un argumento de tipo void

A conditional expression cannot be used directly in a string interpolation because the ':' ends the interpolation. Parenthesize the conditional expression. Una expresión condicional no se puede utilizar directamente en una interpolación de cadenas porque ":" finaliza la interpolación. Ponga la expresión condicional entre paréntesis.

Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute on a property No utilice el atributo "System.Runtime.CompilerServices.FixedBuffer" en una propiedad.

Feature '{0}' is not available in C# 7.3. Please use language version {1} or greater. La característica "{0}" no está disponible en C# 7.3. Use la versión {1} del lenguaje o una posterior.

Field-targeted attributes on auto-properties are not supported in language version {0}. Please use language version {1} or greater. Los atributos destinados al campo en las propiedades automáticas no se admiten en la versión del lenguaje {0}. Use la versión del lenguaje {1} o una superior.

Field-targeted attributes on auto-properties are not supported in this version of the language. Los atributos destinados al campo en las propiedades automáticas no se admiten en esta versión del lenguaje.

async streams flujos asincrónicos

'{0}': type used in an asynchronous using statement must be implicitly convertible to 'System.IAsyncDisposable' or implement a suitable 'DisposeAsync' method. "{0}": el tipo usado en una instrucción using asincrónica debe poder convertirse de forma implícita en "System.IAsyncDisposable" o implementar un método "DisposeAsync" adecuado.

Asynchronous foreach requires that the return type '{0}' of '{1}' must have a suitable public 'MoveNextAsync' method and public 'Current' property Una instrucción foreach asincrónica requiere que el tipo de valor devuelto “{0}” de “{1}” tenga un método “MoveNextAsync” público y una propiedad “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 Una instrucción foreach asincrónica no puede funcionar en variables de tipo “{0}” porque implementa varias creaciones de instancias de “{1}”; pruebe a convertirla en una creación de una instancia de interfaz específica.

Interfaces cannot contain conversion, equality, or inequality operators Las interfaces no pueden contener operadores de conversión, igualdad o desigualdad

Target runtime doesn't support default interface implementation. El tiempo de ejecución de destino no admite la implementación de interfaz predeterminada.

'{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support default interface implementation. "{0}" no puede implementar el miembro de interfaz "{1}" en el tipo "{2}" porque el entorno de ejecución de destino no admite la implementación de interfaz predeterminada.

The modifier '{0}' is not valid for this item in C# {1}. Please use language version '{2}' or greater. El modificador "{0}" no es válido para este elemento en C# {1}. Use la versión de lenguaje "{2}" o una posterior.

'{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member. "{0}" no implementa el miembro de interfaz "{1}". "{2}" no puede implementar implícitamente un miembro que no sea público.

Interface member '{0}' does not have a most specific implementation. Neither '{1}', nor '{2}' are most specific. El miembro de interfaz "{0}" no tiene una implementación más específica. Ni "{1}" ni "{2}" son los más específicos.

'{0}' cannot implement interface member '{1}' in type '{2}' because feature '{3}' is not available in C# {4}. Please use language version '{5}' or greater. "{0}" no puede implementar el miembro de interfaz "{1}" en el tipo "{2}" porque la característica "{3}" no está disponible en C# {4}. Use la versión de idioma "{5}" o una posterior.