mono 2.1 - en to es translation catalogue (102 entries)

en: #endregion directive expected
es: Esperaba la directiva `#endregion'

en: A generic type cannot derive from `{0}' because it is an attribute class
es: Los tipos genericos no pueden derivad de `{0} ya que es un atributo

en: A member `{0}' is already defined. Rename this member or use different parameter types
es: El miembro `{0} ya ha sido definido.   Renombre este miembro o use tipos de parámetro distintos

en: A member `{0}' marked as override cannot be marked as new or virtual
es: El miembro `{0}' está usa `override' y no puede usar `new' o `virtual'

en: A static member `{0}' cannot be marked as override, virtual or abstract
es: El miembro estático `{0}' no puede ser marcado con override, virtual o abstract

en: An anonymous method cannot be converted to an expression tree
es: Los métodos anónimos no pueden ser convertidos a árboles de expresiones

en: An expression tree cannot contain an anonymous method expression
es: Un árbol de expresiones no puede contener una expresión que sea una método anónimo

en: An expression tree cannot contain an assignment operator
es: Un árbol de expresiones no puede contener un operador de asignación

en: Anonymous methods and lambda expressions cannot be used in the current context
es: Los métodos anónimos y las expresiones lambdas no pueden ser usados en este contexto

en: Attribute `System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes
es: El atributo `System.Diagnostics.ConditionalAttribute' solamente es válido en métodos o en clases derivadas de System.Attribute

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

en: Cannot apply attribute class `{0}' because it is abstract
es: No es posible aplicar el atributo `{0}' ya que es abstracto

en: Cannot convert `{0}' to an expression tree of non-delegate type `{1}'
es: No es posible convertir `{0}' a un árbol de expresiónáéíóú de tipo `{1}; ya que no es un tipo de delegado

en: Cannot convert `{0}' to non-delegate type `{1}'
es: No es posible convertir `{0}' a un un tipo que no es un delegado `{1}'

en: Cannot define or undefine preprocessor symbols after first token in file
es: No es posible definir nuevos símbolos para el preprocesador o elimiar las definiciones existentes después del primer tóken del archivo

en: Cannot specify the `DefaultMember' attribute on type containing an indexer
es: No puede especificar el atributo `DefaultMember' en un tipo que contiene un indexador

en: Cannot take the address of, get the size of, or declare a pointer to a managed type `{0}'
es: No es posible obtener la dirección, el tamaño o declarar un apuntador a un tipo gestionado `{0}'

en: Circular base class dependency involving `{0}' and `{1}'
es: Dependencia circular en la clase base involucrando `{0}' y `{1}'

en: Delegate `{0}' does not take `{1}' arguments
es: El delegado `{0} no toma {1} argumentos

en: Division by constant zero
es: División por cero (con una constante)

en: Do not use `{0}' directly. Use parameter modifier `this' instead
es: No use `{0}' directamente.   Use el modificador de parámetro `this' en su lugar

en: End-of-file found, '*/' expected
es: El archivo se terminó, y esperaba encontrar un `*/'

en: Error during emitting `{0}' attribute. The reason is `{1}'
es: Error al emitir el atributo `{0}'.   La razón es `{1}'

en: Expected `#endif' directive
es: Esperaba la directiva `#endif'

en: Foreach statement cannot operate on a `{0}'
es: El mandato `foreach' no puede operar en un `{0}'

en: Identifier expected: {0}
es: Esperaba un identificador: {0}.

en: Identifier too long (limit is 512 chars)
es: El identificador es demasiado grande (el límite son 512 caracteres)

en: Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'
es: Accesibilidad inconsistente: la clase base `{0}' es menos accessible que la clase `{1}'

en: Inconsistent accessibility: base interface `{0}' is less accessible than interface `{1}'
es: Accesibilidad inconsistente: la interface base `{0}' es menos accessible que la interface `{1}'

en: Inconsistent accessibility: parameter type `{0}' is less accessible than delegate `{1}'
es: Accesibilidad inconsistente: la interface base `{0}' es menos accessible que el delegado `{1}'

en: Inconsistent accessibility: parameter type `{0}' is less accessible than indexer `{1}'
es: Accesibilidad inconsistente: la interface base `{0}' es menos accessible que el indexador `{1}'

en: Inconsistent accessibility: parameter type `{0}' is less accessible than operator `{1}'
es: Accesibilidad inconsistente: el tipo del parámetro `{0}' es menos accessible que el operador `{1}'

en: Inherited interface `{0}' causes a cycle in the interface hierarchy of `{1}'
es: La interface heredada `{0}' produce un ciclo en la jerarquía de la interface `{1}'

en: Invalid number
es: Número inválido

en: Invalid preprocessor directive
es: Directiva inválida para el pre-procesador.

en: Keyword, identifier, or string expected after verbatim specifier: @
es: Esperaba una palabra clave, un identificador o una cadena después del especificador '@' (al pie de la letra)

en: Newline in constant
es: Hay un carácter nueva-linea en la constante

en: Parameter `{0}' is declared as type `{1}' but should be `{2}'
es: El parámetro `{0}' está declarado con `{1}' pero debería de ser `{2}'

en: Parameter `{0}' must be declared with the `{1}' keyword
es: El parámetro `{0}' debe de ser declarado con la palabra reservada `{1}'

en: Parameter `{0}' should not be declared with the `{1}' keyword
es: El parámetro `{0}' no debe ser ser declarado con la palabra reservada `{1}'

en: Partial declarations of `{0}' have conflicting accessibility modifiers
es: Las varias declaraciones parciales de `{0} tienen modificadores de accesibilidad en conflicto

en: Partial declarations of `{0}' have inconsistent constraints for type parameter `{1}'
es: Las declaraciones parciales de `{0}' tienen limitaciones inconsistentes para el tipo parametrizado `{1}'

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

en: Partial declarations of `{0}' must have the same type parameter names in the same order
es: Las declaraciones parciales de `{0} deben de tener los mismos nombres de parámetros en el mismo órden.

en: Partial declarations of `{0}' must not specify different base classes
es: Las declaraciones parciales de `{0}' no deben de especificar clases bases distintas

en: Preprocessor directives must appear as the first non-whitespace character on a line
es: Las directivas del pre-procesador deben aparecer como el primer carácter en la línea (que no sea un espacio en blanco)

en: Single-line comment or end-of-line expected
es: Esperaba un comentario de una sola línea o el final de archivo

en: Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object
es: La clase estática `{0}' no puede derivarse del tipo `{1}'.   Las clases estáticas deben derivar de `System.Object'

en: Static class `{0}' cannot implement interfaces
es: Las clases estáticas no pueden implementar interfaces (`{0}')

en: The Guid attribute must be specified with the ComImport attribute
es: El atributo Guid debe de ser especificado junto con el atributo ComImport

en: The `partial' modifier can be used only immediately before `class', `struct', `interface', or `void' keyword
es: El modificador `partial' solamente puede ser utilizado antes de `class', `struct', `interface' o la palabra clave `void'

en: The abstract method `{0}' cannot be marked virtual
es: El método abstracto `{0} no puede ser marcado como virtual

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

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

en: The compiler required member `{0}.{1}{2}' could not be found or is inaccessible
es: El compilador no encuentra el miembro `{0}.{1}{2}' o no es accessible

en: The line number specified for #line directive is missing or invalid
es: Falta el número de linea especificado en la directiva #line o el número es inválido

en: The operation overflows at compile time in checked mode
es: La operación produjo un sobreflujo durante la compilación en el modo verificado (-checked)

en: The operator `{0}' requires a matching operator `{1}' to also be defined
es: El operador `{0}' require que el operador correspondiente `{1}' también sea definido

en: The predefined type `{0}.{1}' is not declared correctly
es: El tipo predefinido `{0}.{1}' fue incorrectamente declarado

en: The predefined type `{0}.{1}' is not defined or imported
es: El tipo predefinido `{0}.{1}' no está definido o no ha sido importado

en: Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type
es: Hay dos indexadores con nombres distintos;   El atributo IndexerName debe ser usado con el mismo nombre en todos los indexadores dentro de un tipo

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

en: Type parameter `{0}' has same name as containing type, or method
es: El tipo parametrizado `{0}' tiene el mimo nombre que el tipo contenedor, o el método

en: Unexpected processor directive ({0})
es: Directiva inválida para el pre-procesador ({0}).

en: Unrecognized escape sequence
es: Secuencia de escape no reconocida

en: Unrecognized escape sequence `\{0}'
es: Secuencia de escape no reconocida: `\\{0}'

en: Unterminated string literal
es: La literal de texto no tiene fin

en: Wrong preprocessor directive
es: La directiva del pre-procesador es errónea

en: `{0}' cannot be both abstract and sealed
es: `{0}'' no puede ser tanto sellado como abstracto

en: `{0}' cannot be both extern and abstract
es: `{0}' no puede ser tanto externo como abstracto

en: `{0}' cannot be sealed because it is not an override
es: `{0}' no puede sellarse por que no es una sobrecarga

en: `{0}' cannot derive from special class `{1}'
es: `{0}' no es posible derivad de la clase especial `{1}'

en: `{0}' cannot implement both `{1}' and `{2}' because they may unify for some type parameter substitutions
es: `{0}' no es posible implementar tanto `{1}' como `{2}' por que se pueden unificar en algunos casos

en: `{0}' hides inherited abstract member `{1}'
es: `{0}' esconde el miembro abstracto heredado `{1}'

en: `{0}' is abstract but it is declared in the non-abstract class `{1}'
es: `{0}' es abstracto pero ha sido declarado dentro de una clase que no es abstracta (`{1}')

en: `{0}' is already listed in interface list
es: `{0}' ya está listado en la lista de interfaces

en: `{0}' is marked as an override but no suitable {1} found to override
es: `{0}' está marcado como una sobreescritura pero no es posible encontrar {1} para usar override

en: `{0}': An anonymous type cannot have multiple properties with the same name
es: `{0}' An tipo anónimo no puede tener multiples propiedades con el mismo nombre

en: `{0}': Base class `{1}' must be specified as first
es: `{0}': la clase base `{1}' tiene que ser especificada primero

en: `{0}': Cannot derive from static class `{1}'
es: `{0}': no es posible derivar de una clase estática (`{1}')

en: `{0}': Classes cannot have multiple base classes (`{1}' and `{2}')
es: `{0}': las clases no pueden tener múltiples clases base (`{1}' y `{2}')

en: `{0}': Extension methods must be declared static
es: `{0}' Los métodos de extensión deben de ser estáticos

en: `{0}': Static classes cannot contain destructor
es: `{0}': las clases estáticas no pueden contener un destructor

en: `{0}': Static classes cannot contain user-defined operators
es: `{0}': las clases estáticas no pueden contener operadores definidos por el usuario

en: `{0}': Static classes cannot have instance constructors
es: `{0}': las clases estáticas no pueden tener constructores de instancias

en: `{0}': Structs cannot have instance field initializers
es: `{0}': las estructuras no pueden tener inicializadores de campos en instancias

en: `{0}': a class cannot be both static and sealed
es: `{0}': una clase no puede estar sellada y ser estática al mismo tiempo

en: `{0}': an abstract class cannot be sealed or static
es: `{0}': una clase abstracta no puede estar sellada o ser estática

en: `{0}': cannot declare indexers in a static class
es: `{0}': no es posible declarar indexadores en una clase estática

en: `{0}': cannot declare instance members in a static class
es: `{0}'L no es posible declarar miembros de instancia en una clase estática

en: `{0}': cannot override because `{1}' is not a method
es: `{0}': no es posible sobreescribir `{1}' ya que no es un método

en: `{0}': cannot override because `{1}' is not a property
es: `{0}': no es posible sobreescribir `{1}' ya que no es una propiedad

en: `{0}': cannot override because `{1}' is not an event
es: `{0}': no es posible sobreescribir ya que `{1}' no es un evento

en: `{0}': cannot override inherited member `{1}' because it is not marked virtual, abstract or override
es: `{0}': no es posible sobreescribir el miembro heredado `{1}' ya que este no está marcado con `virtual', `abstract' u `override'

en: `{0}': cannot override inherited member `{1}' because it is sealed
es: `{0}': no es posible sobreescribir el miembro heredado `{1}' ya que este está sellado

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

en: `{0}': explicit interface declaration can only be declared in a class or struct
es: `{0}': las declaraciones explícitas de interfaces solamente pueden ser declaradas en una clase o estructura

en: `{0}': is not an attribute class
es: `{0}' no es una clase atributo

en: `{0}': member names cannot be the same as their enclosing type
es: `{0}': los nombres de los miembros no pueden ser el mismo que el del tipo contenedor

en: `{0}': return type must be `{1}' to match overridden member `{2}'
es: `{0}': El tipo de regreso debe de ser `{1}' para qu ecorresponda con el miembro sobreescrito `{2}'

en: `{0}': type must be `{1}' to match overridden member `{2}'
es: `{0}': el tipo debe de ser `{1}' para que corresponda con el miembro sobreescrito `{2}'

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