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. Konstruovaný obecný typ nejde vytvořit z jiného konstruovaného obecného typu. Cannot create constructed generic type from non-generic type. Konstruovaný obecný typ nejde vytvořit z jiného než obecného typu. '{0}': abstract event cannot use event accessor syntax {0}: abstraktní událost nemůže používat syntaxi přístupového objektu události. '&' 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. Pokud chcete pro interpolovaný doslovný řetězec použít @$ místo $@, použijte verzi jazyka {0} nebo vyšší. 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 Operátor {0} nejde použít pro default a operand typu {1}, protože se jedná o parametr typu, který není znám jako odkazový typ. Cannot use a nullable reference type in object creation. K vytvoření objektu nejde použít typ odkazu s možnou hodnotou null. Element names are not permitted when pattern-matching via 'System.Runtime.CompilerServices.ITuple'. Názvy elementů nejsou povolené při porovnávání vzorů přes System.Runtime.CompilerServices.ITuple. It is not legal to use nullable reference type '{0}?' in an as expression; use the underlying type '{0}' instead. Ve výrazu as se nepovoluje použití typu odkazu s možnou hodnotou null {0}?; místo toho použijte základní typ {0}. 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. Atribut {0} není platný pro přístupové objekty události. Je platný jenom pro deklarace {1}. Auto-implemented property '{0}' cannot be marked 'readonly' because it has a 'set' accessor. Automaticky implementovanou vlastnost {0} nelze označit modifikátorem readonly, protože má přístupový objekt set. Auto-implemented 'set' accessor '{0}' cannot be marked 'readonly'. Automaticky implementovaný přístupový objekt set {0} nelze označit modifikátorem 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}' Asynchronní příkaz foreach nejde použít pro proměnné typu {0}, protože {0} neobsahuje vhodnou veřejnou definici instance pro {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'? Asynchronní příkaz foreach nejde použít pro proměnné typu {0}, protože {0} neobsahuje veřejnou definici instance pro {1}. Měli jste v úmyslu foreach místo await foreach? Cannot use a collection of dynamic type in an asynchronous foreach V asynchronním příkazu foreach nejde použít kolekce dynamického typu. 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' Neplatná možnost {0} pro /nullable. Je třeba použít disable, enable, warnings nebo annotations. The typeof operator cannot be used on a nullable reference type Operátor typeof nejde použít na typ odkazů s možnou hodnotou 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}'. Neplatný operand pro porovnávací vzorek. Vyžaduje se hodnota, ale nalezeno: {0}. Records may only inherit from object or another record Records may only inherit from object or another record 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}'. Chyba syntaxe příkazového řádku: {0} není platná hodnota možnosti {1}. Hodnota musí mít tvar {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 '{0}' as a {1} type on a method attributed with 'UnmanagedCallersOnly'. Cannot use '{0}' as a {1} type on a method attributed with 'UnmanagedCallersOnly'. 1 is the localized word for 'parameter' or 'return'. UnmanagedCallersOnly is not localizable. 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 nemůže mít argument předávaný pomocí in nebo 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}' Parametr typu {1} má omezení unmanaged, takže není možné používat {1} jako omezení pro {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. Výraz typu {0} nelze zpracovat vzorem typu {1}. Použijte prosím verzi jazyka {2} nebo vyšší, aby odpovídala otevřenému typu se vzorem konstanty. 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}'. Název {0} neodpovídá příslušnému parametru Deconstruct {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. Typ {0} nemůže být vložený, protože má neabstraktní člen. Zvažte nastavení vlastnosti Vložit typy spolupráce na hodnotu false. There is no target type for the default literal. Není k dispozici žádný cílový typ pro výchozí literál. 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 '_'. Výchozí literál default není platný jako vzor. Podle potřeby použijte jiný literál (například 0 nebo null). Pokud chcete, aby odpovídalo vše, použijte vzor discard „_“. 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 '_'. Tento vzor discard není povolený jako návěstí příkazu case v příkazu switch. Použijte „case var _:“ pro vzor discard nebo „case @_:“ pro konstantu s názvem „_“. '{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. Položka {0} je explicitně implementována více než jednou. '{0}' is already listed in the interface list on type '{2}' as '{1}'. '{0}' is already listed in the interface list on type '{2}' as '{1}'. Duplicate null suppression operator ('!') Duplicitní operátor potlačení hodnoty null (!) Cannot specify 'readonly' modifiers on both accessors of property or indexer '{0}'. Instead, put a 'readonly' modifier on the property itself. Pro přístupové objekty vlastnosti i indexeru {0} nelze zadat modifikátory readonly. Místo toho zadejte modifikátor readonly jenom pro vlastnost. 'else' cannot start a statement. Příkaz nemůže začínat na else. Application entry points cannot be attributed with 'UnmanagedCallersOnly'. Application entry points cannot be attributed with 'UnmanagedCallersOnly'. UnmanagedCallersOnly is not localizable. Record equality contract property '{0}' must have a get accessor. Record equality contract property '{0}' must have a get accessor. Explicit application of 'System.Runtime.CompilerServices.NullableAttribute' is not allowed. Explicitní použití System.Runtime.CompilerServices.NullableAttribute není povolené. 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 Daný výraz nelze použít v příkazu fixed. An expression tree may not contain a null coalescing assignment Strom výrazu nesmí obsahovat přiřazení představující sloučení s hodnotou null. Expression tree cannot contain value of ref struct or restricted type '{0}'. Strom výrazu nemůže obsahovat hodnotu struktury REF ani zakázaný typ {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. Strom výrazů nesmí obsahovat výraz switch. An expression tree may not contain a tuple == or != operator Strom výrazů nesmí obsahovat operátor řazené kolekce členů == nebo !=. 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}: Externí událost nemůže mít inicializátor. The feature '{0}' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version. Funkce {0} je aktuálně ve verzi Preview a je *nepodporovaná*. Pokud chcete používat funkce Preview, použijte jazykovou verzi preview. Feature '{0}' is experimental and unsupported; use '/features:{1}' to enable. Funkce {0} je zkušební, a proto není podporovaná. K aktivaci použijte /features:{1}. Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater. Funkce {0} není v C# 8.0 dostupná. Použijte prosím jazykovou verzi {1} nebo větší. Feature '{0}' is not available in C# 8.0. Please use language version {1} or greater. Funkce {0} není v C# 8.0 dostupná. Použijte prosím jazykovou verzi {1} nebo větší. 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'. Událost podobná poli {0} nemůže mít modifikátor 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'? Příkaz foreach nejde použít pro proměnné typu {0}, protože {0} neobsahuje veřejnou definici instance pro {1}. Měli jste v úmyslu await foreach místo 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 function pointer cannot be called with named arguments. A function pointer cannot be called with named arguments. A goto cannot jump to a location before a using declaration within the same block. Příkaz goto nemůže přejít na místo před deklarací using ve stejném bloku. A goto cannot jump to a location after a using declaration. Příkaz goto nemůže přejít na místo za deklarací using. The suppression operator is not allowed in this context Operátor potlačení není v tomto kontextu povolený. Invocation of implicit Index Indexer cannot name the argument. Volání implicitního indexeru indexů nemůže pojmenovat argument. 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 Invocation of implicit Range Indexer cannot name the argument. Volání implicitního indexeru rozsahů nemůže pojmenovat argument. Arguments with 'in' modifier cannot be used in dynamically dispatched expressions. Argumenty s modifikátorem in se nedají použít v dynamicky volaných výrazech. 'init' accessors cannot be marked 'readonly'. Mark '{0}' readonly instead. 'init' accessors cannot be marked 'readonly'. Mark '{0}' readonly instead. 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} nemůže implementovat člen rozhraní {1} v typu {2}, protože má parametr __arglist. Internal error in the C# compiler. Vnitřní chyba v kompilátoru jazyka 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}' Neplatný název algoritmu hash: {0} Invalid object creation Vytvoření neplatného objektu Cannot specify 'readonly' modifiers on both property or indexer '{0}' and its accessor. Remove one of them. Pro vlastnost nebo indexer {0} i jejich přístupový objekt nelze zadat modifikátory readonly. Odeberte jeden z nich. "Invalid rank specifier: expected ']' Specifikátor rozsahu je neplatný. Očekávala se pravá hranatá závorka ]. '{0}' is not a valid calling convention type for 'UnmanagedCallersOnly'. '{0}' is not a valid calling convention type for 'UnmanagedCallersOnly'. UnmanagedCallersOnly is not localizable. 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. Ve výrazu is-type se nepovoluje použití typu odkazu s možnou hodnotou null {0}?; místo toho použijte základní typ {0}. An expression of type '{0}' can never match the provided pattern. Výraz typu {0} nesmí nikdy odpovídat poskytnutému vzoru. Method '{0}' with an iterator block must be 'async' to return '{1}' Metoda {0} s blokem iterátoru musí být asynchronní, aby vrátila {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 Chybějící vzor Module initializer cannot be attributed with 'UnmanagedCallersOnly'. Module initializer cannot be attributed with 'UnmanagedCallersOnly'. UnmanagedCallersOnly is not localizable. 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}'). Ve stejném adresáři nemůže být více konfiguračních souborů analyzátoru ({0}). The attribute [EnumeratorCancellation] cannot be used on multiple parameters Atribut [EnumeratorCancellation] nejde použít na víc parametrů. 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 Omezení new() nejde používat s omezením 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}: typ použitý v asynchronním příkazu using musí být implicitně převoditelný na System.IAsyncDisposable nebo musí implementovat odpovídající metodu DisposeAsync. Měli jste v úmyslu použít using nebo 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}: Typ použitý v příkazu using musí být implicitně převoditelný na System.IDisposable. Neměli jste v úmyslu použít await using místo 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' Očekávala se hodnota enable, disable nebo restore. Expected 'warnings', 'annotations', or end of directive Očekávala se možnost warnings nebo annotations nebo konec direktivy. Invalid '{0}' value: '{1}' for C# {2}. Please use language version '{3}' or greater. Neplatná hodnota {0}: {1} pro jazyk C# {2}. Použijte prosím verzi jazyka {3} nebo vyšší. 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 Výstupní proměnná nemůže být deklarovaná jako lokální proměnná podle odkazu. 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. Metoda {0} určuje omezení class pro parametr typu {1}, ale odpovídající parametr typu {2} přepsané nebo explicitně implementované metody {3} není odkazový typ. 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. Metoda {0} určuje omezení struct pro parametr typu {1}, ale odpovídající parametr typu {2} přepsané nebo explicitně implementované metody {3} není typ, který nemůže mít hodnotu 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 Obě deklarace částečné metody musí mít modifikátor readonly, nebo nesmí mít modifikátor readonly žádná z nich. 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. Porovnávání vzorů není povolené pro typy ukazatelů. The body of an async-iterator method must contain a 'yield' statement. Tělo metody async-iterator musí obsahovat příkaz 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. Tělo metody async-iterator musí obsahovat příkaz yield. Zvažte odebrání položky async z deklarace metody nebo přidání příkazu yield. A property subpattern requires a reference to the property or field to be matched, e.g. '{{ Name: {0} }}' Dílčí vzor vlastnosti vyžaduje odkaz na vlastnost nebo pole k přiřazení, např. „{{ 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. Typ {0} nemůže být vložený, protože má reabstrakci člena ze základního rozhraní. Zvažte nastavení vlastnosti Vložit typy spolupráce na hodnotu false. '{0}': 'readonly' can only be used on accessors if the property or indexer has both a get and a set accessor {0}: U přístupových objektů se modifikátor readonly může použít jenom v případě, že vlastnost nebo indexer má přístupový objekt get i set. Cannot ref-assign '{1}' to '{0}' because '{1}' has a narrower escape scope than '{0}'. Přiřazení odkazu {1} k {0} nelze provést, protože {1} má užší řídicí obor než {0}. The left-hand side of a ref assignment must be a ref local or parameter. Levá strana přiřazení odkazu musí být lokální proměnná nebo parametr odkazu. 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. Cílový modul runtime nepodporuje pro člena rozhraní přístupnost na úrovni Protected, Protected internal nebo Private protected. 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 ')'. Vzor deconstruct s jedním elementem vyžaduje určitou další syntaxi pro zajištění jednoznačnosti. Doporučuje se přidat označení discard „_“ za koncovou závorku „)“. 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'. Statická lokální funkce nesmí obsahovat odkaz na this nebo base. A static local function cannot contain a reference to '{0}'. Statická lokální funkce nesmí obsahovat odkaz na {0}. Static member '{0}' cannot be marked 'readonly'. Statický člen {0} se nedá označit modifikátorem 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. Tento vzor už zpracovala předchozí větev výrazu switch. The switch case is unreachable. It has already been handled by a previous case or it is impossible to match. Větev příkazu switch se už zpracovala předchozí větví. No best type was found for the switch expression. Pro výraz switch se nenašel žádný optimální typ. Parentheses are required around the switch governing expression. Řídící výraz switch je nutné uzavřít do závorek. Top-level statements must precede namespace and type declarations. Top-level statements must precede namespace and type declarations. Unexpected character sequence '...' Neočekáváná posloupnost znaků ... The name '{0}' does not identify tuple element '{1}'. Název {0} neidentifikuje element tuple {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. Typy řazené kolekce členů, které se používají jako operandy operátoru == nebo !=, musí mít odpovídající kardinality. U tohoto operátoru je ale kardinalita typů řazené kolekce členů vlevo {0} a vpravo {1}. 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. '{0}' is attributed with 'UnmanagedCallersOnly' and cannot be called directly. Obtain a function pointer to this method. '{0}' is attributed with 'UnmanagedCallersOnly' and cannot be called directly. Obtain a function pointer to this method. UnmanagedCallersOnly is not localizable. '{0}' is attributed with 'UnmanagedCallersOnly' and cannot be converted to a delegate type. Obtain a function pointer to this method. '{0}' is attributed with 'UnmanagedCallersOnly' and cannot be converted to a delegate type. Obtain a function pointer to this method. UnmanagedCallersOnly is not localizable. discards discards target-typed object creation target-typed object creation The assembly '{0}' containing type '{1}' references .NET Framework, which is not supported. The assembly '{0}' containing type '{1}' references .NET Framework, which is not supported. {1} is the type that was loaded, {0} is the containing assembly. The loaded assembly references .NET Framework, which is not supported. The loaded assembly references .NET Framework, which is not supported. Parameter '{0}' must have a non-null value when exiting because parameter '{1}' is non-null. Parameter '{0}' must have a non-null value when exiting because parameter '{1}' is non-null. Parameter must have a non-null value when exiting because parameter referenced by NotNullIfNotNull is non-null. Parameter must have a non-null value when exiting because parameter referenced by NotNullIfNotNull is non-null. '{0}' defines 'Equals' but not 'GetHashCode' '{0}' defines 'Equals' but not 'GetHashCode' 'GetHashCode' and 'Equals' are not localizable. Record defines 'Equals' but not 'GetHashCode'. Record defines 'Equals' but not 'GetHashCode'. 'GetHashCode' and 'Equals' are not localizable. Types and aliases should not be named 'record'. Types and aliases should not be named 'record'. Types and aliases should not be named 'record'. Types and aliases should not be named 'record'. Return value must be non-null because parameter '{0}' is non-null. Return value must be non-null because parameter '{0}' is non-null. Return value must be non-null because parameter is non-null. Return value must be non-null because parameter is non-null. The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value. For example, the pattern '{0}' is not covered. The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value. For example, the pattern '{0}' is not covered. The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value. The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value. Method '{0}' will not be used as an entry point because a synchronous entry point '{1}' was found. Method '{0}' will not be used as an entry point because a synchronous entry point '{1}' was found. Type '{0}' is not defined. Type '{0}' is not defined. Unexpected argument list. Unexpected argument list. A constructor declared in a record with parameter list must have 'this' constructor initializer. A constructor declared in a record with parameter list must have 'this' constructor initializer. Invalid variance: The type parameter '{1}' must be {3} valid on '{0}' unless language version '{4}' or greater is used. '{1}' is {2}. Invalid variance: The type parameter '{1}' must be {3} valid on '{0}' unless language version '{4}' or greater is used. '{1}' is {2}. '{0}': cannot specify both a constraint class and the 'unmanaged' constraint {0}: Nejde zadat třídu omezení a zároveň omezení unmanaged. Methods attributed with 'UnmanagedCallersOnly' cannot have generic type parameters and cannot be declared in a generic type. Methods attributed with 'UnmanagedCallersOnly' cannot have generic type parameters and cannot be declared in a generic type. UnmanagedCallersOnly is not localizable. 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions. 'UnmanagedCallersOnly' can only be applied to ordinary static methods or static local functions. UnmanagedCallersOnly is not localizable. 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}' Typ {2} musí být typ, který nemůže mít hodnotu null, ani nesmí v žádné úrovni vnoření obsahovat pole, které by ji povolovalo, aby se dal použít jako parametr {1} v obecném typu nebo metodě {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). Proměnnou using není možné v sekci switch použít přímo (zvažte použití složených závorek). The syntax 'var' for a pattern is not permitted to refer to a type, but '{0}' is in scope here. U syntaxe var pro vzor se nepovoluje odkazování na typ, ale {0} je tady v rámci rozsahu. Enums, classes, and structures cannot be declared in an interface that has an 'in' or 'out' type parameter. Výčty, třídy a struktury není možné deklarovat v rozhraní, které má parametr typu in/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. Přiřazení k řazené kolekci členů typu {0} vyžaduje dílčí vzory {1}, ale k dispozici jsou dílčí vzory {2}. File name '{0}' is empty, contains invalid characters, has a drive specification without an absolute path, or is too long Název souboru {0} je prázdný, obsahuje neplatné znaky, má specifikaci jednotky bez absolutní cesty nebo je moc dlouhý. &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 -generatedfilesout:<dir> Place files generated during compilation in the specified directory. Parametry kompilátoru Visual C# - VÝSTUPNÍ SOUBORY - -out:<soubor> Určuje název výstupního souboru (výchozí: základní název souboru s hlavní třídou nebo prvního souboru) -target:exe Vytvoří spustitelný soubor konzoly (výchozí). (Krátký formát: -t:exe) -target:winexe Vytvoří spustitelný soubor systému Windows. (Krátký formát: -t:winexe) -target:library Vytvoří knihovnu. (Krátký formát: -t:library) -target:module Vytvoří modul, který se dá přidat do jiného sestavení. (Krátký formát: -t:module) -target:appcontainerexe Sestaví spustitelný soubor kontejneru Appcontainer. (Krátký formát: -t:appcontainerexe) -target:winmdobj Sestaví pomocný soubor modulu Windows Runtime, který využívá knihovna WinMDExp. (Krátký formát: -t:winmdobj) -doc:<soubor> Soubor dokumentace XML, který má být vygenerován -refout:<soubor> Výstup referenčního sestavení, který má být vygenerován -platform:<řetězec> Omezuje platformy, na kterých lze tento kód spustit: x86, Itanium, x64, arm, arm64, anycpu32bitpreferred nebo anycpu. Výchozí nastavení je anycpu. - VSTUPNÍ SOUBORY - -recurse:<zástupný znak> Zahrne všechny soubory v aktuálním adresáři a jeho podadresářích podle zadaného zástupného znaku. -reference:<alias>=<soubor> Odkazuje na metadata ze zadaného souboru sestavení pomocí daného aliasu. (Krátký formát: -r) -reference:<seznam souborů> Odkazuje na metadata ze zadaných souborů sestavení (Krátký formát: -r) -addmodule:<seznam souborů> Připojí zadané moduly k tomuto sestavení. -link:<seznam souborů> Vloží metadata ze zadaných souborů sestavení spolupráce (Krátký formát: -l) -analyzer:<seznam souborů> Spustí analyzátory z tohoto sestavení. (Krátký formát: -a) -additionalfile:<seznam souborů> Další soubory, které přímo neovlivňují generování kódu, ale analyzátory můžou jejich pomocí produkovat chyby nebo upozornění. -embed Vloží všechny zdrojové soubory do PDB. -embed:<seznam souborů> Vloží konkrétní soubory do PDB. - PROSTŘEDKY - -win32res:<soubor> Určuje soubor prostředků Win32 (.res). -win32icon:<soubor> Použije pro výstup zadanou ikonu. -win32manifest:<soubor> Určuje soubor manifestu Win32 (.xml). -nowin32manifest Nezahrne výchozí manifest Win32. -resource:<prostředek> Vloží zadaný prostředek. (Krátký formát: -res) -linkresource:<prostředek> Propojí zadaný prostředek s tímto sestavením. (Krátký formát: -linkres) Prostředek má formát is <soubor>[,<název řetězce>[,public|private]]. - GENEROVÁNÍ KÓDU - -debug[+|-] Generuje ladicí informace. -debug:{full|pdbonly|portable|embedded} Určuje typ ladění (výchozí je možnost full, portable je formát napříč platformami, embedded je formát napříč platformami vložený do cílového souboru .dll nebo .exe). -optimize[+|-] Povolí optimalizace. (Krátký formát: -o) -deterministic Vytvoří deterministické sestavení (včetně GUID verze modulu a časového razítka). -refonly Vytvoří referenční sestavení na místě hlavního výstupu. -instrument:TestCoverage Vytvoří sestavení instrumentované ke shromažďování informací o pokrytí. -sourcelink:<soubor> Informace o zdrojovém odkazu vkládané do souboru PDB. - CHYBY A UPOZORNĚNÍ - -warnaserror[+|-] Hlásí všechna upozornění jako chyby. -warnaserror[+|-]:<seznam upozornění> Hlásí zadaná upozornění jako chyby. -warn:<n> Nastaví úroveň pro upozornění (0–4). (Krátký formát: -w) -nowarn:<seznam upozornění> Zakáže zadaná upozornění. -ruleset:<soubor> Určuje soubor sady pravidel, která zakazuje specifickou diagnostiku. -errorlog:<soubor>>[,version=<verze_sarif>] Určuje soubor pro protokolování veškeré diagnostiky kompilátoru a analyzátoru. verze_sarif:{1|2|2.1} Výchozí jsou 1. 2 a 2.1. Obojí znamená SARIF verze 2.1.0. -reportanalyzer Hlásí další informace analyzátoru, např. dobu spuštění. - JAZYK - -checked[+|-] Generuje kontroly přetečení. -unsafe[+|-] Povoluje nezabezpečený kód. -define:<seznam symbolů> Definuje symboly podmíněné kompilace. (Krátký formát: -d) -langversion:? Zobrazuje povolené hodnoty pro verzi jazyka. -langversion:<řetězec> Určuje verzi jazyka, například: latest (poslední verze včetně podverzí), default (stejné jako latest), latestmajor (poslední verze bez podverzí), preview (poslední verze včetně funkcí v nepodporované verzi preview) nebo konkrétní verze, například 6 nebo 7.1. -nullable[+|-] Určuje pro kontext s hodnotou null možnosti enable|disable. -nullable:{enable|disable|warnings|annotations} Určuje pro kontext s hodnotou null možnosti enable|disable|warnings|annotations. - ZABEZPEČENÍ - -delaysign[+|-] Vytvoří zpožděný podpis sestavení s využitím jenom veřejné části klíče silného názvu. -publicsign[+|-] Vytvoří veřejný podpis sestavení s využitím jenom veřejné části klíče silného názvu. -keyfile:<soubor> Určuje soubor klíče se silným názvem. -keycontainer:<řetězec> Určuje kontejner klíče se silným názvem. -highentropyva[+|-] Povolí ASLR s vysokou entropií. - RŮZNÉ - @<soubor> Načte další možnosti ze souboru odpovědí. -help Zobrazí tuto zprávu o použití. (Krátký formát: -?) -nologo Potlačí zprávu o autorských právech kompilátoru. -noconfig Nezahrnuje automaticky soubor CSC.RSP. -parallel[+|-] Souběžné sestavení. -version Zobrazí číslo verze kompilátoru a ukončí se. - POKROČILÉ - -baseaddress:<adresa> Základní adresa pro knihovnu, která se má sestavit. -checksumalgorithm:<alg> Určuje algoritmus pro výpočet kontrolního součtu zdrojového souboru uloženého v PDB. Podporované hodnoty: SHA1 nebo SHA256 (výchozí). -codepage:<n> Určuje znakovou stránku, která se má použít při otevírání zdrojových souborů. -utf8output Určuje výstup zpráv kompilátoru v kódování UTF-8. -main:<typ> Určuje typ obsahující vstupní bod (ignoruje všechny ostatní potenciální vstupní body). (Krátký formát: -m) -fullpaths Kompilátor generuje úplné cesty. -filealign:<n> Určuje zarovnání použité pro oddíly výstupního souboru. -pathmap:<K1>=<V1>,<K2>=<V2>,... Určuje mapování pro výstup zdrojových názvů cest kompilátorem. -pdb:<soubor> Určuje název souboru ladicích informací (výchozí: název výstupního souboru s příponou .pdb). -errorendlocation Vypíše řádek a sloupec koncového umístění jednotlivých chyb. -preferreduilang Určuje název upřednostňovaného výstupního jazyka. -nosdkpath Zakazuje hledání cesty k výchozí sadě SDK pro sestavení standardních knihoven. -nostdlib[+|-] Neodkazuje na standardní knihovnu (mscorlib.dll). -subsystemversion:<string> Určuje verzi subsystému tohoto sestavení. -lib:<seznam souborů> Určuje další adresáře, ve kterých se mají hledat reference. -errorreport:<řetězec> Určuje způsob zpracování interních chyb kompilátoru: prompt, send, queue nebo none. Výchozí možnost je queue (zařadit do fronty). -appconfig:<soubor> Určuje konfigurační soubor aplikace, který obsahuje nastavení vazby sestavení. -moduleassemblyname:<řetězec> Určuje název sestavení, jehož součástí bude tento modul. -modulename:<řetězec> Určuje název zdrojového modulu. Visual C# Compiler Options default interface implementation implementace výchozího rozhraní disposable jednoúčelové alternative interpolated verbatim strings alternativní interpolované doslovné řetězce and pattern and pattern asynchronous using asynchronní příkaz using coalescing assignment slučovací přiřazení covariant returns covariant returns default type parameter constraints default type parameter constraints delegate generic type constraints delegovat obecná omezení typu enum generic type constraints výčet obecných omezení typu declaration of expression variables in member initializers and queries deklarace proměnných výrazu v inicializátorech členů a dotazech extended partial methods extended partial methods extensible fixed statement rozšiřitelný příkaz fixed extension GetAsyncEnumerator extension GetAsyncEnumerator extension GetEnumerator extension GetEnumerator extern local functions extern local functions function pointers function pointers index operator operátor indexu indexing movable fixed buffers indexování mobilních vyrovnávacích pamětí pevné velikosti init-only setters init-only setters local function attributes local function attributes lambda discard parameters lambda – zahodit parametry MemberNotNull attribute MemberNotNull attribute module initializers module initializers name shadowing in nested functions skrývání názvů ve vnořených funkcích native-sized integers native-sized integers stackalloc in nested expressions stackalloc ve vnořených výrazech notnull generic type constraint omezení obecného typu notnull not pattern not pattern null pointer constant pattern null pointer constant pattern nullable reference types typy odkazů s možnou hodnotou null obsolete on property accessor zastaralé u přístupového objektu vlastnosti or pattern or pattern parenthesized pattern parenthesized pattern warning action enable akce upozornění enable range operator operátor rozsahu readonly members členové s modifikátorem readonly records records recursive patterns rekurzivní vzory ref conditional expression referenční podmínka ref for-loop variables Proměnné smyčky for odkazu ref foreach iteration variables Iterační proměnné foreach odkazu ref reassignment Opětovné přiřazení odkazu relational pattern relational pattern stackalloc initializer inicializátor výrazu stackalloc static anonymous function static anonymous function static local functions statické místní funkce <switch expression> <výraz přepínače> target-typed conditional expression target-typed conditional expression tuple equality rovnost řazené kolekce členů type pattern type pattern unconstrained type parameters in null coalescing operator parametry neomezeného typu v operátoru sloučení s hodnotou null unmanaged constructed types nespravované konstruované typy unmanaged generic type constraints nespravovaná obecná omezení typu using declarations deklarace using variance safety for static interface members variance safety for static interface members <null> <null> constraints for override and explicit interface implementation methods omezení pro metody přepsání a explicitní implementace rozhraní parameter parameter return return <throw expression> <výraz throw> (Location of symbol related to previous error) (Umístění symbolu vzhledem k předchozí chybě) (Location of symbol related to previous warning) (Umístění symbolu vzhledem k předchozímu upozornění) top-level statements top-level statements <!-- Badly formed XML comment ignored for member "{0}" --> <!-- Badly formed XML comment ignored for member "{0}" --> Badly formed XML file "{0}" cannot be included Chybně vytvořený soubor XML {0} nejde zahrnout. Failed to insert some or all of included XML Vložení části nebo veškerého zahrnutého kódu XML se nezdařilo. Include tag is invalid Značka Include je neplatná. No matching elements were found for the following include tag Pro následující značku include se nenašly žádné vyhovující prvky. Missing file attribute Atribut souboru se nenašel. Missing path attribute Atribut cesty se nenašel. <global namespace> <globální obor názvů> generics obecné anonymous methods anonymní metody module as an attribute target specifier modul jako cílový specifikátor atributů namespace alias qualifier kvalifikátor aliasu oboru názvů fixed size buffers vyrovnávací paměti pevné velikosti #pragma #pragma static classes statické třídy readonly structs struktury jen pro čtení partial types částečné typy async function asynchronní funkce switch on boolean type přepínač založený na typu boolean method group skupina metod anonymous method anonymní metoda lambda expression výraz lambda collection kolekce access modifiers on properties modifikátory přístupu pro vlastnosti extern alias externí alias iterators iterátory default operator výchozí operátor default literal výchozí literál private protected private protected nullable types typy s povolenou hodnotou null pattern matching porovnávání vzorů expression body property accessor přístupový objekt vlastnosti textu výrazu expression body constructor and destructor konstruktor a destruktor textu výrazu throw expression výraz throw implicitly typed array implicitně typované pole implicitly typed local variable implicitně typovaná lokální proměnná anonymous types anonymní typy automatically implemented properties automaticky implementované vlastnosti readonly automatically implemented properties automaticky implementované vlastnosti jen pro čtení object initializer inicializátor objektu collection initializer inicializátor kolekce query expression výraz dotazu extension method metoda rozšíření partial method částečná metoda method metoda type typ namespace obor názvů field pole property vlastnost element element variable proměnná label popisek event událost type parameter parametr typu using alias alias using extern alias externí alias constructor konstruktor foreach iteration variable iterační proměnná foreach fixed variable pevná proměnná using variable proměnná using contravariant kontravariant contravariantly kontravariantně covariant kovariant covariantly kovariantně invariantly invariantně dynamic dynamický named argument pojmenovaný argument optional parameter volitelný parametr exception filter filtr výjimky type variance odchylka typu 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 není součástí kompilace. SyntaxTree is not part of the compilation, so it cannot be removed SyntaxTree není součástí kompilace, takže se nedá odebrat. 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. Název „_“ odkazuje na konstantu, ne na vzor discard. Zadáním „var _“ hodnotu zahodíte a zadáním „@_“ nastavíte pod tímto názvem odkaz na konstantu. Do not use '_' for a case constant. Nepoužívejte „_“ jako konstantu case. 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. Literál s hodnotou null nebo s možnou hodnotou null se převádí na typ, který nemůže mít hodnotu null. Converting null literal or possible null value to non-nullable type. Literál s hodnotou null nebo s možnou hodnotou null se převádí na typ, který nemůže mít hodnotu null. A possible null value may not be used for a type marked with [NotNull] or [DisallowNull] Možnou hodnotu null není možné použít pro typ označený jako [NotNull] nebo [DisallowNull]. A possible null value may not be used for a type marked with [NotNull] or [DisallowNull] Možnou hodnotu null není možné použít pro typ označený jako [NotNull] nebo [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. Položka {0} je už uvedená v seznamu rozhraní u typu {1} s různou možností použití hodnoty null u typů odkazů. Interface is already listed in the interface list with different nullability of reference types. Rozhraní je už uvedené v seznamu rozhraní s různou možností použití hodnoty null u typů odkazů. 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. Daný výraz vždy odpovídá zadané konstantě. The given expression always matches the provided constant. Daný výraz vždy odpovídá zadané konstantě. The given expression always matches the provided pattern. The given expression always matches the provided pattern. The given expression always matches the provided pattern. The given expression always matches the provided pattern. The given expression never matches the provided pattern. Daný výraz nikdy neodpovídá zadané konstantě. The given expression never matches the provided pattern. Daný výraz nikdy neodpovídá zadané konstantě. Call to non-readonly member '{0}' from a 'readonly' member results in an implicit copy of '{1}'. Volání člena {0}, který nemá modifikátor readonly, ze člena s modifikátorem readonly má za následek implicitní kopii {1}. Call to non-readonly member from a 'readonly' member results in an implicit copy. Volání člena, který nemá modifikátor readonly, ze člena s modifikátorem readonly má za následek implicitní kopii. 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. Název „_“ odkazuje na typ {0}, ne vzor discard. Použijte „@_“ pro tento typ nebo „var _“ pro zahození. Do not use '_' to refer to the type in an is-type expression. Nepoužívejte „_“ jako odkaz na typ ve výrazu 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. Poznámka u typů odkazů s možnou hodnotou null by se měla v kódu používat jenom v kontextu poznámek #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. Poznámka pro typy odkazů s možnou hodnotou null by se měla používat jenom v kódu v rámci kontextu poznámek #nullable. Automaticky vygenerovaný kód vyžaduje explicitní direktivu #nullable ve zdroji. 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. Poznámka pro typy odkazů s možnou hodnotou null by se měla používat jenom v kódu v rámci kontextu poznámek #nullable. Automaticky vygenerovaný kód vyžaduje explicitní direktivu #nullable ve zdroji. The annotation for nullable reference types should only be used in code within a '#nullable' annotations context. Poznámka u typů odkazů s možnou hodnotou null by se měla v kódu používat jenom v kontextu poznámek #nullable. Cannot convert null literal to non-nullable reference type. Literál null nejde převést na odkazový typ, který nemůže mít hodnotu null. Cannot convert null literal to non-nullable reference type. Literál null nejde převést na odkazový typ, který nemůže mít hodnotu null. Possible null reference argument for parameter '{0}' in '{1}'. V parametru {0} v {1} může být argument s odkazem null. Possible null reference argument. Může jít o argument s odkazem null. Possible null reference assignment. Může jít o přiřazení s odkazem null. Possible null reference assignment. Může jít o přiřazení s odkazem null. Object or collection initializer implicitly dereferences possibly null member '{0}'. Inicializátor objektu nebo kolekce implicitně přistupuje přes ukazatel ke členovi {0}, který může být null. Object or collection initializer implicitly dereferences possibly null member. Inicializátor objektu nebo kolekce implicitně přistupuje přes ukazatel ke členovi, který může být null Dereference of a possibly null reference. Přístup přes ukazatel k možnému odkazu s hodnotou null Dereference of a possibly null reference. Přístup přes ukazatel k možnému odkazu s hodnotou null Possible null reference return. Může jít o vrácený odkaz null. Possible null reference return. Může jít o vrácený odkaz null. Argument of type '{0}' cannot be used for parameter '{2}' of type '{1}' in '{3}' due to differences in the nullability of reference types. Argument typu {0} nejde použít pro parametr {2} typu {1} v {3} z důvodu rozdílů v možnostech použití hodnoty null u odkazových typů. Argument of type '{0}' cannot be used as an output of type '{1}' for parameter '{2}' in '{3}' due to differences in the nullability of reference types. Argument typu {0} nejde použít jako výstup typu {1} pro parametr {2} v {3} z důvodu rozdílů v možnostech použití hodnoty null u odkazových typů. Argument cannot be used as an output for parameter due to differences in the nullability of reference types. Argument nejde použít jako výstup pro parametr z důvodu rozdílů v možnostech použití hodnoty null u odkazových typů. Argument cannot be used for parameter due to differences in the nullability of reference types. Argument nejde použít pro parametr z důvodu rozdílů v možnostech použití hodnoty null u odkazových typů. Nullability of reference types in value of type '{0}' doesn't match target type '{1}'. Typ odkazu s možnou hodnotou null v hodnotě typu {0} neodpovídá cílovému typu {1}. Nullability of reference types in value doesn't match target type. Typ odkazu s možnou hodnotou null v hodnotě neodpovídá cílovému typu. 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. Možná hodnota null v omezení parametru typu {0} metody {1} neodpovídá omezením parametru typu {2} metody rozhraní {3}. Zkuste raději použít explicitní implementaci rozhraní. Nullability in constraints for type parameter doesn't match the constraints for type parameter in implicitly implemented interface method'. Možná hodnota null v omezeních parametru typu neodpovídá omezením parametru typu v implicitně implementované metodě rozhraní. Partial method declarations of '{0}' have inconsistent nullability in constraints for type parameter '{1}' Částečné deklarace metod {0} mají nekonzistentní možnost použití hodnoty null v omezeních parametru typu {1}. Partial method declarations have inconsistent nullability in constraints for type parameter Částečné deklarace metod mají nekonzistentní možnost použití hodnoty null v omezeních parametru typu. Nullability of reference types in explicit interface specifier doesn't match interface implemented by the type. Možnost použití hodnoty null u typů odkazů v explicitním specifikátoru rozhraní neodpovídá rozhraní implementovanému podle tohoto typu. Nullability of reference types in explicit interface specifier doesn't match interface implemented by the type. Možnost použití hodnoty null u typů odkazů v explicitním specifikátoru rozhraní neodpovídá rozhraní implementovanému podle tohoto typu. '{0}' does not implement interface member '{1}'. Nullability of reference types in interface implemented by the base type doesn't match. {0} neimplementuje člen rozhraní {1}. Možnost použití hodnoty null u typů odkazů v rozhraní implementovaném podle základního typu se neshoduje. Type does not implement interface member. Nullability of reference types in interface implemented by the base type doesn't match. Typ neimplementuje člen rozhraní. Možnost použití hodnoty null u typů odkazů v rozhraní implementovaném podle základního typu se neshoduje. Nullability of reference types in type of parameter '{0}' of '{1}' doesn't match the target delegate '{2}' (possibly because of nullability attributes). Typ odkazu s možnou hodnotu null v typu parametru {0} metody {1} neodpovídá cílovému delegátovi {2}. Nullability of reference types in type of parameter doesn't match the target delegate (possibly because of nullability attributes). Typ odkazu s možnou hodnotou null v typu parametru neodpovídá cílovému delegátovi. Nullability of reference types in type of parameter '{0}' doesn't match implemented member '{1}'. Typ odkazu s možnou hodnotou null v typu parametru {0} neodpovídá implementovanému členu {1}. Nullability of reference types in type of parameter doesn't match implemented member. Typ odkazu s možnou hodnotou null v typu parametru neodpovídá implementovanému členu. Nullability of reference types in type of parameter '{0}' of '{1}' doesn't match implicitly implemented member '{2}'. Typ odkazu s možnou hodnotou null v typu parametru {0} z {1} neodpovídá implicitně implementovanému členu {2}. Nullability of reference types in type of parameter doesn't match implicitly implemented member. Typ odkazu s možnou hodnotou null v typu parametru neodpovídá implicitně implementovanému členu. Nullability of reference types in type of parameter '{0}' doesn't match overridden member. Typ odkazu s možnou hodnotou null v typu parametru {0} neodpovídá přepsanému členu. Nullability of reference types in type of parameter doesn't match overridden member. Typ odkazu s možnou hodnotou null v typu parametru neodpovídá přepsanému členu. Nullability of reference types in type of parameter '{0}' doesn't match partial method declaration. Typ odkazu s možnou hodnotou null v typu parametru {0} neodpovídá deklaraci částečné metody. Nullability of reference types in type of parameter doesn't match partial method declaration. Typ odkazu s možnou hodnotou null v typu parametru neodpovídá deklaraci částečné metody. Nullability of reference types in return type of '{0}' doesn't match the target delegate '{1}' (possibly because of nullability attributes). Typ odkazu s možnou hodnotou null ve vráceném typu {0} neodpovídá cílovému delegátovi {1}. Nullability of reference types in return type doesn't match the target delegate (possibly because of nullability attributes). Typ odkazu s možnou hodnotou null ve vráceném typu neodpovídá cílovému delegátovi. Nullability of reference types in return type doesn't match implemented member '{0}'. Typ odkazu s možnou hodnotou null ve vráceném typu neodpovídá implementovanému členu {0}. Nullability of reference types in return type doesn't match implemented member. Typ odkazu s možnou hodnotou null ve vráceném typu neodpovídá implementovanému členu. Nullability of reference types in return type of '{0}' doesn't match implicitly implemented member '{1}'. Typ odkazu s možnou hodnotou null v návratovém typu {0} neodpovídá implicitně implementovanému členu {1}. Nullability of reference types in return type doesn't match implicitly implemented member. Typ odkazu s možnou hodnotou null ve vráceném typu neodpovídá implicitně implementovanému členu. Nullability of reference types in return type doesn't match overridden member. Typ odkazu s možnou hodnotou null ve vráceném typu neodpovídá přepsanému členu. Nullability of reference types in return type doesn't match overridden member. Typ odkazu s možnou hodnotou null ve vráceném typu neodpovídá přepsanému členu. 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 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}'. Typ odkazu s možnou hodnotou null v typu neodpovídá implementovanému členu {0}. Nullability of reference types in type doesn't match implemented member. Typ odkazu s možnou hodnotou null v typu neodpovídá implementovanému členu. Nullability of reference types in type of '{0}' doesn't match implicitly implemented member '{1}'. Typ odkazu s možnou hodnotou null v typu {0} neodpovídá implicitně implementovanému členu {1}. Nullability of reference types in type doesn't match implicitly implemented member. Typ odkazu s možnou hodnotou null v typu neodpovídá implicitně implementovanému členu. Nullability of reference types in type doesn't match overridden member. Typ odkazu s možnou hodnotou null v typu neodpovídá přepsanému členu. Nullability of reference types in type doesn't match overridden member. Typ odkazu s možnou hodnotou null v typu neodpovídá přepsanému členu. 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}'. Typ {3} nejde použít jako parametr typu {2} v obecném typu nebo metodě {0}. Typ argumentu {3} s možnou hodnotou null neodpovídá typu omezení {1}. The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match constraint type. Typ nejde použít jako parametr typu v obecném typu nebo metodě. Typ argumentu s možnou hodnotou null neodpovídá typu omezení. 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. Typ {2} nejde použít jako parametr typu {1} v obecném typu nebo metodě {0}. Argument typu {2} s možnou hodnotou null neodpovídá omezení notnull. The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'notnull' constraint. Typ nejde použít jako parametr typu v obecném typu nebo metodě. Argument typu s možnou hodnotou null neodpovídá omezení 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. Typ {2} nejde použít jako parametr typu {1} v obecném typu nebo metodě {0}. Typ argumentu {2} s možnou hodnotou null neodpovídá omezení třídy. The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'class' constraint. Typ nejde použít jako parametr typu v obecném typu nebo metodě. Typ argumentu s možnou hodnotou null neodpovídá omezení třídy. Nullable value type may be null. Typ hodnoty, která připouští hodnotu null, nemůže být null. Nullable value type may be null. Typ hodnoty, která připouští hodnotu null, nemůže být null. 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}'. Parametr {0} nemusí mít při ukončení s {1} hodnotu null. Parameter must have a non-null value when exiting in some condition. Parametr nemusí mít při ukončení za určité podmínky hodnotu null 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. '{0}': static types cannot be used as parameters '{0}': static types cannot be used as parameters Static types cannot be used as parameters Static types cannot be used as parameters 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. '{0}': static types cannot be used as return types '{0}': static types cannot be used as return types Static types cannot be used as return types Static types cannot be used as return types A method marked [DoesNotReturn] should not return. Metoda označená jako [DoesNotReturn] by neměla vracet hodnotu A method marked [DoesNotReturn] should not return. Metoda označená jako [DoesNotReturn] by neměla vracet hodnotu 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. Výraz switch nezpracovává některé vstupy s hodnotou 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). Výraz switch nezpracovává všechny možné hodnoty svého vstupního typu (není úplný) Thrown value may be null. Vyvolaná hodnota může být null. Thrown value may be null. Vyvolaná hodnota může být 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). 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. Název elementu řazené kolekce členů {0} se ignoruje, protože na druhé straně operátoru == nebo != řazené kolekce členů je určený jiný nebo žádný název. The tuple element name is ignored because a different name or no name is specified on the other side of the tuple == or != operator. Název elementu řazené kolekce členů se ignoruje, protože na druhé straně operátoru == nebo != řazené kolekce členů je určený jiný nebo žádný název. Type parameter '{0}' has the same name as the type parameter from outer method '{1}' Parametr typu {0} má stejný název jako parametr typu z vnější metody {1}. Type parameter has the same type as the type parameter from outer method. Parametr typu má stejný typ jako parametr typu z vnější metody. 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. Rozbalení možné hodnoty null Unboxing a possibly null value. Rozbalení možné hodnoty 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 EnumeratorCancellationAttribute, který se používá u parametru {0}, nebude mít žádný účinek. Tento atribut je platný jenom u parametru typu CancellationToken v metodě async-iterator, která vrací 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 EnumeratorCancellationAttribute nebude mít žádný účinek. Tento atribut je platný jenom u parametru typu CancellationToken v metodě async-iterator, která vrací 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 Asynchronní iterátor {0} má jeden nebo více parametrů typu CancellationToken, ale žádný z nich není dekorovaný atributem EnumeratorCancellation, takže parametr tokenu zrušení z vygenerovaného výrazu IAsyncEnumerable<>.GetAsyncEnumerator se nespotřebuje. 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 Člen asynchronního iterátoru má jeden nebo více parametrů typu CancellationToken, ale žádný z nich není dekorovaný atributem EnumeratorCancellation, takže parametr tokenu zrušení z vygenerovaného výrazu IAsyncEnumerable<>.GetAsyncEnumerator se nespotřebuje. Non-nullable {0} '{1}' must contain a non-null value when exiting constructor. Consider declaring the {0} as nullable. Není inicializovaný prvek {0} ({1}) bez možnosti zadání hodnoty null. Zvažte možnost deklarovat prvek {0} jako umožňující hodnotu null. Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable. Není inicializované pole, které nemůže mít hodnotu null. Zvažte možnost deklarovat ho jako typ s možnou hodnotou null. Parameter '{0}' is unread. Did you forget to use it to initialize the property with that name? Parameter '{0}' is unread. Did you forget to use it to initialize the property with that name? Parameter is unread. Did you forget to use it to initialize the property with that name? Parameter is unread. Did you forget to use it to initialize the property with that name? 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. Znaky {0} se na tomto místě nedají použít. Incorrect syntax was used in a comment. V komentáři se používá nesprávná syntaxe. An invalid character was found inside an entity reference. Uvnitř odkazu na entitu se našel neplatný znak. Expected '>' or '/>' to close tag '{0}'. Očekával se řetězec > nebo /> uzavírající značku {0}. An identifier was expected. Očekával se identifikátor. Invalid unicode character. Neplatný znak unicode Whitespace is not allowed at this location. Prázdný znak není v tomto místě povolený. The character '<' cannot be used in an attribute value. Znak < se nedá použít v hodnotě atributu. Missing equals sign between attribute and attribute value. Mezi atributem a jeho hodnotou chybí znaménko rovná se. Reference to undefined entity '{0}'. Odkaz na nedefinovanou entitu {0} A string literal was expected, but no opening quotation mark was found. Očekával se řetězcový literál, ale nenašly se úvodní uvozovky. Missing closing quotation mark for string literal. U řetězcového literálu chybí koncové uvozovky. Non-ASCII quotations marks may not be used around string literals. U řetězcových literálů se nesmí používat jiné uvozovky než ASCII. End tag was not expected at this location. Na tomto místě se neočekávala koncová značka. End tag '{0}' does not match the start tag '{1}'. Koncová značka {0} neodpovídá počáteční značce {1}. Expected an end tag for element '{0}'. Očekávala se koncová značka pro element {0}. Required white space was missing. Chybí požadovaná mezera. Unexpected character at this location. Neočekávaný znak na tomto místě The literal string ']]>' is not allowed in element content. V obsahu elementu není povolený řetězec literálu ]]>. Duplicate '{0}' attribute Duplicitní atribut {0} Metadata file '{0}' could not be found Soubor metadat {0} se nenašel. Metadata references are not supported. Odkazy v metadatech se nepodporují. Metadata file '{0}' could not be opened -- {1} Soubor metadat {0} nešel otevřít -- {1} The type '{0}' is defined in an assembly that is not referenced. You must add a reference to assembly '{1}'. Typ {0} je definovaný jako sestavení, na které se neodkazuje. Je nutné přidat odkaz na sestavení {1}. The type '{0}' is defined in a module that has not been added. You must add the module '{1}'. Typ {0} je definovaný v modulu, který jste nepřidali. Musíte přidat modul {1}. Could not write to output file '{0}' -- '{1}' Do výstupního souboru {0} nejde zapisovat -- {1}. Program has more than one entry point defined. Compile with /main to specify the type that contains the entry point. Program má definovaný víc než jeden vstupní bod. V kompilaci použijte /main určující typ, který vstupní bod obsahuje. Operator '{0}' cannot be applied to operands of type '{1}' and '{2}' Operátor {0} nejde použít na operandy typu {1} a {2}. Division by constant zero Dělení nulovou konstantou Cannot apply indexing with [] to an expression of type '{0}' Ve výrazu typu {0} nejde použít indexování pomocí hranatých závorek ([]). Wrong number of indices inside []; expected {0} Špatné číslo indexu uvnitř []; očekává se {0}. Operator '{0}' cannot be applied to operand of type '{1}' Operátor {0} nejde použít na operand typu {1}. Keyword 'this' is not valid in a static property, static method, or static field initializer Klíčové slovo this není platné ve statické vlastnosti, ve statické metodě ani ve statickém inicializátoru pole. Keyword 'this' is not available in the current context Klíčové slovo this není v aktuálním kontextu k dispozici. '{0}' has the wrong signature to be an entry point '{0} nemá správný podpis, takže nemůže být vstupním bodem. Method has the wrong signature to be an entry point Metoda nemá správný podpis, takže nemůže být vstupním bodem. Cannot implicitly convert type '{0}' to '{1}' Typ {0} nejde implicitně převést na typ {1}. Cannot convert type '{0}' to '{1}' Typ {0} nejde převést na typ {1}. Constant value '{0}' cannot be converted to a '{1}' Konstantní hodnotu {0} nejde převést na typ {1}. Operator '{0}' is ambiguous on operands of type '{1}' and '{2}' Operátor {0} je nejednoznačný na operandech typu {1} a {2}. Operator '{0}' is ambiguous on an operand of type '{1}' Operátor {0} je nejednoznačný na operandu typu {1}. An out parameter cannot have the In attribute Parametr out nemůže obsahovat atribut In. Cannot convert null to '{0}' because it is a non-nullable value type Hodnotu null nejde převést na typ {0}, protože se jedná o typ, který nemůže mít hodnotu null. Cannot convert type '{0}' to '{1}' via a reference conversion, boxing conversion, unboxing conversion, wrapping conversion, or null type conversion Typ {0} nejde převést na {1} prostřednictvím převodu odkazu, převodu zabalení, převodu rozbalení, převodu obálky nebo převodu s hodnotou null. Unexpected error writing debug information -- '{0}' Neočekávaná chyba při zápisu ladicích informací -- {0} Inconsistent accessibility: return type '{1}' is less accessible than method '{0}' Nekonzistentní dostupnost: Typ vrácené hodnoty {1} je míň dostupný než metoda {0}. Inconsistent accessibility: parameter type '{1}' is less accessible than method '{0}' Nekonzistentní dostupnost: Typ parametru {1} je míň dostupný než metoda {0}. Inconsistent accessibility: field type '{1}' is less accessible than field '{0}' Nekonzistentní dostupnost: Typ pole {1} je míň dostupný než pole {0}. Inconsistent accessibility: property type '{1}' is less accessible than property '{0}' Nekonzistentní dostupnost: Typ vlastnosti {1} je míň dostupný než vlastnost {0}. Inconsistent accessibility: indexer return type '{1}' is less accessible than indexer '{0}' Nekonzistentní dostupnost: Typ vrácené hodnoty indexeru {1} je méně dostupný než indexer {0}. Inconsistent accessibility: parameter type '{1}' is less accessible than indexer '{0}' Nekonzistentní dostupnost: Typ parametru {1} je míň dostupný než indexer {0}. Inconsistent accessibility: return type '{1}' is less accessible than operator '{0}' Nekonzistentní dostupnost: Typ vrácené hodnoty {1} je míň dostupný než operátor {0}. Inconsistent accessibility: parameter type '{1}' is less accessible than operator '{0}' Nekonzistentní dostupnost: Typ parametru {1} je míň dostupný než operátor {0}. Inconsistent accessibility: return type '{1}' is less accessible than delegate '{0}' Nekonzistentní dostupnost: Typ vrácené hodnoty {1} je míň dostupný než delegát {0}. Inconsistent accessibility: parameter type '{1}' is less accessible than delegate '{0}' Nekonzistentní dostupnost: Typ parametru {1} je míň dostupný než delegát {0}. Inconsistent accessibility: base class '{1}' is less accessible than class '{0}' Nekonzistentní dostupnost: Základní třída {1} je míň dostupná než třída {0}. Inconsistent accessibility: base interface '{1}' is less accessible than interface '{0}' Nekonzistentní dostupnost: Základní rozhraní {1} je míň dostupné než rozhraní {0}. '{0}': event property must have both add and remove accessors '{0}: Vlastnost události musí obsahovat přistupující objekty add i remove. '{0}': event must be of a delegate type '{0}: Událost musí být typu delegát. The event '{0}' is never used Událost {0} se nikdy nepoužívá. Event is never used Událost se nikdy nepoužívá. '{0}': instance event in interface cannot have initializer {0}: Událost instance v rozhraní nemůže mít inicializátor. The event '{0}' can only appear on the left hand side of += or -= (except when used from within the type '{1}') Událost {0} se může zobrazovat jenom na levé straně výrazu += nebo -= (s výjimkou případu, kdy se používá z typu {1}). An explicit interface implementation of an event must use event accessor syntax Explicitní implementace rozhraní události musí používat syntaxi přistupujícího objektu události. '{0}': cannot override; '{1}' is not an event '{0}: Nejde přepsat; {1} není událost. An add or remove accessor must have a body Přistupující objekty add a remove musí mít tělo. '{0}': abstract event cannot have initializer '{0}: Abstraktní událost nemůže mít inicializátor. The assembly name '{0}' is reserved and cannot be used as a reference in an interactive session Název sestavení {0} je rezervovaný a nedá se použít jako odkaz v interaktivní relaci. The enumerator name '{0}' is reserved and cannot be used Název čítače výčtu {0} je rezervovaný a nedá se použít. The as operator must be used with a reference type or nullable type ('{0}' is a non-nullable value type) Operátor as je třeba použít s typem odkazu nebo s typem připouštějícím hodnotu null ({0} je typ hodnoty, který nepřipouští hodnotu null). The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity Přípona l je snadno zaměnitelná s číslicí 1. V zájmu větší srozumitelnosti použijte písmeno L. The 'l' suffix is easily confused with the digit '1' Přípona l je snadno zaměnitelná s číslicí 1. The event '{0}' can only appear on the left hand side of += or -= Událost {0} se může zobrazovat jenom na levé straně výrazu += nebo -=. Constraints are not allowed on non-generic declarations U neobecných deklarací nejsou povolená omezení. Type parameter declaration must be an identifier not a type Deklarace parametru typů musí být identifikátor, ne typ. Type '{1}' already reserves a member called '{0}' with the same parameter types Typ {1} už rezervuje člen s názvem {0} se stejnými typy parametrů. The parameter name '{0}' is a duplicate Název parametru {0} je duplicitní. The namespace '{1}' already contains a definition for '{0}' Obor názvů {1} už obsahuje definici pro {0}. The type '{0}' already contains a definition for '{1}' Typ {0} už obsahuje definici pro {1}. The name '{0}' does not exist in the current context Název {0} v aktuálním kontextu neexistuje. The name '{0}' does not exist in the current context (are you missing a reference to assembly '{1}'?) Název {0} v aktuálním kontextu neexistuje. (Nechybí odkaz na sestavení {1}?) '{0}' is an ambiguous reference between '{1}' and '{2}' '{0} je nejednoznačný odkaz mezi {1} a {2}. The using directive for '{0}' appeared previously in this namespace Direktiva using pro {0} se objevila už dřív v tomto oboru názvů. Using directive appeared previously in this namespace Direktiva Using se už v tomto oboru názvů objevila dříve. The modifier '{0}' is not valid for this item Modifikátor {0} není pro tuto položku platný. More than one protection modifier Víc než jeden modifikátor ochrany '{0}' hides inherited member '{1}'. Use the new keyword if hiding was intended. '{0} skryje zděděný člen {1}. Pokud je skrytí úmyslné, použijte klíčové slovo new. Member hides inherited member; missing new keyword Člen skrývá zděděný člen. Chybí klíčové slovo new. 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. Proměnná byla deklarovaná se stejným názvem jako proměnná v základní třídě. Klíčové slovo new se ale nepoužilo. Toto varování vás informuje, že byste měli použít new; proměnná je deklarovaná, jako by se v deklaraci používalo new. The member '{0}' does not hide an accessible member. The new keyword is not required. Člen {0} neskrývá přístupný člen. Klíčové slovo new se nevyžaduje. Member does not hide an inherited member; new keyword is not required Člen neskrývá zděděný člen. Klíčové slovo new se nevyžaduje. The evaluation of the constant value for '{0}' involves a circular definition Vyhodnocení konstantní hodnoty pro {0} zahrnuje cyklickou definici. Type '{1}' already defines a member called '{0}' with the same parameter types Typ {1} už definuje člen s názvem {0} se stejnými typy parametrů. A static member '{0}' cannot be marked as override, virtual, or abstract Statický člen {0} nemůže být označený klíčovými slovy override, virtual nebo abstract. A member '{0}' marked as override cannot be marked as new or virtual Člen {0} označený jako override nejde označit jako new nebo virtual. '{0}' hides inherited member '{1}'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword. 'Člen {0} skryje zděděný člen {1}. Pokud má aktuální člen tuto implementaci přepsat, přidejte klíčové slovo override. Jinak přidejte klíčové slovo new. Member hides inherited member; missing override keyword Člen skrývá zděděný člen. Chybí klíčové slovo override. '{0}': no suitable method found to override '{0}: Nenašla se vhodná metoda k přepsání. A namespace cannot directly contain members such as fields or methods Obor názvů nemůže přímo obsahovat členy, jako jsou pole a metody. '{0}' does not contain a definition for '{1}' '{0} neobsahuje definici pro {1}. '{0}' is a {1} but is used like a {2} '{0} je {1}, ale používá se jako {2}. '{0}' is a {1}, which is not valid in the given context '{0} je {1}, což není platné v daném kontextu. An object reference is required for the non-static field, method, or property '{0}' Pro nestatické pole, metodu nebo vlastnost {0} se vyžaduje odkaz na objekt. The call is ambiguous between the following methods or properties: '{0}' and '{1}' Volání je nejednoznačné mezi následujícími metodami nebo vlastnostmi: {0} a {1}. '{0}' is inaccessible due to its protection level 'Typ {0} je vzhledem k úrovni ochrany nepřístupný. No overload for '{0}' matches delegate '{1}' Žádná přetížená metoda {0} neodpovídá delegátovi {1}. An object of a type convertible to '{0}' is required Vyžaduje se objekt typu, který se dá převést na {0}. Since '{0}' returns void, a return keyword must not be followed by an object expression Protože {0} vrací void, nesmí za klíčovým slovem return následovat výraz objektu. A local variable or function named '{0}' is already defined in this scope Lokální proměnná nebo funkce s názvem {0} je už v tomto oboru definovaná. The left-hand side of an assignment must be a variable, property or indexer Levou stranou přiřazení musí být proměnná, vlastnost nebo indexer. '{0}': a static constructor must be parameterless '{0}: Statický konstruktor musí být bez parametrů. The expression being assigned to '{0}' must be constant Výraz přiřazovaný proměnné {0} musí být konstantou. '{0}' is of type '{1}'. A const field of a reference type other than string can only be initialized with null. '{0} je typu {1}. Pole const s jiným než řetězcovým typem odkazu jde inicializovat jenom hodnotou 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 Místní proměnná nebo parametr s názvem {0} se nedá deklarovat v tomto oboru, protože se tento název používá v uzavírajícím místním oboru pro definování místní proměnné nebo parametru. A 'using namespace' directive can only be applied to namespaces; '{0}' is a type not a namespace. Consider a 'using static' directive instead Direktivu using namespace jde uplatnit jenom u oborů názvů; {0} je typ, ne obor názvů. Zkuste radši použít direktivu using static. A 'using static' directive can only be applied to types; '{0}' is a namespace not a type. Consider a 'using namespace' directive instead Direktiva using static se dá použít jenom u typů; {0} je obor názvů, ne typ. Zkuste radši použít direktivu using namespace. A 'using static' directive cannot be used to declare an alias Direktiva using static se nedá použít k deklarování aliasu. No enclosing loop out of which to break or continue Příkazy break a continue nejsou uvedené ve smyčce. The label '{0}' is a duplicate Návěstí {0} je duplicitní. The type '{0}' has no constructors defined Pro typ {0} nejsou definované žádné konstruktory. Cannot create an instance of the abstract type or interface '{0}' Nejde vytvořit instanci abstraktní třídy nebo rozhraní {0}. A const field requires a value to be provided Pole const vyžaduje zadání hodnoty. Circular base type dependency involving '{0}' and '{1}' Prvky {0} a {1} jsou součástí cyklické závislosti základních tříd. The delegate '{0}' does not have a valid constructor Delegát {0} nemá platný konstruktor. Method name expected Očekává se název metody. A constant value is expected Očekává se konstantní hodnota. A switch expression or case label must be a bool, char, string, integral, enum, or corresponding nullable type in C# 6 and earlier. Výraz switch nebo popisek větve musí být bool, char, string, integral, enum nebo odpovídající typ s možnou hodnotou null v jazyce C# 6 nebo starším. A value of an integral type expected Očekává se hodnota integrálního typu. The switch statement contains multiple cases with the label value '{0}' Příkaz switch obsahuje víc případů s hodnotou návěstí {0}. A goto case is only valid inside a switch statement Příkaz goto case je platný jenom uvnitř příkazu switch. The property or indexer '{0}' cannot be used in this context because it lacks the get accessor Vlastnost nebo indexer {0} nejde v tomto kontextu použít, protože neobsahuje přistupující objekt get. The type caught or thrown must be derived from System.Exception Zachycený nebo vyvolaný typ musí být odvozený od třídy System.Exception. A throw statement with no arguments is not allowed outside of a catch clause Příkaz throw bez argumentů není povolený vně klauzule catch. Control cannot leave the body of a finally clause Řízení nemůže opustit tělo klauzule finally. The label '{0}' shadows another label by the same name in a contained scope Návěstí {0} stíní v obsaženém oboru jiné návěstí se stejným názvem. No such label '{0}' within the scope of the goto statement V rozsahu příkazu goto není žádné takové návěstí {0}. A previous catch clause already catches all exceptions of this or of a super type ('{0}') Předchozí klauzule catch už zachytává všechny výjimky vyvolávané tímto typem nebo nadtypem ({0}). Filter expression is a constant 'true', consider removing the filter Výraz filtru je konstantní hodnota true. Zvažte odebrání filtru. Filter expression is a constant 'true' Výraz filtru je konstantní hodnota true. '{0}': not all code paths return a value '{0}: Ne všechny cesty kódu vrací hodnotu. Unreachable code detected Byl zjištěn nedosažitelný kód. Unreachable code detected Byl zjištěn nedosažitelný kód. Control cannot fall through from one case label ('{0}') to another Řízení se nedá předat z jednoho návěstí příkazu case ({0}) do jiného. This label has not been referenced Na tuto jmenovku se neodkazuje. This label has not been referenced Na tuto jmenovku se neodkazuje. Use of unassigned local variable '{0}' Použila se nepřiřazená lokální proměnná {0}. The variable '{0}' is declared but never used Proměnná {0} je deklarovaná, ale nikdy se nepoužívá. Variable is declared but never used Proměnná je deklarovaná, ale nikdy se nepoužívá. The field '{0}' is never used Pole {0} se nikdy nepoužívá. Field is never used Pole se nikdy nepoužívá. Use of possibly unassigned field '{0}' Použila se možná nepřiřazené pole {0}. Use of possibly unassigned auto-implemented property '{0}' Použití pravděpodobně nepřiřazené automaticky implementované vlastnosti {0} Field '{0}' must be fully assigned before control is returned to the caller Před předáním řízení volající proceduře musí být pole {0} plně přiřazené. Type of conditional expression cannot be determined because '{0}' and '{1}' implicitly convert to one another Typ podmíněného výrazu nejde určit, protože {0} a {1} se implicitně převádějí jeden na druhého. Type of conditional expression cannot be determined because there is no implicit conversion between '{0}' and '{1}' Nejde zjistit typ podmíněného výrazu, protože mezi typy {0} a {1} nedochází k implicitnímu převodu A base class is required for a 'base' reference Pro odkaz base se vyžaduje základní typ. Use of keyword 'base' is not valid in this context Použití klíčového slova base není v tomto kontextu platné. Member '{0}' cannot be accessed with an instance reference; qualify it with a type name instead K členovi {0} nejde přistupovat pomocí odkazu na instanci. Namísto toho použijte kvalifikaci pomocí názvu typu. The out parameter '{0}' must be assigned to before control leaves the current method Parametr out {0} se musí přiřadit ještě předtím, než aktuální metoda předá řízení. Invalid rank specifier: expected ',' or ']' Specifikátor rozsahu je neplatný. Očekávala se čárka (,) nebo pravá hranatá závorka ]. '{0}' cannot be extern and declare a body '{0} nemůže být extern a deklarovat tělo. '{0}' cannot be extern and have a constructor initializer '{0} nemůže být extern a mít inicializátor konstruktoru. '{0}' cannot be both extern and abstract '{0} nemůže být extern i abstract. Attribute constructor parameter '{0}' has type '{1}', which is not a valid attribute parameter type Parametr {0} konstruktoru atributu má typ {1}, což není platný typ pro parametr atributu. An attribute argument must be a constant expression, typeof expression or array creation expression of an attribute parameter type Argumentem atributu musí být konstantní výraz, výraz typeof nebo výraz vytvoření pole s typem parametru atributu. Attribute constructor parameter '{0}' is optional, but no default parameter value was specified. Parametr {0} konstruktoru atributu je nepovinný, ale nebyla zadaná žádná výchozí hodnota parametru. The given expression is always of the provided ('{0}') type Tento výraz je vždy zadaného typu ({0}). 'is' expression's given expression is always of the provided type 'Daný výraz is je vždycky zadaného typu. The given expression is never of the provided ('{0}') type Tento výraz nikdy není zadaného typu ({0}). 'is' expression's given expression is never of the provided type 'Daný výraz is není nikdy zadaného typu. '{0}' is not a reference type as required by the lock statement '{0} není typu odkaz, jak vyžaduje příkaz lock Use of null is not valid in this context Použití hodnoty NULL není v tomto kontextu platné. Use of default literal is not valid in this context Použití výchozího literálu není v tomto kontextu platné. The 'this' object cannot be used before all of its fields have been assigned Objekt this nejde použít, dokud není provedeno přiřazení do všech jeho polí. The __arglist construct is valid only within a variable argument method Konstrukce __arglist je platná jenom v rámci metody s proměnnými argumenty. The * or -> operator must be applied to a pointer Operátor * nebo -> musí být použitý u ukazatele. A pointer must be indexed by only one value Ukazatel může být indexován jenom jednou hodnotou. 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 Použití prvku {0} jako hodnoty Ref nebo Out nebo převzetí jeho adresy může způsobit výjimku při běhu, protože se jedná o pole třídy marshal-by-reference. Using a field of a marshal-by-reference class as a ref or out value or taking its address may cause a runtime exception Použití pole třídy marshal-by-reference jako hodnoty Ref nebo Out nebo převzetí jeho adresy může způsobit běhovou výjimku. A static readonly field cannot be assigned to (except in a static constructor or a variable initializer) Do statického pole určeného jen pro čtení nejde přiřazovat (kromě případu, kdy se nachází uvnitř statického konstruktoru nebo inicializátoru proměnné). A static readonly field cannot be used as a ref or out value (except in a static constructor) Statické pole určené jen pro čtení nejde použít jako hodnotu Ref nebo Out (kromě případu, kdy se nachází uvnitř statického konstruktoru). Property or indexer '{0}' cannot be assigned to -- it is read only Vlastnost nebo indexer {0} nejde přiřadit – je jen pro čtení. Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement Jako příkaz jde použít jenom objektové výrazy přiřazení, volání, zvýšení nebo snížení hodnoty nebo výrazy obsahující operátor new. foreach requires that the return type '{0}' of '{1}' must have a suitable public 'MoveNext' method and public 'Current' property Příkaz foreach vyžaduje, aby typ vracených hodnot {0} pro {1} měl vhodnou veřejnou metodu MoveNext a veřejnou vlastnost Current. Only 65534 locals, including those generated by the compiler, are allowed Je povolených jenom 65 534 lokálních proměnných, včetně těch, které generuje kompilátor. Cannot call an abstract base member: '{0}' Nejde volat abstraktní základní člen: {0}. A property or indexer may not be passed as an out or ref parameter Vlastnost nebo indexer nejde předat jako parametr ref nebo out. Cannot take the address of, get the size of, or declare a pointer to a managed type ('{0}') Nejde převzít adresu proměnné spravovaného typu ({0}), získat její velikost nebo deklarovat ukazatel na ni. The type of a local declared in a fixed statement must be a pointer type Lokální proměnná deklarovaná v příkazu fixed musí být typu ukazatel. You must provide an initializer in a fixed or using statement declaration V deklaracích příkazů fixed a using je nutné zadat inicializátor. Cannot take the address of the given expression Nejde převzít adresu daného výrazu. You can only take the address of an unfixed expression inside of a fixed statement initializer Adresu volného výrazu jde převzít jenom uvnitř inicializátoru příkazu fixed. You cannot use the fixed statement to take the address of an already fixed expression K převzetí adresy výrazu, který je už nastavený jako pevný, nejde použít příkaz fixed. Pointers and fixed size buffers may only be used in an unsafe context Ukazatele a vyrovnávací paměti pevné velikosti jde použít jenom v nezabezpečeném kontextu. The return type of operator True or False must be bool Vrácená hodnota operátorů True a False musí být typu bool. The operator '{0}' requires a matching operator '{1}' to also be defined Operátor {0} vyžaduje, aby byl definovaný i odpovídající operátor {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 Pokud má být uživatelem definovaný logický operátor ({0}) použitelný jako operátor zkráceného vyhodnocení, musí vracet hodnotu stejného typu a mít stejné typy parametrů. In order for '{0}' to be applicable as a short circuit operator, its declaring type '{1}' must define operator true and operator false Aby byl {0} použitelný jako operátor zkráceného vyhodnocení, musí jeho deklarující typ {1} definovat operátor true a operátor false. The variable '{0}' is assigned but its value is never used Proměnná {0} má přiřazenou hodnotu, ale nikdy se nepoužívá. Variable is assigned but its value is never used Proměnná má přiřazenou hodnotu, ale nikdy se nepoužívá. The operation overflows at compile time in checked mode Během kompilace v režimu kontroly došlo k přetečení. Constant value '{0}' cannot be converted to a '{1}' (use 'unchecked' syntax to override) Konstantní hodnotu {0} nejde převést na typ {1} (k přepsání jde použít syntaxi unchecked). A method with vararg cannot be generic, be in a generic type, or have a params parameter Metoda s parametrem vararg nemůže být obecná, být obecného typu nebo mít pole parametr params. The params parameter must be a single dimensional array Parametr params musí být jednorozměrné pole. An __arglist expression may only appear inside of a call or new expression Výraz __arglist může být jedině uvnitř volání nebo výrazu new. Unsafe code may only appear if compiling with /unsafe Nebezpečný kód může vzniknout jenom při kompilaci s přepínačem /unsafe. Ambiguity between '{0}' and '{1}' Došlo k nejednoznačnosti mezi metodami nebo vlastnostmi {0} a {1}. Type and identifier are both required in a foreach statement V příkazu foreach se vyžaduje typ i identifikátor. A params parameter must be the last parameter in a formal parameter list Parametr params musí být posledním parametrem v seznamu formálních parametrů. '{0}' does not have a predefined size, therefore sizeof can only be used in an unsafe context {0} nemá předdefinovanou velikost. Operátor sizeof jde proto použít jenom v nezabezpečeném kontextu. The type or namespace name '{0}' does not exist in the namespace '{1}' (are you missing an assembly reference?) Typ nebo název oboru názvů {0} neexistuje v oboru názvů {1}. (Nechybí odkaz na sestavení?) A field initializer cannot reference the non-static field, method, or property '{0}' Inicializátor pole nemůže odkazovat na nestatické pole, metodu nebo vlastnost {0}. '{0}' cannot be sealed because it is not an override '{0} nejde zapečetit, protože to není přepis. '{0}': cannot override inherited member '{1}' because it is sealed '{0}: Nejde přepsat zděděný člen {1}, protože je zapečetěný. The operation in question is undefined on void pointers Příslušná operace není definovaná pro ukazatele typu void. The Conditional attribute is not valid on '{0}' because it is an override method Atribut Conditional není pro {0} platný, protože je to metoda override. Neither 'is' nor 'as' is valid on pointer types Klíčová slova is a as nejsou platná pro ukazatele. Destructors and object.Finalize cannot be called directly. Consider calling IDisposable.Dispose if available. Destruktory a metodu object.Finalize nejde volat přímo. Zvažte možnost volání metody IDisposable.Dispose, pokud je k dispozici. The type or namespace name '{0}' could not be found (are you missing a using directive or an assembly reference?) Typ nebo název oboru názvů {0} se nenašel. (Nechybí direktiva using nebo odkaz na sestavení?) Cannot use a negative size with stackalloc Ve výrazu stackalloc nejde použít zápornou velikost. Cannot create an array with a negative size Nejde vytvořit pole se zápornou velikostí. Do not override object.Finalize. Instead, provide a destructor. Nepřepisujte metodu object.Finalize. Raději použijte destruktor. Do not directly call your base type Finalize method. It is called automatically from your destructor. Nevolejte přímo metodu Finalize základní třídy. Tuto metodu volá automaticky destruktor. Indexing an array with a negative index (array indices always start at zero) Došlo k indexování pole záporným indexem (indexy polí vždy začínají hodnotou 0). Indexing an array with a negative index Došlo k indexování pole záporným indexem. Possible unintended reference comparison; to get a value comparison, cast the left hand side to type '{0}' Možná došlo k neúmyslnému porovnání ukazatelů; chcete-li porovnat hodnoty, přetypujte levou stranu na typ {0}. Possible unintended reference comparison; left hand side needs cast Pravděpodobně došlo k neúmyslnému porovnání odkazů. Je třeba přetypovat levou stranu. Possible unintended reference comparison; to get a value comparison, cast the right hand side to type '{0}' Možná došlo k neúmyslnému porovnání ukazatelů; chcete-li porovnat hodnoty, přetypujte pravou stranu na typ {0}. Possible unintended reference comparison; right hand side needs cast Pravděpodobně došlo k neúmyslnému porovnání odkazů. Je třeba přetypovat pravou stranu. The right hand side of a fixed statement assignment may not be a cast expression Pravá strana přiřazení příkazu fixed nemůže být výrazem přetypování. stackalloc may not be used in a catch or finally block Výraz stackalloc nejde použít v bloku catch nebo finally. An __arglist parameter must be the last parameter in a formal parameter list Parametr __arglist musí být posledním parametrem v seznamu formálních parametrů. Missing partial modifier on declaration of type '{0}'; another partial declaration of this type exists Chybí částečný modifikátor deklarace typu {0}; existuje jiná částečná deklarace tohoto typu. Partial declarations of '{0}' must be all classes, all records, all structs, or all interfaces Částečné deklarace {0} musí být jen třídy, jen struktury, nebo jen rozhraní. Partial declarations of '{0}' have conflicting accessibility modifiers Částečné deklarace {0} mají konfliktní modifikátory dostupnosti. Partial declarations of '{0}' must not specify different base classes Částečné deklarace {0} nesmí určovat různé základní třídy. Partial declarations of '{0}' must have the same type parameter names in the same order Částečné deklarace {0} musí mít stejné názvy parametrů typů ve stejném pořadí. Partial declarations of '{0}' have inconsistent constraints for type parameter '{1}' Částečné deklarace {0} mají nekonzistentní omezení parametru typu {1}. Cannot implicitly convert type '{0}' to '{1}'. An explicit conversion exists (are you missing a cast?) Typ {0} nejde implicitně převést na typ {1}. Existuje explicitní převod. (Nechybí výraz přetypování?) The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method return type. Modifikátor partial se smí objevit jenom bezprostředně před klíčovým slovem class, struct, interface nebo void. Imported type '{0}' is invalid. It contains a circular base type dependency. Importovaný typ {0} je neplatný. Obsahuje cyklickou závislost základních tříd. Use of unassigned out parameter '{0}' Použil se nepřiřazený parametr out {0}. Array size cannot be specified in a variable declaration (try initializing with a 'new' expression) Velikost pole nejde určit v deklaraci proměnné (zkuste inicializaci pomocí výrazu new). The property or indexer '{0}' cannot be used in this context because the get accessor is inaccessible Vlastnost nebo indexer {0} nejde v tomto kontextu použít, protože přistupující objekt get není dostupný. The property or indexer '{0}' cannot be used in this context because the set accessor is inaccessible Vlastnost nebo indexer {0} nejde v tomto kontextu použít, protože přistupující objekt jet není dostupný. The accessibility modifier of the '{0}' accessor must be more restrictive than the property or indexer '{1}' Modifikátor dostupnosti přistupujícího objektu {0} musí být více omezující než vlastnost nebo indexer {1}. Cannot specify accessibility modifiers for both accessors of the property or indexer '{0}' Nejde zadat modifikátory dostupnosti pro přistupující objekty jak vlastnosti, tak i indexer {0}. '{0}': accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor '{0}: Modifikátory přístupnosti u přistupujících objektů se můžou používat, jenom pokud vlastnost nebo indexeru má přistupující objekt get i set. '{0}' does not implement interface member '{1}'. '{2}' is not public. '{0} neimplementuje člen rozhraní {1}. {2} není veřejný. '{0}' does not implement the '{1}' pattern. '{2}' is ambiguous with '{3}'. '{0} neimplementuje vzorek {1}. {2} je nejednoznačný vzhledem k: {3}. Type does not implement the collection pattern; members are ambiguous Typ neimplementuje vzorek kolekce. Členové nejsou jednoznační. '{0}' does not implement the '{1}' pattern. '{2}' has the wrong signature. '{0} neimplementuje vzorek {1}. {2} nemá správný podpis. Type does not implement the collection pattern; member has the wrong signature Typ neimplementuje vzorek kolekce. Člen nemá správný podpis. 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. Sestavení {0} udělilo přístup typu Friend, ale veřejný klíč výstupního sestavení ({1}) neodpovídá klíči určenému atributem InternalsVisibleTo v udělujícím sestavení. Friend access was granted by '{0}', but the strong name signing state of the output assembly does not match that of the granting assembly. Sestavení {0} udělilo přístup typu Friend, ale stav podepsání silného názvu u výstupního sestavení neodpovídá stavu udělujícího sestavení. 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. Mezi poli více deklarací částečné třídy nebo struktury {0} není žádné definované řazení. Pokud chcete zadat řazení, musí být všechna pole instancí ve stejné deklaraci. There is no defined ordering between fields in multiple declarations of partial struct Není nadefinované řazení mezi poli ve více deklaracích částečné struktury. The type '{0}' cannot be declared const Typ {0} nemůže být deklarovaný jako const. Cannot create an instance of the variable type '{0}' because it does not have the new() constraint Nejde vytvořit instanci proměnné typu {0}, protože nemá omezení new(). Using the generic {1} '{0}' requires {2} type arguments Použití obecného prvku {1} {0} vyžaduje tento počet argumentů typů: {2}. The type '{0}' may not be used as a type argument Typ {0} nejde použít jako argument typu. The {1} '{0}' cannot be used with type arguments {1} {0} nejde použít s argumenty typů. The non-generic {1} '{0}' cannot be used with type arguments Neobecnou možnost {1} {0} nejde použít s argumenty typů. '{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}' 'Objekt {2} musí být neabstraktního typu s veřejným konstruktorem bez parametrů, jinak jej nejde použít jako parametr {1} v obecném typu nebo metodě {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}'. Typ {3} nejde použít jako parametr typu {2} v obecném typu nebo metodě {0}. Neexistuje žádný implicitní převod odkazu z {3} na {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}'. Typ {3} nejde použít jako parametr typu {2} v obecném typu nebo metodě {0}. Typ {3} s možnou hodnotou null nevyhovuje omezení {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. Typ {3} nejde použít jako parametr typu {2} v obecném typu nebo metodě {0}. Typ {3} s možnou hodnotou null nevyhovuje omezení {1}. Typy s možnou hodnotou null nemůžou vyhovět žádným omezením rozhraní. 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}'. Typ {3} nejde použít jako parametr typu {2} v obecném typu nebo metodě {0}. Neexistuje žádný převod na uzavřené určení ani převod typu parametru z {3} na {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}'. Typ {3} nejde použít jako parametr typu {2} v obecném typu nebo metodě {0}. Neexistuje žádný převod na uzavřené určení z {3} na {1}. The parameter name '{0}' conflicts with an automatically-generated parameter name Název parametru {0} je v konfliktu s automaticky generovaným názvem parametru. The type or namespace name '{0}' could not be found in the global namespace (are you missing an assembly reference?) Typ nebo název oboru názvů {0} se nenašel v globálním oboru názvů. (Nechybí odkaz na sestavení?) The new() constraint must be the last constraint specified Omezení new() musí být poslední zadané omezení. '{0}': an entry point cannot be generic or in a generic type '{0}: Vstupní bod nemůže být obecný nebo v obecném typu. An entry point cannot be generic or in a generic type Vstupní bod nemůže být obecný nebo v obecném typu. Cannot convert null to type parameter '{0}' because it could be a non-nullable value type. Consider using 'default({0})' instead. Hodnotu Null nejde převést na parametr typu {0}, protože by se mohlo jednat o typ, který nemůže mít hodnotu null. Zvažte možnost použití výrazu default({0}). Cannot apply attribute class '{0}' because it is generic Nejde použít třídu atributů {0}, protože je obecná. Duplicate constraint '{0}' for type parameter '{1}' Duplicitní omezení {0} pro parametru typu {1} The class type constraint '{0}' must come before any other constraints Omezení typu třídy {0} musí předcházet všem dalším omezením. '{1} {0}' has the wrong return type '{1} {0} má nesprávný návratový typ. Ref mismatch between '{0}' and delegate '{1}' Mezi {0} a delegátem {1} se neshoduje odkaz. 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. Klauzule omezení už byla přidaná pro parametr typu {0}. Všechna omezení pro parametr typu musí být zadaná v jediné klauzuli where. The type arguments for method '{0}' cannot be inferred from the usage. Try specifying the type arguments explicitly. Argumenty typu pro metodu {0} nejde stanovit z použití. Zadejte argumenty typu explicitně. '{0}': a parameter, local variable, or local function cannot have the same name as a method type parameter '{0}: Parametr, místní proměnná nebo místní funkce nemůžou mít stejný název jako parametr typů metod. The type parameter '{0}' cannot be used with the 'as' operator because it does not have a class type constraint nor a 'class' constraint Parametr typu {0} nejde používat s operátorem as, protože nemá omezení typu třída ani omezení class. The field '{0}' is assigned but its value is never used Pole {0} má přiřazenou hodnotu, ale nikdy se nepoužívá. Field is assigned but its value is never used Pole má přiřazenou hodnotu, ale nikdy se nepoužívá. The '{0}' attribute is valid only on an indexer that is not an explicit interface member declaration Atribut {0} je platný jenom pro indexer, který nepředstavuje explicitní deklaraci člena rozhraní. '{0}': an attribute argument cannot use type parameters '{0}: Argument atributu nemůže používat parametry typů. '{0}': cannot provide arguments when creating an instance of a variable type '{0}: Při vytváření instance typu proměnné nejde zadat argumenty. '{0}': an abstract type cannot be sealed or static '{0}: Abstraktní třída nemůže být sealed nebo static. Ambiguous reference in cref attribute: '{0}'. Assuming '{1}', but could have also matched other overloads including '{2}'. Nejednoznačný odkaz v atributu cref: {0}. Předpokládá se {1}, ale mohla se najít shoda s dalšími přetíženími, včetně {2}. Ambiguous reference in cref attribute Nejednoznačný odkaz v atributu cref '{0}': a reference to a volatile field will not be treated as volatile '{0}: Odkaz na pole s modifikátorem volatile se nezpracuje jako volatile. A reference to a volatile field will not be treated as volatile Odkaz na pole s modifikátorem volatile se nezpracuje jako volatile. 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. Pole s modifikátorem volatile by se normálně mělo používat jako hodnota Ref nebo Out, protože se s ním nebude zacházet jako s nestálým. Pro toto pravidlo platí výjimky, například při volání propojeného API. Since '{1}' has the ComImport attribute, '{0}' must be extern or abstract Protože {1} má atribut ComImport, {0} musí být externí nebo abstraktní. '{0}': a class with the ComImport attribute cannot specify a base class '{0}: Třída s atributem ComImport nemůže určovat základní třídu. 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. Omezení pro parametr typu {0} metody {1} se musí shodovat s omezeními u parametru typu {2} metody rozhraní {3}. Místo toho zvažte použití explicitní implementace rozhraní. 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). Názvy prvků řazené kolekce členů v signatuře metody {0} se musí shodovat s názvy prvků řazené kolekce členů metody rozhraní {1} (a zároveň u návratového typu). The type name '{0}' does not exist in the type '{1}' Název typu {0} neexistuje v typu {1}. Cannot convert method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method? Nejde převést skupinu metod {0} na nedelegující typ {1}. Chtěli jste volat tuto metodu? The extern alias '{0}' was not specified in a /reference option Externí alias {0} nebyl zadaný jako možnost /reference. Cannot use alias '{0}' with '::' since the alias references a type. Use '.' instead. Zápis aliasu {0} se dvěma dvojtečkami (::) nejde použít, protože alias odkazuje na typ. Místo toho použijte zápis s tečkou (.). Alias '{0}' not found Alias {0} se nenašel. The type '{1}' exists in both '{0}' and '{2}' Typ {1} existuje v {0} i {2}. The namespace '{1}' in '{0}' conflicts with the type '{3}' in '{2}' Obor názvů {1} v {0} je v konfliktu s typem {3} v {2}. The namespace '{1}' in '{0}' conflicts with the imported type '{3}' in '{2}'. Using the namespace defined in '{0}'. Obor názvů {1} v {0} je v konfliktu s importovaným typem {3} v {2}. Použije se obor názvů definovaný v {0}. Namespace conflicts with imported type Obor názvů je v konfliktu s importovaným typem. The type '{1}' in '{0}' conflicts with the imported type '{3}' in '{2}'. Using the type defined in '{0}'. Typ {1} v {0} je v konfliktu s importovaným typem {3} v {2}. Použije se typ definovaný v {0}. Type conflicts with imported type Typ je v konfliktu s importovaným typem. The type '{1}' in '{0}' conflicts with the imported namespace '{3}' in '{2}'. Using the type defined in '{0}'. Typ {1} v {0} je v konfliktu s importovaným oborem názvů {3} v {2}. Použije se typ definovaný v {0}. Type conflicts with imported namespace Typ je v konfliktu s importovaným oborem názvů. The type '{1}' in '{0}' conflicts with the namespace '{3}' in '{2}' Typ {1} v {0} je v konfliktu s oborem názvů {3} v {2}. An extern alias declaration must precede all other elements defined in the namespace Deklarace externího aliasu musí předcházet všem ostatním prvkům definovaným v oboru názvů. Defining an alias named 'global' is ill-advised since 'global::' always references the global namespace and not an alias Definování aliasu s názvem global se nedoporučuje, protože global:: vždycky odkazuje na globální obor názvů, ne na alias. Defining an alias named 'global' is ill-advised Definování aliasu s názvem global se nedoporučuje. '{0}': a type cannot be both static and sealed '{0}: Třída nemůže být zároveň statická i zapečetěná. '{0}': abstract properties cannot have private accessors '{0}: Abstraktní vlastnosti nemůžou mít privátní přistupující objekty. Syntax error; value expected Chyba syntaxe: Očekávala se hodnota. Cannot modify the result of an unboxing conversion Nejde změnit výsledek unboxingového převodu. Foreach cannot operate on a '{0}'. Did you intend to invoke the '{0}'? Příkaz foreach nejde použít pro {0}. Měli jste v úmyslu vyvolat {0}? The return type for ++ or -- operator must match the parameter type or be derived from the parameter type Typ vrácené hodnoty operátorů ++ a -- musí odpovídat danému typu parametru nebo z něho musí být odvozený. '{0}': cannot specify both a constraint class and the 'class' or 'struct' constraint '{0}: Nejde zadat třídu omezení a zároveň omezení class nebo struct. The 'new()' constraint cannot be used with the 'struct' constraint Omezení new() nejde používat s omezením struct. The type '{2}' must be a reference type in order to use it as parameter '{1}' in the generic type or method '{0}' Typ {2} musí být typ odkazu, aby ho bylo možné používat jako parametr {1} v obecném typu nebo metodě {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}' Typ {2} musí být typ, který nemůže mít hodnotu null, aby ho bylo možné používat jako parametr {1} v obecném typu nebo metodě {0}. Circular constraint dependency involving '{0}' and '{1}' Cyklická závislost omezení zahrnující {0} a {1} Type parameter '{0}' inherits conflicting constraints '{1}' and '{2}' Parametr typu {0} dědí konfliktní omezení {1} a {2}. Type parameter '{1}' has the 'struct' constraint so '{1}' cannot be used as a constraint for '{0}' Parametr typu {1} má omezení struct, takže není možné používat {1} jako omezení pro {0}. Ambiguous user defined conversions '{0}' and '{1}' when converting from '{2}' to '{3}' Při převodu typu {2} na typ {3} došlo k uživatelem definovaným nejednoznačným převodům typu {0} na typ {1}. The result of the expression is always 'null' of type '{0}' Výsledek výrazu je vždy hodnota null typu {0}. The result of the expression is always 'null' Výsledek výrazu je vždycky null. Cannot return 'this' by reference. Nejde vrátit this pomocí odkazu. Cannot use attribute constructor '{0}' because it has 'in' parameters. Nejde použít konstruktor atributu {0}, protože má parametry 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. Omezení pro metody přepsání a explicitní implementace rozhraní se dědí ze základní metody, nejde je tedy zadat přímo, s výjimkou omezení class nebo struct. The inherited members '{0}' and '{1}' have the same signature in type '{2}', so they cannot be overridden Zděděné členy {0} a {1} mají stejný podpis v typu {2}, takže je nejde přepsat. Evaluation of the decimal constant expression failed Vyhodnocování výrazu desítkové konstanty se nepovedlo. Comparing with null of type '{0}' always produces 'false' Výsledkem porovnání s hodnotou null typu {0} je vždycky false. Comparing with null of struct type always produces 'false' Výsledkem porovnání s typem struct je vždycky false. Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor? Zavedení metody Finalize může vést k potížím s voláním destruktoru. Měli jste v úmyslu deklarovat destruktor? Introducing a 'Finalize' method can interfere with destructor invocation Zavedení metody Finalize se může rušit s vyvoláním destruktoru. 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. Toto varování se objeví, pokud vytvoříte třídu s metodou, jejíž podpis je veřejný virtuální void Finalize. Pokud se taková třída používá jako základní třída a pokud odvozující třída definuje destruktor, přepíše tento destruktor metodu Finalize základní třídy, ne samotné Finalize. '{0}' should not have a params parameter since '{1}' does not 'Pro {0} by neměl být nastavený parametr params, protože {1} ho nemá. The 'goto case' value is not implicitly convertible to type '{0}' Hodnotu goto case nejde implicitně převést na typ {0}. The 'goto case' value is not implicitly convertible to the switch type Hodnotu goto case nejde implicitně převést na typ přepínače. Method '{0}' cannot implement interface accessor '{1}' for type '{2}'. Use an explicit interface implementation. Metoda {0} nemůže implementovat přistupující objekt rozhraní {1} pro typ {2}. Použijte explicitní implementaci rozhraní. The result of the expression is always '{0}' since a value of type '{1}' is never equal to 'null' of type '{2}' Výsledek výrazu je vždycky {0}, protože hodnota typu {1} se nikdy nerovná hodnotě null typu {2}. The result of the expression is always the same since a value of this type is never equal to 'null' Výsledek výrazu je vždycky stejný, protože hodnota tohoto typu se nikdy nerovná hodnotě null. The result of the expression is always '{0}' since a value of type '{1}' is never equal to 'null' of type '{2}' Výsledek výrazu je vždycky {0}, protože hodnota typu {1} se nikdy nerovná hodnotě null typu {2}. The result of the expression is always the same since a value of this type is never equal to 'null' Výsledek výrazu je vždycky stejný, protože hodnota tohoto typu se nikdy nerovná hodnotě 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. Explicitní implementace rozhraní {0} odpovídá víc než jednomu členovi rozhraní. Konkrétní výběr člena rozhraní závisí na implementaci. Zvažte možnost použití neexplicitní implementace. Explicit interface implementation matches more than one interface member Explicitní implementace rozhraní se shoduje s víc než jedním členem rozhraní. '{0}' cannot declare a body because it is marked abstract '{0} nemůže deklarovat tělo, protože je označené jako abstraktní. '{0}' must declare a body because it is not marked abstract, extern, or partial '{0} musí deklarovat tělo, protože je označené jako abstraktní, externí nebo částečné. '{0}' cannot be both abstract and sealed '{0} nemůže být extern i sealed. The abstract {0} '{1}' cannot be marked virtual Abstraktní {0} {1} nelze označit jako virtuální. The constant '{0}' cannot be marked static Konstanta {0} nemůže být označená jako statická. '{0}': cannot override because '{1}' is not a function '{0}: Nejde přepsat, protože {1} není funkce. '{0}': cannot override inherited member '{1}' because it is not marked virtual, abstract, or override '{0}: Nejde přepsat zděděný člen {1}, protože není označený jako virtuální, abstraktní nebo přepis. '{0}': cannot change access modifiers when overriding '{1}' inherited member '{2}' '{0}: Při přepsání {1} zděděného členu {2} nejde měnit modifikátory přístupu. '{0}': cannot change tuple element names when overriding inherited member '{1}' '{0}: při přepisu zděděného člena {1} nelze změnit prvek řazené kolekce členů. '{0}': return type must be '{2}' to match overridden member '{1}' '{0}: Návratový typ musí být {2}, aby odpovídal přepsanému členu {1}. '{0}': cannot derive from sealed type '{1}' '{0}: Nejde odvozovat ze zapečetěného typu {1}. '{0}' is abstract but it is contained in non-abstract type '{1}' '{0} je abstrakní, ale je obsažená v neabstraktní třídě {1}. '{0}': static constructor cannot have an explicit 'this' or 'base' constructor call '{0}: Statický konstruktor nemůže používat explicitní volání konstruktoru this nebo base. '{0}': access modifiers are not allowed on static constructors '{0}: Modifikátory přístupu nejsou povolené pro statické konstruktory. Constructor '{0}' cannot call itself Konstruktor {0} nemůže volat sám sebe. Constructor '{0}' cannot call itself through another constructor Konstruktor {0} nemůže volat sám sebe přes jiný konstruktor. '{0}' has no base class and cannot call a base constructor '{0} nemá žádnou základní třídu a nemůže volat konstruktor base. Predefined type '{0}' is not defined or imported Předdefinovaný typ {0} není definovaný ani importovaný. Predefined type '{0}' is not defined or imported Předdefinovaný typ {0} není definovaný ani importovaný. Predefined type '{0}' is declared in multiple referenced assemblies: '{1}' and '{2}' Předdefinovaný typ {0} je deklarovaný v několika odkazovaných sestaveních: {1} a {2}. '{0}': structs cannot call base class constructors '{0}: Struktury nemůžou volat konstruktor základní třídy. Struct member '{0}' of type '{1}' causes a cycle in the struct layout Člen struktury {0} typu {1} způsobuje cyklus v rozložení struktury. Interfaces cannot contain instance fields Rozhraní nemůžou obsahovat pole instance. Interfaces cannot contain instance constructors Rozhraní nemůžou obsahovat konstruktory instance. Type '{0}' in interface list is not an interface Typ {0} v seznamu rozhraní není rozhraní. '{0}' is already listed in interface list '{0} je už uvedené v seznamu rozhraní. '{0}' is already listed in the interface list on type '{2}' with different tuple element names, as '{1}'. '{0} je již uvedeno v seznamu rozhraní u typu {2} s jinými názvy prvků řazené kolekce členů jako {1}. Inherited interface '{1}' causes a cycle in the interface hierarchy of '{0}' Zděděné rozhraní {1} způsobuje cyklus v hierarchii rozhraní {0}. '{0}' hides inherited abstract member '{1}' '{0} skryje zděděný abstraktní člen {1}. '{0}' does not implement inherited abstract member '{1}' '{0} neimplementuje zděděný abstraktní člen {1}. '{0}' does not implement interface member '{1}' '{0} neimplementuje člen rozhraní {1}. The class System.Object cannot have a base class or implement an interface Třída System.Object nemůže mít základní třídu ani nemůže implementovat rozhraní. '{0}' in explicit interface declaration is not an interface '{0} v explicitní deklaraci rozhraní není rozhraní. '{0}' in explicit interface declaration is not found among members of the interface that can be implemented {0} v explicitní deklaraci rozhraní se nenašel mezi členy rozhraní, které se dají implementovat. '{0}': containing type does not implement interface '{1}' '{0}: Nadřazený typ neimplementuje rozhraní {1}. '{0}': explicit interface declaration can only be declared in a class, record, struct or interface {0}: Explicitní deklaraci rozhraní jde použít jenom ve třídě, struktuře nebo rozhraní. '{0}': member names cannot be the same as their enclosing type '{0}: Názvy členů nemůžou být stejné jako názvy jejich nadřazených typů. '{0}': the enumerator value is too large to fit in its type '{0}: Hodnota výčtu je pro příslušný typ moc velká. '{0}': cannot override because '{1}' is not a property '{0}: Nejde přepsat, protože {1} není vlastnost. '{0}': cannot override because '{1}' does not have an overridable get accessor '{0}: Nejde přepsat, protože {1} neobsahuje přepsatelný přistupující objekt get. '{0}': cannot override because '{1}' does not have an overridable set accessor '{0}: Nejde přepsat, protože {1} neobsahuje přepsatelný přistupující objekt set. '{0}': property or indexer cannot have void type '{0}: Vlastnost nebo indexer nemůže být typu void. '{0}': property or indexer must have at least one accessor '{0}: Vlastnost nebo indexer musí obsahovat aspoň jeden přistupující objekt. '{0}' is a new virtual member in sealed type '{1}' '{0} je nový virtuální člen v zapečetěné třídě {1}. '{0}' adds an accessor not found in interface member '{1}' '{0} přidává přistupující objekt, který se nenašel v členu rozhraní {1}. Explicit interface implementation '{0}' is missing accessor '{1}' V explicitní implementaci rozhraní {0} chybí přistupující objekt {1}. '{0}': user-defined conversions to or from an interface are not allowed '{0}: Uživatelem definované převody na rozhraní nebo z něho nejsou povolené. '{0}': user-defined conversions to or from a base type are not allowed '{0}: Uživatelem definované převody na základní třídu nebo z ní nejsou povolené. '{0}': user-defined conversions to or from a derived type are not allowed '{0}: Uživatelem definované převody na odvozenou třídu nebo z ní nejsou povolené. User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type Uživatelem definovaný operátor nemůže převzít objekt nadřazeného typu a převést jej na objekt nadřazeného typu. User-defined conversion must convert to or from the enclosing type Uživatelem definovaný převod musí převádět na nadřazený typ nebo z nadřazeného typu. Duplicate user-defined conversion in type '{0}' Duplicitní uživatelem definovaný převod v typu {0} User-defined operator '{0}' must be declared static and public Uživatelem definovaný operátor {0} musí být deklarovaný jako static a public. The parameter type for ++ or -- operator must be the containing type Typ parametru operátorů ++ a -- musí být nadřazeného typu. The parameter of a unary operator must be the containing type Parametr unárního operátoru musí být nadřazeného typu. One of the parameters of a binary operator must be the containing type Jeden z parametrů binárního operátoru musí být nadřazeného typu. 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 První operand přetěžovaného operátoru shift musí být stejného typu jako obsahující typ a druhý operand musí být typu int. Structs cannot contain explicit parameterless constructors Struktury nemůžou obsahovat explicitní konstruktory bez parametrů. Enums cannot contain explicit parameterless constructors Výčty nemůžou obsahovat explicitní konstruktory bez parametrů. '{0}': cannot override '{1}' because it is not supported by the language '{0} nemůže přepsat {1}, protože ho tento jazyk nepodporuje. '{0}' is not supported by the language '{0} není tímto jazykem podporovaný. '{0}': cannot explicitly call operator or accessor '{0}: Nejde explicitně volat operátor nebo přistupující objekt. '{0}': cannot reference a type through an expression; try '{1}' instead '{0}: Nemůže odkazovat na typ prostřednictvím výrazu. Místo toho zkuste {1}. '{0}': cannot have instance property or field initializers in structs '{0}: Vlastnosti instancí nebo inicializátory polí nemůžou být ve strukturách. Name of destructor must match name of type Název destruktoru musí odpovídat názvu třídy. Only class types can contain destructors Destruktor může být obsažený jenom v typu třída. Namespace '{1}' contains a definition conflicting with alias '{0}' Obor názvů {1} obsahuje definici, která je v konfliktu s aliasem {0}. Alias '{0}' conflicts with {1} definition Alias {0} je v konfliktu s definicí {1}. The Conditional attribute is not valid on '{0}' because it is a constructor, destructor, operator, or explicit interface implementation Atribut Conditional není pro {0} platný, protože je to konstruktor, destruktor, operátor nebo explicitní implementace rozhraní. The Conditional attribute is not valid on '{0}' because its return type is not void Atribut Conditional není pro {0} platný, protože jeho návratový kód není void. Duplicate '{0}' attribute Duplicitní atribut {0} Duplicate '{0}' attribute in '{1}' Duplicitní atribut {0} v {1} The Conditional attribute is not valid on interface members Pro členy rozhraní je atribut Conditional neplatný. User-defined operators cannot return void Operátory definované uživatelem nemůžou vracet typ void. '{0}': user-defined conversions to or from the dynamic type are not allowed '{0}: Uživatelsky definované převody na dynamický typ nebo z dynamického typu nejsou povolené. Invalid value for argument to '{0}' attribute Neplatná hodnota pro argument u atributu {0} Parameter not valid for the specified unmanaged type. Parametr není platný pro zadaný nespravovaný typ. Attribute parameter '{0}' must be specified. Parametr atributu {0} musí být zadaný. Attribute parameter '{0}' or '{1}' must be specified. Parametr atributu {0} nebo {1} musí být zadaný. Unmanaged type '{0}' not valid for fields. Nespravovaný typ {0} není platný pro pole. Unmanaged type '{0}' is only valid for fields. Nespravovaný typ {0} je platný jenom pro pole. Attribute '{0}' is not valid on this declaration type. It is only valid on '{1}' declarations. Atribut {0} není platný pro deklaraci tohoto typu. Je platný jenom pro deklarace {1}. Floating-point constant is outside the range of type '{0}' Konstanta s pohyblivou řádovou čárkou je mimo rozsah typu {0}. The Guid attribute must be specified with the ComImport attribute Atribut Guid musí být zadaný současně s atributem ComImport. Invalid value for named attribute argument '{0}' Neplatná hodnota argumentu {0} pojmenovaného atributu The DllImport attribute must be specified on a method marked 'static' and 'extern' Pro metodu s deklarací static a extern musí být zadaný atribut DllImport. Cannot update '{0}'; attribute '{1}' is missing. Nelze aktualizovat {0}; chybí atribut {1}. The DllImport attribute cannot be applied to a method that is generic or contained in a generic method or type. Atribut DllImport nejde použít u metody, která je obecná nebo obsažená v obecném typu. Field or property cannot be of type '{0}' Pole nebo vlastnost nemůže být typu {0}. Field or auto-implemented property cannot be of type '{0}' unless it is an instance member of a ref struct. Vlastnost pole nebo automaticky implementovaná vlastnost nemůže být typu {0}, pokud není členem instance struktury REF. Array elements cannot be of type '{0}' Prvky pole nemůžou být typu {0}. '{0}' is obsolete 'Prvek {0} je zastaralý. Type or member is obsolete Typ nebo člen je zastaralý. '{0}' is not an attribute class '{0} není třída atributu. '{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} není platný argument pojmenovaného atributu. Argumenty pojmenovaného atributu musí být pole, pro která nebyla použitá deklarace readonly, static ani const, nebo vlastnosti pro čtení i zápis, které jsou veřejné a nejsou statické. '{0}' is obsolete: '{1}' '{0} je zastaralá: {1}. Type or member is obsolete Typ nebo člen je zastaralý. '{0}' is obsolete: '{1}' '{0} je zastaralá: {1}. Indexers cannot have void type Indexer nemůže být typu void. '{0}': virtual or abstract members cannot be private '{0}: Virtuální nebo abstraktní členy nemůžou být privátní. Can only use array initializer expressions to assign to array types. Try using a new expression instead. Výrazy inicializátoru pole jde používat jenom pro přiřazení k typům pole. Zkuste použít výraz new. Array initializers can only be used in a variable or field initializer. Try using a new expression instead. Inicializátory pole jde používat jenom v inicializátoru pole nebo proměnné. Zkuste použít výraz new. '{0}': instance field in types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute {0}: Typy polí instance označené deklarací StructLayout(LayoutKind.Explicit) musí mít atribut 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. Metoda, operátor nebo přistupující objekt {0} je označený jako externí a nemá žádné atributy. Zvažte možnost přidání atributu DllImport k určení externí implementace. Method, operator, or accessor is marked external and has no attributes on it Metoda, operátor nebo přistupující objekt používá deklaraci external a nemá žádné atributy. '{0}': new protected member declared in sealed type '{0}: V zapečetěné třídě je deklarovaný nový chráněný člen. New protected member declared in sealed type V zapečetěné třídě je deklarovaný nový chráněný člen. Conditional member '{0}' cannot implement interface member '{1}' in type '{2}' Podmíněný člen {0} nemůže implementovat člen rozhraní {1} v typu {2}. ref and out are not valid in this context Atributy ref a out nejsou v tomto kontextu platné. The argument to the '{0}' attribute must be a valid identifier Argument atributu {0} musí být platný identifikátor. The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit) Atribut FieldOffset jde použít jenom pro členy typů s deklarací StructLayout(LayoutKind.Explicit). The FieldOffset attribute is not allowed on static or const fields Atribut FieldOffset není povolený pro pole typu static nebo const. Attribute '{0}' is only valid on classes derived from System.Attribute Atribut {0} je platný jenom pro třídy odvozené od třídy System.Attribute. Possible mistaken empty statement Možná chybný prázdný příkaz Possible mistaken empty statement Možná chybný prázdný příkaz '{0}' duplicate named attribute argument 'Duplicitní argument pojmenovaného atributu {0} '{0}' cannot derive from special class '{1}' '{0} se nemůže odvozovat ze speciální třídy {1}. Cannot specify the DefaultMember attribute on a type containing an indexer Atribut DefaultMember nejde zadat pro typ obsahující indexer. '{0}' is a type not supported by the language 'Typ {0} není tímto jazykem podporovaný. Field '{0}' is never assigned to, and will always have its default value {1} Do pole {0} se nikdy nic nepřiřadí. Bude mít vždy výchozí hodnotu {1}. Field is never assigned to, and will always have its default value Do pole se nikdy nic nepřiřadí. Bude mít vždycky výchozí hodnotu. 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. Chybný deklarátor pole. Při deklaraci spravovaného pole musí být specifikátor rozměru uvedený před identifikátorem proměnné. Při deklaraci pole vyrovnávací paměti pevné velikosti uveďte před typem pole klíčové slovo fixed. Comparison to integral constant is useless; the constant is outside the range of type '{0}' Porovnání s integrální konstantou je zbytečné; hodnota konstanty je mimo rozsah typu {0}. Comparison to integral constant is useless; the constant is outside the range of the type Porovnání s integrální konstantou je zbytečné; hodnota konstanty je mimo rozsah typu. Cannot apply attribute class '{0}' because it is abstract Nejde použít třídu atributů {0}, protože je abstraktní. '{0}' is not a valid named attribute argument because it is not a valid attribute parameter type '{0} není platný argument pojmenovaného atributu, protože se nejedná o platný typ parametru atributu. Missing compiler required member '{0}.{1}' Požadovaný člen {0}.{1} kompilátoru se nenašel. '{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} není platné umístění atributu pro tuto deklaraci. Platnými umístěními atributů pro tuto deklaraci jsou {1}. Všechny atributy v tomto bloku se budou ignorovat. Not a valid attribute location for this declaration Není platné umístění atributu pro tuto deklaraci. '{0}' is not a recognized attribute location. Valid attribute locations for this declaration are '{1}'. All attributes in this block will be ignored. '{0} není známé umístění atributu. Platná umístění atributu pro tuto deklaraci jsou {1}. Všechny atributy v tomto bloku se budou ignorovat. Not a recognized attribute location Není rozpoznané umístění atributu. '{0}' overrides Object.Equals(object o) but does not override Object.GetHashCode() '{0} přepisuje Object.Equals(object o), ale nepřepisuje Object.GetHashCode(). Type overrides Object.Equals(object o) but does not override Object.GetHashCode() Typ přepisuje Object.Equals(object o), ale nepřepisuje Object.GetHashCode(). '{0}' defines operator == or operator != but does not override Object.Equals(object o) '{0} definuje operátor == nebo !=, ale nepřepisuje funkci Object.Equals(object o). Type defines operator == or operator != but does not override Object.Equals(object o) Typ definuje operátor == nebo !=, ale nepřepisuje funkci Object.Equals(object o). '{0}' defines operator == or operator != but does not override Object.GetHashCode() '{0} definuje operátor == nebo !=, ale nepřepisuje funkci Object.GetHashCode(). Type defines operator == or operator != but does not override Object.GetHashCode() Typ definuje operátor == nebo !=, ale nepřepisuje funkci Object.GetHashCode(). Cannot specify the Out attribute on a ref parameter without also specifying the In attribute. Nejde specifikovat atribut Out pro referenční parametr, když není současně specifikovaný atribut In. '{0}' cannot define an overloaded {1} that differs only on parameter modifiers '{2}' and '{3}' '{0} nemůže definovat přetíženou {1}, která se liší jenom v modifikátorech parametrů {2} a {3}. Literal of type double cannot be implicitly converted to type '{1}'; use an '{0}' suffix to create a literal of this type Literály typu double nejde implicitně převést na typ {1}. Chcete-li vytvořit literál tohoto typu, použijte předponu {0}. Assignment in conditional expression is always constant; did you mean to use == instead of = ? Přiřazení je v podmíněných výrazech vždy konstantní. Nechtěli jste spíše použít operátor == místo operátoru = ? Assignment in conditional expression is always constant Přiřazení je v podmíněných výrazech vždycky konstantní. '{0}': new protected member declared in struct '{0}: Ve struktuře je deklarovaný nový chráněný člen. Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type Dva indexery mají stejný název. Atribut IndexerName musí být v rámci jednoho typu použitý se stejným názvem pro každý indexer. A class with the ComImport attribute cannot have a user-defined constructor Třída s atributem ComImport nemůže mít konstruktor definovaný uživatelem. Field cannot have void type Pole nemůže být typu void. Member '{0}' overrides obsolete member '{1}'. Add the Obsolete attribute to '{0}'. Člen {0} přepisuje zastaralý člen {1}. Přidejte ke členu {0} atribut Obsolete. Member overrides obsolete member Člen přepisuje nezastaralý člen. System.Void cannot be used from C# -- use typeof(void) to get the void type object Nejde použít konstrukci System.Void jazyka C#. Objekt typu void získáte pomocí syntaxe typeof(void). Do not use 'System.ParamArrayAttribute'. Use the 'params' keyword instead. Nepoužívejte atribut System.ParamArrayAttribute. Použijte místo něj klíčové slovo params. Bitwise-or operator used on a sign-extended operand; consider casting to a smaller unsigned type first Logický bitový operátor or se použil pro operand s rozšířeným podpisem. Zvažte nejprve možnost přetypování na menší nepodepsaný typ. Bitwise-or operator used on a sign-extended operand Bitový operátor or byl použitý pro operand s rozšířeným podpisem. 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. Kompilátor implicitně rozšířil proměnnou a doplnil k ní podpis. Výslednou hodnotu pak použil v bitovém porovnání NEBO operaci. Výsledkem může být neočekávané chování. '{0}': a volatile field cannot be of the type '{1}' '{0}: Pole s modifikátorem volatile nemůže být {1}. '{0}': a field cannot be both volatile and readonly '{0}: U pole nejde použít současně volatile i readonly. The modifier 'abstract' is not valid on fields. Try using a property instead. Modifikátor abstract není pro pole platný. Místo něho zkuste použít vlastnost. '{0}' cannot implement '{1}' because it is not supported by the language '{0} nemůže implementovat {1}, protože ho tento jazyk nepodporuje. '{0}' explicit method implementation cannot implement '{1}' because it is an accessor 'Explicitní implementace metody {0} nemůže implementovat {1}, protože se jedná o přistupující objekt. '{0}' interface marked with 'CoClassAttribute' not marked with 'ComImportAttribute' 'Rozhraní {0} s deklarací CoClassAttribute neobsahuje deklaraci ComImportAttribute. Interface marked with 'CoClassAttribute' not marked with 'ComImportAttribute' Rozhraní s deklarací CoClassAttribute neobsahuje deklaraci ComImportAttribute. Conditional member '{0}' cannot have an out parameter Podmíněný člen {0} nemůže mít parametr out. Accessor '{0}' cannot implement interface member '{1}' for type '{2}'. Use an explicit interface implementation. Přistupující objekt {0} nemůže implementovat člen rozhraní {1} pro typ {2}. Použijte explicitní implementaci rozhraní. The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead. Kvalifikátor aliasu oboru názvů (::) se vždycky vyhodnotí jako typ nebo obor názvů, takže je tady neplatný. Místo něho zvažte použití kvalifikátoru . (tečka). Cannot derive from '{0}' because it is a type parameter Nejde odvozovat z parametru {0}, protože je to parametr typu. Duplicate type parameter '{0}' Duplicitní parametr typu {0} Type parameter '{0}' has the same name as the type parameter from outer type '{1}' Parametr typu {0} má stejný název jako parametr typu z vnějšího typu {1}. Type parameter has the same name as the type parameter from outer type Parametr typu má stejný název jako parametr typu z vnějšího typu. Type parameter '{0}' has the same name as the containing type, or method Parametr typu {0} má stejný název jako nadřazený typ nebo metoda. '{0}' cannot implement both '{1}' and '{2}' because they may unify for some type parameter substitutions '{0} nemůže implementovat {1} a zároveň {2}, protože u některých náhrad parametrů typu může dojít k jejich sjednocení. A generic type cannot derive from '{0}' because it is an attribute class Obecný typ se nemůže odvozovat z {0}, protože je to třída atributů. '{1}' does not define type parameter '{0}' '{1} nedefinuje parametr typu {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} není platné omezení. Typ použitý jako omezení musí být rozhraní, nezapečetěná třída nebo parametr typu. Constraint cannot be special class '{0}' Omezení nemůže být speciální třída {0}. Inconsistent accessibility: constraint type '{1}' is less accessible than '{0}' Nekonzistentní dostupnost: Typ omezení {1} je míň dostupný než {0}. Cannot do member lookup in '{0}' because it is a type parameter Nejde vyhledávat člena v {0}, protože se jedná o parametr typu. Invalid constraint type. A type used as a constraint must be an interface, a non-sealed class or a type parameter. Neplatný typ omezení. Typ použitý jako omezení musí být rozhraní, nezapečetěná třída nebo parametr typu. '{0}': cannot declare instance members in a static class '{0}: Nejde deklarovat členy instance ve statické třídě. '{1}': cannot derive from static class '{0}' '{1}: Nejde odvodit ze statické třídy {0}. Static classes cannot have instance constructors Statické třídy nemůžou mít konstruktory instancí. Static classes cannot contain destructors Statické třídy nemůžou obsahovat destruktory. Cannot create an instance of the static class '{0}' Nejde vytvořit instanci statické třídy {0}. Static class '{0}' cannot derive from type '{1}'. Static classes must derive from object. Statická třída {0} se nemůže odvozovat z typu {1}. Tyto třídy se musí odvozovat z objektu. '{0}': static classes cannot implement interfaces '{0}: Statické třídy nemůžou implementovat rozhraní. '{0}': ref structs cannot implement interfaces '{0}: Struktury REF nemůžou implementovat rozhraní. '{0}': static classes cannot contain user-defined operators '{0}: Statické třídy nemůžou obsahovat operátory definované uživatelem. Cannot convert to static type '{0}' Nejde převést na statický typ {0}. '{0}': static classes cannot be used as constraints '{0}: Statické třídy nejde používat jako omezení. '{0}': static types cannot be used as type arguments '{0}: Statické typy nejde používat jako argumenty typu. '{0}': array elements cannot be of static type '{0}: Prvky pole nemůžou být statického typu. '{0}': cannot declare indexers in a static class '{0}: Nejde deklarovat indexery ve statické třídě. '{0}': static types cannot be used as parameters '{0}: Statické typy nejde používat jako parametry. '{0}': static types cannot be used as return types '{0}: Statické typy nejde používat jako typy vracených hodnot. Cannot declare a variable of static type '{0}' Nejde deklarovat proměnnou statického typu {0}. A throw statement with no arguments is not allowed in a finally clause that is nested inside the nearest enclosing catch clause Příkaz throw bez argumentů není povolený v klauzuli finally, která je vnořená do nejbližší uzavírající klauzule catch. '{0}' is not a valid format specifier '{0} není platným specifikátorem formátu. 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. Možná existuje nesprávné přiřazení místní proměnné {0}, která je argumentem příkazu using nebo lock. Volání Dispose nebo odemknutí se provede u původní hodnoty místní proměnné. Possibly incorrect assignment to local which is the argument to a using or lock statement Pravděpodobně nesprávné přiřazení místní hodnotě, která je argumentem příkazu using nebo lock Type '{0}' is defined in this assembly, but a type forwarder is specified for it V tomto sestavení je definovaný typ {0}, je ale pro něj zadané předávání typů. Cannot forward type '{0}' because it is a nested type of '{1}' Nejde předat typ {0}, protože se jedná o vnořený typ {1}. The type forwarder for type '{0}' in assembly '{1}' causes a cycle Předávání typů pro typ {0} v sestavení {1} způsobuje zacyklení. The /moduleassemblyname option may only be specified when building a target type of 'module' Parametr /moduleassemblyname jde zadat jenom při vytváření typu cíle module. Assembly reference '{0}' is invalid and cannot be resolved Odkaz na sestavení {0} je neplatný a nedá se vyhodnotit. Invalid type specified as an argument for TypeForwardedTo attribute Neplatný typ zadaný jako argument atributu TypeForwardedTo '{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static. '{0} neimplementuje člen rozhraní {1}. {2} nemůže implementovat člen rozhraní, protože je statické. '{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is not public. '{0} neimplementuje člen rozhraní {1}. {2} nemůže implementovat člen rozhraní, protože není veřejné. '{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}' because it does not have the matching return type of '{3}'. '{0} neimplementuje člen rozhraní {1}. {2} nemůže implementovat člen {1}, protože nemá odpovídající návratový typ {3}. '{0}' duplicate TypeForwardedToAttribute 'Duplicitní TypeForwardedToAttribute {0} A query body must end with a select clause or a group clause Za tělem dotazu musí následovat klauzule select nebo group. Expected contextual keyword 'on' Očekávalo se kontextové klíčové slovo on. Expected contextual keyword 'equals' Očekávalo se kontextové klíčové slovo equals. Expected contextual keyword 'by' Očekávalo se kontextové klíčové slovo by. Invalid anonymous type member declarator. Anonymous type members must be declared with a member assignment, simple name or member access. Neplatný deklarátor členu anonymního typu. Členy anonymního typu musí být deklarované přiřazením členu, prostým názvem nebo přístupem k členu. Invalid initializer member declarator Neplatný deklarátor členu inicializátoru Inconsistent lambda parameter usage; parameter types must be all explicit or all implicit Nekonzistentní použití parametru lambda. Typy parametrů musí být buď všechny explicitní, nebo všechny implicitní. A partial method cannot have the 'abstract' modifier Částečná metoda nemůže používat modifikátory přístupu ani modifikátory virtual, abstract, override, new, sealed či extern. A partial method must be declared within a partial type Částečná metoda musí být deklarovaná uvnitř částečné třídy, částečné struktury nebo částečného rozhraní. A partial method may not explicitly implement an interface method Částečná metoda nesmí explicitně implementovat metodu rozhraní. Both partial method declarations must be extension methods or neither may be an extension method Obě deklarace částečné metody musí deklarovat metody rozšíření, nebo nesmí metodu rozšíření deklarovat žádná z nich. A partial method may not have multiple defining declarations Částečná metoda nesmí mít víc definujících deklarací. A partial method may not have multiple implementing declarations Částečná metoda nesmí mít víc implementujících deklarací. Both partial method declarations must use a params parameter or neither may use a params parameter Obě deklarace částečné metody musí používat parametr params nebo ho nepoužívat. No defining declaration found for implementing declaration of partial method '{0}' Nenašla se žádná definující deklarace pro implementující deklaraci částečné metody {0}. Both partial method declarations, '{0}' and '{1}', must use the same tuple element names. V deklaracích metod, {0} a {1} se musí používat stejné názvy prvků řazené kolekce členů. Partial method declarations of '{0}' have inconsistent constraints for type parameter '{1}' Částečné deklarace metod {0} mají nekonzistentní omezení parametru typu {1}. Cannot create delegate from method '{0}' because it is a partial method without an implementing declaration Nejde vytvořit delegáta z metody {0}, protože se jedná o částečnou metodu bez implementující deklarace. Both partial method declarations must be static or neither may be static Obě deklarace částečné metody musí být statické, nebo nesmí být statická žádná z nich. Both partial method declarations must be unsafe or neither may be unsafe Obě deklarace částečné metody musí být nezabezpečené, nebo nesmí být nezabezpečená žádná z nich. Partial methods with only a defining declaration or removed conditional methods cannot be used in expression trees Ve stromech výrazů nejde používat částečné metody, pro které existuje jenom definující deklarace, nebo odebrané podmíněné metody. Obsolete member '{0}' overrides non-obsolete member '{1}' Zastaralý člen {0} potlačuje nezastaralý člen {1}. Obsolete member overrides non-obsolete member Zastaralý člen přepisuje nezastaralý člen. The fully qualified name for '{0}' is too long for debug information. Compile without '/debug' option. Plně kvalifikovaný název {0} je moc dlouhý pro vygenerování ladicích informací. Z kompilace vyřaďte možnost /debug. Fully qualified name is too long for debug information Plně kvalifikovaný název je pro ladicí informace moc dlouhý. Cannot assign {0} to an implicitly-typed variable {0} nejde přiřadit k proměnné s implicitním typem. Implicitly-typed variables must be initialized Proměnné s implicitním typem musí být inicializované. Implicitly-typed variables cannot have multiple declarators Proměnné s implicitním typem nemůžou mít víc deklarátorů. Cannot initialize an implicitly-typed variable with an array initializer Proměnnou s implicitním typem nejde inicializovat inicializátorem pole. Implicitly-typed local variables cannot be fixed Lokální proměnné s implicitním typem nemůžou být pevné. Implicitly-typed variables cannot be constant Proměnné s implicitním typem nemůžou být konstanty. Constructor '{0}' is marked external Konstruktor {0} je označený jako externí. Constructor is marked external Konstruktor je označený jako externí. The contextual keyword 'var' may only appear within a local variable declaration or in script code Kontextové klíčové slovo var se může objevit pouze v rámci deklarace lokální proměnné nebo v kódu skriptu. No best type found for implicitly-typed array Nebyl nalezen optimální typ pro implicitně typované pole. Cannot assign '{0}' to anonymous type property {0} nejde přiřadit k anonymní vlastnosti typu. An expression tree may not contain a base access Strom výrazu nesmí obsahovat základní přístup. An expression tree may not contain an assignment operator Strom výrazu nesmí obsahovat operátor přiřazení. An anonymous type cannot have multiple properties with the same name Anonymní typ nemůže mít více vlastností se stejným názvem. A lambda expression with a statement body cannot be converted to an expression tree Výraz lambda s tělem příkazu nejde převést na strom výrazu. Cannot convert lambda to an expression tree whose type argument '{0}' is not a delegate type Výraz lambda nejde převést na strom výrazu, jehož argument typu {0} neurčuje delegovaný typ. Cannot use anonymous type in a constant expression V konstantním výrazu nejde použít anonymní typ. The first operand of an 'is' or 'as' operator may not be a lambda expression, anonymous method, or method group. Prvním operandem operátoru is nebo as nesmí být výraz lambda, anonymní metoda ani skupina metod. The first operand of an 'as' operator may not be a tuple literal without a natural type. První operand operátoru as nesmí být literál řazené kolekce členů bez přirozeného typu. An expression tree may not contain a multidimensional array initializer Strom výrazu nesmí obsahovat inicializátor vícedimenzionálního pole. Argument missing Chybí argument. Cannot use local variable '{0}' before it is declared Lokální proměnnou {0} nejde použít dřív, než je deklarovaná. Type of '{0}' cannot be inferred since its initializer directly or indirectly refers to the definition. Typ pro {0} nejde odvodit, protože jeho inicializátor přímo nebo nepřímo odkazuje na definici. Auto-implemented property '{0}' must be fully assigned before control is returned to the caller. Před vrácením řízení volajícímu modulu musí být plně přiřazená automaticky implementovaná vlastnost {0}. Cannot use local variable '{0}' before it is declared. The declaration of the local variable hides the field '{1}'. Lokální proměnnou {0} nejde použít dřív, než je deklarovaná. Deklarace lokální proměnné skryje pole {1}. An expression tree lambda may not contain a coalescing operator with a null or default literal left-hand side Strom výrazu lambda nesmí obsahovat operátor sloučení, na jehož levé straně stojí literál s hodnotou Null nebo výchozí literál. Identifier expected Očekával se identifikátor. ; expected Očekával se středník (;). Syntax error, '{0}' expected Chyba syntaxe; očekávána hodnota: {0} Duplicate '{0}' modifier Duplicitní modifikátor {0} Property accessor already defined Přistupující objekt vlastnosti je už definovaný. Type byte, sbyte, short, ushort, int, uint, long, or ulong expected Očekával se typ byte, sbyte, short, ushort, int, uint, long nebo ulong. Unrecognized escape sequence Nerozpoznaná řídicí sekvence Newline in constant Konstanta obsahuje znak nového řádku. Empty character literal Prázdný znakový literál Too many characters in character literal Příliš moc znaků ve znakovém literálu Invalid number Neplatné číslo A get or set accessor expected Očekával se přistupující objekt get nebo set. An object, string, or class type expected Očekával se typ object, string nebo class. Named attribute argument expected Očekával se argument pojmenovaného atributu. Catch clauses cannot follow the general catch clause of a try statement Klauzule catch nemůžou následovat za obecnou klauzulí catch příkazu try. Keyword 'this' or 'base' expected Očekávalo se klíčové slovo this nebo base. Overloadable unary operator expected Očekával se přetěžovatelný unární operátor. Overloadable binary operator expected Očekával se přetěžovatelný binární operátor. Integral constant is too large Integrální konstanta je moc velká. Type or namespace definition, or end-of-file expected Očekávala se definice typu nebo oboru názvů, nebo konec souboru. Member definition, statement, or end-of-file expected Očekává se definice člena, příkaz nebo konec souboru. Embedded statement cannot be a declaration or labeled statement Vloženým příkazem nemůže být deklarace ani příkaz s návěstím. Preprocessor directive expected Očekávala se direktiva preprocesoru. Single-line comment or end-of-line expected Očekával se jednořádkový komentář nebo konec řádku. ) expected Očekává se ). #endif directive expected Očekávala se direktiva #endif. Unexpected preprocessor directive Neočekávaná direktiva preprocesoru #error: '{0}' #error: {0} #warning: '{0}' #warning: {0} #warning directive Direktiva #warning Type expected Očekával se typ. Cannot define/undefine preprocessor symbols after first token in file Po prvním tokenu v souboru nejde definovat symboly preprocesoru ani rušit jejich definice. Cannot use #r after first token in file Nejde použít #r po prvním tokenu v souboru. End-of-file found, '*/' expected Našel se konec souboru. Očekával se řetězec */. Merge conflict marker encountered Byla zjištěna značka konfliktu sloučení. Do not use refout when using refonly. Když používáte refonly, nepoužívejte refout. Cannot compile net modules when using /refout or /refonly. Když se používá přepínač /refout nebo /refonly, nejde zkompilovat síťové moduly. Overloadable operator expected Očekával se přetěžovatelný operátor. #endregion directive expected Očekávala se direktiva #endregion. Unterminated string literal Neukončený řetězcový literál Preprocessor directives must appear as the first non-whitespace character on a line Direktivy preprocesoru musí být uvedené jako první neprázdné znaky na řádku. Identifier expected; '{1}' is a keyword Očekával se identifikátor; {1} je klíčové slovo. { or ; expected Očekávala se levá složená závorka ({) nebo středník (;). Cannot use more than one type in a for, using, fixed, or declaration statement V příkazu deklarace for, using, fixed nebo or nejde použít více než jeden typ. An add or remove accessor expected Očekával se přistupující objekt add nebo remove. Unexpected character '{0}' Neočekávaný znak {0} Unexpected token '{0}' Neočekávaný token {0} '{0}': static classes cannot contain protected members '{0}: Statické třídy nemůžou obsahovat chráněné členy. A previous catch clause already catches all exceptions. All non-exceptions thrown will be wrapped in a System.Runtime.CompilerServices.RuntimeWrappedException. Předchozí klauzule catch už zachycuje všechny výjimky. Všechny vyvolané události, které nejsou výjimkami, budou zahrnuty do obálky třídy System.Runtime.CompilerServices.RuntimeWrappedException. A previous catch clause already catches all exceptions Předchozí klauzule catch už zachytává všechny výjimky. 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. Toto varování způsobuje, když blok catch() nemá žádný zadaný typ výjimky po bloku catch (System.Exception e). Varování informuje, že blok catch() nezachytí žádné výjimky. Blok catch() po bloku catch (System.Exception e) může zachytit výjimky, které nesouvisí se specifikací CLS, pokud je RuntimeCompatibilityAttribute nastavený na false v souboru AssemblyInfo.cs: [assembly: RuntimeCompatibilityAttribute(WrapNonExceptionThrows = false)]. Pokud tento atribut není nastavený explicitně na false, všechny výjimky, které nesouvisí se specifikací CLS, se dostanou do balíčku Exceptions a blok catch (System.Exception e) je zachytí. The operand of an increment or decrement operator must be a variable, property or indexer Operandem operátoru přičtení nebo odečtení musí být proměnná, vlastnost nebo indexer. '{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} neobsahuje definici pro {1} a nenašla se žádná dostupná metoda rozšíření {1}, která by přijímala první argument typu {0}. (Nechybí direktiva using nebo odkaz na sestavení?) '{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} neobsahuje definici pro {1} a nenašla se žádná metoda rozšíření {1}, která by přijímala první argument typu {0}. (Nechybí direktiva using pro {2}?) Method '{0}' has a parameter modifier 'this' which is not on the first parameter Metoda {0} má modifikátor parametru this, který není na prvním parametru. The parameter modifier '{0}' cannot be used with '{1}' Modifikátor parametru {0} nejde použít s modifikátorem {1}. The first parameter of an extension method cannot be of type '{0}' První parametr metody rozšíření nesmí být typu {0}. A parameter array cannot be used with 'this' modifier on an extension method V metodě rozšíření nejde použít pole parametrů s modifikátorem this. Extension method must be static Metoda rozšíření musí být statická. Extension method must be defined in a non-generic static class Metoda rozšíření musí být definovaná v neobecné statické třídě. A parameter can only have one '{0}' modifier Parametr může mít jenom jeden modifikátor {0}. Extension methods must be defined in a top level static class; {0} is a nested class Metody rozšíření musí být definované ve statické třídě nejvyšší úrovně; {0} je vnořená třída. Cannot define a new extension method because the compiler required type '{0}' cannot be found. Are you missing a reference to System.Core.dll? Nejde definovat novou metodu rozšíření, protože se nenašel vyžadovaný typ kompilátoru {0}. Nechybí odkaz na System.Core.dll? Do not use 'System.Runtime.CompilerServices.ExtensionAttribute'. Use the 'this' keyword instead. Nepoužívejte System.Runtime.CompilerServices.ExtensionAttribute. Místo toho použijte klíčové slovo this. Do not use 'System.Runtime.CompilerServices.DynamicAttribute'. Use the 'dynamic' keyword instead. Nepoužívejte System.Runtime.CompilerServices.DynamicAttribute. Místo toho použijte klíčové slovo dynamic. The constructor call needs to be dynamically dispatched, but cannot be because it is part of a constructor initializer. Consider casting the dynamic arguments. Volání konstruktoru je nutné volat dynamicky, což ale není možné, protože je součástí inicializátoru konstruktoru. Zvažte použití dynamických argumentů. Extension method '{0}' defined on value type '{1}' cannot be used to create delegates Metoda rozšíření {0} definovaná v hodnotovém typu {1} se nedá použít k vytváření delegátů. No overload for method '{0}' takes {1} arguments Žádné přetížení pro metodu {0} nepřevezme tento počet argumentů: {1}. Argument {0}: cannot convert from '{1}' to '{2}' Argument {0}: Nejde převést z {1} na {2}. Source file '{0}' could not be opened -- {1} Zdrojový soubor {0} nešel otevřít -- {1} Cannot link resource files when building a module Při sestavování modulu nejde propojit soubory prostředků. Resource identifier '{0}' has already been used in this assembly Identifikátor prostředku {0} se už v tomto sestavení používá. Each linked resource and module must have a unique filename. Filename '{0}' is specified more than once in this assembly Každý propojený prostředek a modul musí mít jedinečný název souboru, ale {0} se v tomto sestavení objevuje víc než jednou. The referenced file '{0}' is not an assembly Odkazovaný soubor {0} není sestavení. A ref or out value must be an assignable variable Hodnotou Ref nebo Out musí být proměnná s možností přiřazení hodnoty. Keyword 'base' is not available in a static method Klíčové slovo base není k dispozici uvnitř statické metody. Keyword 'base' is not available in the current context Klíčové slovo base není k dispozici v aktuálním kontextu. } expected Očekával se znak }. { expected Očekával se znak {. 'in' expected 'Očekávalo se klíčové slovo in. Invalid preprocessor expression Neplatný výraz preprocesoru Invalid token '{0}' in class, record, struct, or interface member declaration Neplatný token {0} v deklaraci člena rozhraní, třídy nebo struktury Method must have a return type Metoda musí mít typ vrácené hodnoty. Invalid base type Neplatný základní typ Empty switch block Prázdný blok switch Empty switch block Prázdný blok switch Expected catch or finally Očekávalo se klíčové slovo catch nebo finally. Invalid expression term '{0}' Neplatný výraz {0} A new expression requires an argument list or (), [], or {} after type Výraz new vyžaduje za typem použití znaků (), [] nebo {} Elements defined in a namespace cannot be explicitly declared as private, protected, protected internal, or private protected Elementy definované v názvovém prostoru nelze explicitně deklarovat jako private, protected, protected internal nebo private protected. Expected ; or = (cannot specify constructor arguments in declaration) Očekával se znak ; nebo = (v deklaraci nejde zadat argumenty konstruktoru). A using clause must precede all other elements defined in the namespace except extern alias declarations Klauzule using musí předcházet všem ostatním prvkům definovaným v oboru názvů s výjimkou deklarací externích aliasů. Overloaded binary operator '{0}' takes two parameters Přetěžovaný binární operátor {0} používá dva parametry. Overloaded unary operator '{0}' takes one parameter Přetěžovaný unární operátor {0} převezme jeden parametr. Invalid parameter type 'void' Neplatný typ parametru void The using alias '{0}' appeared previously in this namespace Alias using {0} se objevil dřív v tomto oboru názvů. Cannot access protected member '{0}' via a qualifier of type '{1}'; the qualifier must be of type '{2}' (or derived from it) K chráněnému členu {0} nejde přistupovat prostřednictvím kvalifikátoru typu {1}. Kvalifikátor musí být typu {2} (nebo musí být od tohoto typu odvozen). '{0}' cannot be added to this assembly because it already is an assembly '{0} se nemůže přidat do tohoto sestavení, protože už to sestavení je. Property, indexer, or event '{0}' is not supported by the language; try directly calling accessor methods '{1}' or '{2}' Vlastnost, indexer nebo událost {0} nejsou tímto jazykem podporované. Zkuste přímo volat metody přistupujícího objektu {1} nebo {2}. Property, indexer, or event '{0}' is not supported by the language; try directly calling accessor method '{1}' Vlastnost, indexer nebo událost {0} nejsou tímto jazykem podporované. Zkuste přímo volat metodu přistupujícího objektu {1}. Keyword 'void' cannot be used in this context Klíčové slovo void nejde v tomto kontextu použít. Indexers must have at least one parameter Indexery musí mít nejmíň jeden parametr. Array type specifier, [], must appear before parameter name Před názvem parametru musí být uvedený specifikátor typu pole []. Declaration is not valid; use '{0} operator <dest-type> (...' instead Deklarace není platná. Místo toho použijte: {0} operátor <dest-type> (... Could not find '{0}' specified for Main method Prvek {0} zadaný pro metodu Main se nenašel. '{0}' specified for Main method must be a non-generic class, record, struct, or interface {0} zadaný pro metodu Main musí být neobecná třída, struktura nebo rozhraní. '{0}' does not have a suitable static 'Main' method '{0} nemá vhodnou statickou metodu Main. Cannot use '{0}' for Main method because it is imported {0} nejde použít pro metodu Main, protože je importovaný. Outputs without source must have the /out option specified U výstupu bez zdroje musí být zadaný přepínač /out. Conflicting options specified: Win32 resource file; Win32 manifest Jsou zadané konfliktní možnosti: soubor prostředků Win32, manifest Win32. Conflicting options specified: Win32 resource file; Win32 icon Jsou zadané konfliktní možnosti: soubor prostředků Win32, ikona Win32. Error reading resource '{0}' -- '{1}' Chyba při čtení prostředku {0} -- {1} Error writing to XML documentation file: {0} Chyba při zápisu do souboru dokumentace XML: {0} XML comment has badly formed XML -- '{0}' Komentáře XML má chybně vytvořený kód -- {0} XML comment has badly formed XML Komentář XML má chybně vytvořený kód. XML comment has a duplicate param tag for '{0}' Komentář XML má duplicitní značku param pro {0}. XML comment has a duplicate param tag Komentář XML má duplicitní značku param. XML comment has a param tag for '{0}', but there is no parameter by that name Komentář XML má značku param pro {0}, ale neexistuje parametr s tímto názvem. XML comment has a param tag, but there is no parameter by that name Komentář XML má značku param, ale neexistuje parametr s tímto názvem. XML comment on '{1}' has a paramref tag for '{0}', but there is no parameter by that name Komentář XML u {1} má značku paramref pro {0}, ale neexistuje parametr s tímto názvem. XML comment has a paramref tag, but there is no parameter by that name Komentář XML má značku paramref, ale neexistuje parametr s tímto názvem. Parameter '{0}' has no matching param tag in the XML comment for '{1}' (but other parameters do) Parametr {0} nemá žádnou odpovídající značku param v komentáři XML pro {1} (ale jiné parametry ano). Parameter has no matching param tag in the XML comment (but other parameters do) Parametr nemá odpovídající značku param v komentáři XML (na rozdíl od jiných parametrů). XML comment has cref attribute '{0}' that could not be resolved Komentář XML má atribut cref {0}, který se nedal vyřešit. XML comment has cref attribute that could not be resolved Komentář XML má atribut cref, který se nedal vyřešit. A stackalloc expression requires [] after type Výraz stackalloc vyžaduje, aby za typem byly závorky []. The line number specified for #line directive is missing or invalid Číslo řádku zadané v direktivě #line se nenašlo nebo je neplatné. Quoted file name, single-line comment or end-of-line expected Očekával se citovaný název souboru, jednořádkový komentář nebo konec řádku. Quoted file name expected Očekával se citovaný název souboru. #r is only allowed in scripts #r je povolený jenom ve skriptech. foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a public instance or extension definition for '{1}' Příkaz foreach nejde použít pro proměnné typu {0}, protože {0} neobsahuje veřejnou definici instance pro {1}. Invalid type for parameter {0} in XML comment cref attribute: '{1}' Neplatný typ pro parametr {0} v atributu cref komentáře XML: {1}. Invalid type for parameter in XML comment cref attribute Neplatný typ pro parametr v atributu cref komentáře XML. Invalid return type in XML comment cref attribute Neplatný typ vrácené hodnoty v atributu cref komentáře XML Invalid return type in XML comment cref attribute Neplatný typ vrácené hodnoty v atributu cref komentáře XML Error reading Win32 resources -- {0} Chyba při čtení prostředků Win32 -- {0} XML comment has syntactically incorrect cref attribute '{0}' Komentář XML má syntakticky nesprávný atribut cref {0}. XML comment has syntactically incorrect cref attribute Komentář XML má syntakticky nesprávný atribut cref. Member modifier '{0}' must precede the member type and name Modifikátor členu {0} musí předcházet jeho názvu a typu. Array creation must have array size or array initializer Při vytváření pole musí být k dispozici velikost pole nebo inicializátor pole. XML comment is not placed on a valid language element Komentář XML není umístěný v platném prvku jazyka. XML comment is not placed on a valid language element Komentář XML není umístěný v platném prvku jazyka. Unable to include XML fragment '{1}' of file '{0}' -- {2} Nejde zahrnout fragment XML {1} ze souboru {0} -- {2} Unable to include XML fragment Nejde zahrnout fragment XML. Invalid XML include element -- {0} Neplatný prvek direktivy include XML -- {0} Invalid XML include element Neplatný prvek direktivy include XML Missing XML comment for publicly visible type or member '{0}' Komentář XML pro veřejně viditelný typ nebo člen {0} se nenašel. Missing XML comment for publicly visible type or member Komentář XML pro veřejně viditelný typ nebo člen se nenašel. The /doc compiler option was specified, but one or more constructs did not have comments. Byla zadaná možnost kompilátoru /doc, ale nejmíň jedna konstrukce neměla komentáře. Badly formed XML in included comments file -- '{0}' Chybně vytvořený kód XML v zahrnutém souboru komentáře -- {0} Badly formed XML in included comments file Chybně vytvořený kód XML v zahrnutém souboru komentářů Delegate '{0}' does not take {1} arguments Delegát {0} nepřevezme tento počet argumentů: {1}. Semicolon after method or accessor block is not valid Středník není platný za metodou nebo blokem přistupujícího objektu. The return type of a method, delegate, or function pointer cannot be '{0}' Metoda nebo delegát nemůže vracet typ {0}. Compilation cancelled by user Kompilaci zrušil uživatel. Cannot make reference to variable of type '{0}' Nejde vytvořit odkaz na proměnnou typu {0}. Cannot assign to '{0}' because it is read-only K položce nejde přiřadit {0}, protože je jen pro čtení. Cannot use '{0}' as a ref or out value because it is read-only {0} nejde použít jako hodnotu Ref nebo Out, protože je jen pro čtení. The RequiredAttribute attribute is not permitted on C# types Atribut RequiredAttribute není povolený pro typy C#. Modifiers cannot be placed on event accessor declarations Modifikátory nejde umístit do deklarace přistupujícího objektu události. The params parameter cannot be declared as {0} Parametr params nejde deklarovat jako {0}. Cannot modify the return value of '{0}' because it is not a variable Vrácenou hodnotu {0} nejde změnit, protože se nejedná o proměnnou. The managed coclass wrapper class '{0}' for interface '{1}' cannot be found (are you missing an assembly reference?) Spravovaná třída obálky coclass {0} pro rozhraní {1} se nedá najít. (Nechybí odkaz na sestavení?) '{0}' is ambiguous between '{1}' and '{2}'; use either '@{0}' or '{0}Attribute' '{0} je nejednoznačné mezi {1} a {2}; použijte buď @{0}, nebo {0}Attribute. Argument {0} may not be passed with the '{1}' keyword Argument {0} se nesmí předávat s klíčovým slovem {1}. Option '{0}' overrides attribute '{1}' given in a source file or added module Možnost {0} přepíše atribut {1} zadaný ve zdrojovém souboru nebo přidaném modulu. Option overrides attribute given in a source file or added module Možnost přepíše atribut zadaný ve zdrojovém souboru nebo přidaném modulu. 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. Toto varování se objeví, pokud jsou atributy sestavení AssemblyKeyFileAttribute nebo AssemblyKeyNameAttribute nacházející se ve zdroji v konfliktu s parametrem příkazového řádku /keyfile nebo /keycontainer nebo názvem souboru klíče nebo kontejnerem klíčů zadaným ve vlastnostech projektu. Invalid option '{0}' for /langversion. Use '/langversion:?' to list supported values. Neplatný parametr {0} pro /langversion. Podporované hodnoty vypíšete pomocí /langversion:?. Cannot create delegate with '{0}' because it or a method it overrides has a Conditional attribute Delegáta s {0} nejde vytvořit, protože ten nebo metoda, kterou přepisuje, má atribut Conditional. Cannot create temporary file -- {0} Nedá se vytvořit dočasný soubor -- {0}. Argument {0} must be passed with the '{1}' keyword Argument {0} se musí předávat s klíčovým slovem {1}. The yield statement cannot be used inside an anonymous method or lambda expression Příkaz yield nejde používat uvnitř anonymních metod a výrazů lambda. Cannot return a value from an iterator. Use the yield return statement to return a value, or yield break to end the iteration. Nejde vrátit hodnotu z iterátoru. K vrácení hodnoty použijte příkaz yield return. K ukončení opakování použijte příkaz yield break. Iterators cannot have ref, in or out parameters U iterátorů nejde používat parametry ref, in nebo out. The body of '{0}' cannot be an iterator block because '{1}' is not an iterator interface type Tělo {0} nemůže být blok iterátoru, protože {1} není typ rozhraní iterátoru. Cannot yield in the body of a finally clause V těle klauzule finally nejde používat příkaz yield. Cannot yield a value in the body of a try block with a catch clause V těle bloku try s klauzulí catch nejde uvést hodnotu příkazu yield. Expression expected after yield return Po příkazu yield return se očekával výraz. Cannot use ref, out, or in parameter '{0}' inside an anonymous method, lambda expression, query expression, or local function Parametr ref, out nebo in {0} nejde použít uvnitř anonymní metody, výrazu lambda, výrazu dotazu nebo lokální funkce. Unsafe code may not appear in iterators Iterátory nesmí obsahovat nezabezpečený kód. Cannot yield a value in the body of a catch clause V těle klauzule catch nejde použít hodnotu získanou příkazem yield. Control cannot leave the body of an anonymous method or lambda expression Ovládací prvek nemůže opustit tělo anonymní metody nebo výrazu lambda. Unrecognized #pragma directive Nerozpoznaná direktiva #pragma Unrecognized #pragma directive Nerozpoznaná direktiva #pragma Expected 'disable' or 'restore' Očekávala se hodnota disable nebo restore. Expected 'disable' or 'restore' after #pragma warning Po varování #pragma se očekávala hodnota disable nebo restore. Cannot restore warning 'CS{0}' because it was disabled globally Nejde obnovit varování CS{0}, protože je globálně zakázané. Cannot restore warning because it was disabled globally Nejde obnovit varování, protože bylo globálně zakázané. __arglist is not allowed in the parameter list of iterators Parametr __arglist není povolený v seznamu parametrů iterátorů. Iterators cannot have unsafe parameters or yield types U iterátorů nejde používat nezabezpečené parametry nebo typy yield. The managed coclass wrapper class signature '{0}' for interface '{1}' is not a valid class name signature Podpis spravované třídy obálky coclass {0} pro rozhraní {1} není platný podpis názvu třídy. foreach statement cannot operate on variables of type '{0}' because it implements multiple instantiations of '{1}'; try casting to a specific interface instantiation Příkaz foreach nejde použít pro proměnné typu {0}, protože implementuje vytváření víc instancí {1}. Zkuste přetypování na konkrétní instanci rozhraní. A fixed size buffer field must have the array size specifier after the field name Pole vyrovnávací paměti s pevnou velikostí musí mít za názvem pole uvedený specifikátor velikosti pole. Fixed size buffer fields may only be members of structs Pole vyrovnávací paměti pevné velikosti můžou být jenom členy struktur. Not all code paths return a value in {0} of type '{1}' Ne všechny cesty kódu vracejí hodnotu v {0} typu {1}. Feature '{0}' is not part of the standardized ISO C# language specification, and may not be accepted by other compilers Funkce {0} není součástí standardizované specifikace ISO jazyka C# a možná ji nepůjde použít v ostatních kompilátorech Feature is not part of the standardized ISO C# language specification, and may not be accepted by other compilers Funkce není součástí standardizované specifikace ISO jazyka C# a možná ji nepůjde použít v ostatních kompilátorech Keyword, identifier, or string expected after verbatim specifier: @ Po specifikátoru verbatim se očekávalo klíčové slovo, identifikátor nebo řetězec: @ A readonly field cannot be used as a ref or out value (except in a constructor) Pole určené jen pro čtení nejde použít jako hodnotu Ref nebo Out (kromě případu, kdy se nachází uvnitř konstruktoru). Members of readonly field '{0}' cannot be used as a ref or out value (except in a constructor) Členy pole jen pro čtení {0} nejde použít jako hodnotu Ref nebo Out (kromě případu, kdy se nachází uvnitř konstruktoru). 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) Do pole jen pro čtení není možné přiřazovat hodnoty (kromě případu, kdy je v konstruktoru nebo v metodě setter jenom pro inicializaci třídy, ve které je pole definované, nebo v inicializátoru proměnné). Members of readonly field '{0}' cannot be modified (except in a constructor or a variable initializer) Členy pole jen pro čtení {0} nejde měnit (kromě případu, kdy se nacházejí uvnitř konstruktoru nebo inicializátoru proměnné). Cannot use {0} '{1}' as a ref or out value because it is a readonly variable Nejde použít {0} {1} jako hodnotu ref nebo out, protože je to proměnná jen pro čtení. Members of {0} '{1}' cannot be used as a ref or out value because it is a readonly variable Členy {0} {1} nejde použít jako hodnotu ref nebo out, protože je to proměnná jen pro čtení. Cannot assign to {0} '{1}' because it is a readonly variable Nejde přiřadit k položce {0} {1}, protože to je proměnná jen pro čtení. Cannot assign to a member of {0} '{1}' because it is a readonly variable Nejde přiřadit členovi {0} {1}, protože to je proměnná jen pro čtení. Cannot return {0} '{1}' by writable reference because it is a readonly variable Nejde vrátit {0} {1} zapisovatelným odkazem, protože to je proměnná jen pro čtení. Members of {0} '{1}' cannot be returned by writable reference because it is a readonly variable Členy {0} {1} nejde vrátit zapisovatelným odkazem, protože to je proměnná jen pro čtení. Fields of static readonly field '{0}' cannot be assigned to (except in a static constructor or a variable initializer) Pole statických polí jen pro čtení {0} nejde přiřadit (kromě případu, kdy se nacházejí uvnitř statického konstruktoru nebo inicializátoru proměnné). Fields of static readonly field '{0}' cannot be used as a ref or out value (except in a static constructor) Pole statického pole jen pro čtení {0} nejde použít jako hodnotu Ref nebo Out (kromě případu, kdy se nacházejí uvnitř statického konstruktoru). Cannot modify members of '{0}' because it is a '{1}' Členy z {0} nejde upravit, protože jde o {1}. Cannot use fields of '{0}' as a ref or out value because it is a '{1}' Pole elementu {0} nejde použít jako hodnotu Ref nebo Out, protože je {1}. Cannot assign to '{0}' because it is a '{1}' K položce nejde přiřadit {0}, protože je typu {1}. Cannot use '{0}' as a ref or out value because it is a '{1}' {0} nejde použít jako hodnotu Ref nebo Out, protože je {1}. {0}. See also error CS{1}. {0}. Viz taky chyba CS{1}. Warning is overriding an error Varování přepisuje chybu. The compiler emits this warning when it overrides an error with a warning. For information about the problem, search for the error code mentioned. Kompilátor vydá toto varování, když přepíše chybu varováním. Informace o tomto problému vyhledejte podle uvedeného kódu chyby. Cannot convert {0} to type '{1}' because it is not a delegate type {0} nejde převést na typ {1}, protože to není typ delegáta. Cannot convert {0} to type '{1}' because the parameter types do not match the delegate parameter types {0} nejde převést na typ {1}, protože typy parametrů se neshodují s typy parametrů delegáta. 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 {0} nejde převést na zamýšlený typ delegáta, protože některé z návratových typů v bloku nejsou implicitně převeditelné na návratový typ tohoto delegáta. Since this is an async method, the return expression must be of type '{0}' rather than 'Task<{0}>' Protože se jedná o asynchronní metodu, vrácený výraz musí být typu {0} a ne typu 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}'. Asynchronní metodu {0} nejde převést na typ delegáta {1}. Asynchronní metoda {0} může vracet hodnoty typu void, Task nebo Task< T> , z nichž žádnou nejde převést na typ {1}. Fixed size buffer type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double Typ vyrovnávací paměti pevné velikosti musí být následující: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float nebo double. Fixed size buffer of length {0} and type '{1}' is too big Vyrovnávací paměť pevné velikosti s délkou {0} a typem {1} je moc velká. Fixed size buffers must have a length greater than zero Vyrovnávací paměti pevné velikosti mají délku větší než nula. You cannot use fixed size buffers contained in unfixed expressions. Try using the fixed statement. Vyrovnávací paměti pevné velikosti obsažené ve volném výrazu nejde používat. Použijte příkaz fixed. Attribute '{0}' is not valid on property or event accessors. It is only valid on '{1}' declarations. Atribut {0} není platný pro přistupující objekty vlastnosti nebo události. Je platný jenom pro deklarace {1}. Invalid search path '{0}' specified in '{1}' -- '{2}' Neplatná vyhledávací cesta {0} zadaná v {1} -- {2} Invalid search path specified Byla zadaná neplatná vyhledávací cesta. __arglist is not valid in this context Klíčové slovo __arglist není v tomto kontextu platné. params is not valid in this context Klíčové slovo params není v tomto kontextu platné. A namespace declaration cannot have modifiers or attributes Deklarace oboru názvů nemůže mít modifikátory ani atributy. Invalid option '{0}' for /platform; must be anycpu, x86, Itanium, arm, arm64 or x64 Neplatná možnost {0} pro /platform. Musí být anycpu, x86, Itanium, arm, arm64 nebo 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. Anonymní metody, výrazy lambda a dotazovací výrazy uvnitř struktur nemají přístup ke členům instance this. Jako náhradu zkopírujte objekt this do lokální proměnné vně anonymní metody, výrazu lambda nebo dotazovacího výrazu a použijte lokální proměnnou. '{0}': type used in a using statement must be implicitly convertible to 'System.IDisposable'. {0}: Typ použitý v příkazu using musí být implicitně převeditelný na System.IDisposable. Parameter {0} must be declared with the '{1}' keyword Parametr {0} se musí deklarovat s klíčovým slovem {1}. Parameter {0} should not be declared with the '{1}' keyword Parametr {0} by se neměl deklarovat s klíčovým slovem {1}. Parameter {0} is declared as type '{1}{2}' but should be '{3}{4}' Parametr {0} se deklaruje jako typ {1}{2}, ale mělo by jít o {3}{4}. Invalid extern alias for '/reference'; '{0}' is not a valid identifier Neplatný externí alias pro parametr /reference; {0} je neplatný identifikátor. Invalid reference alias option: '{0}=' -- missing filename Neplatný parametr aliasu odkazu: {0}= – nenašel se název souboru. You cannot redefine the global extern alias Nejde předefinovat globální externí alias. Reference to type '{0}' claims it is defined in this assembly, but it is not defined in source or any added modules Odkaz na typ {0} se deklaruje jako definovaný v tomto sestavení, ale není definovaný ve zdroji ani v žádných přidaných modulech. Reference to type '{0}' claims it is defined in '{1}', but it could not be found Odkaz na typ {0} se deklaruje jako definovaný v rámci {1}, ale nenašel. The predefined type '{0}' is defined in multiple assemblies in the global alias; using definition from '{1}' Předdefinovaný typ {0} je definovaný ve více sestaveních v globálním aliasu; použije se definice z {1}. Predefined type is defined in multiple assemblies in the global alias Předdefinovaný typ je definovaný ve více sestaveních v globálním aliasu. 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. K této chybě dojde, když se předdefinovaný systémový typ, jako je System.Int32, nachází ve dvou sestaveních. Jedna z možností, jak se to může stát, je, že odkazujete na mscorlib nebo System.Runtime.dll, ze dvou různých míst, například při pokusu spustit dvě verze .NET Framework vedle sebe. Local '{0}' or its members cannot have their address taken and be used inside an anonymous method or lambda expression Adresu místní proměnné {0} ani jejích členů nejde vzít a použít uvnitř anonymní metody nebo lambda výrazu. Source file has exceeded the limit of 16,707,565 lines representable in the PDB; debug information will be incorrect U zdrojového souboru se překročil limit 16 707 565 řádků, které může soubor PDB obsahovat. Ladicí informace budou nesprávné. Source file has exceeded the limit of 16,707,565 lines representable in the PDB; debug information will be incorrect U zdrojového souboru se překročil limit 16 707 565 řádků, které může soubor PDB obsahovat. Ladicí informace budou nesprávné. Cannot convert anonymous method block without a parameter list to delegate type '{0}' because it has one or more out parameters Blok anonymní metody bez seznamu parametrů nejde převést na typ delegáta {0}, protože má nejmíň jeden parametr out. Attribute '{0}' is only valid on methods or attribute classes Atribut {0} je platný jenom pro metody nebo třídy atributů. Accessing a member on '{0}' may cause a runtime exception because it is a field of a marshal-by-reference class Přístup ke členovi na {0} může způsobit výjimku za běhu, protože se jedná o pole třídy marshal-by-reference. Accessing a member on a field of a marshal-by-reference class may cause a runtime exception Přístup ke členovi v poli třídy marshal-by-reference může způsobit běhovou výjimku. 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. Toto varování se vyskytne, když se pokusíte volat metodu, vlastnost nebo indexer u členu třídy, která se odvozuje z objektu MarshalByRefObject, a tento člen je typu hodnota. Objekty, které dědí z objektu MarshalByRefObject, jsou obvykle zamýšlené tak, že se budou zařazovat podle odkazů v aplikační doméně. Pokud se nějaký kód někdy pokusí o přímý přístup ke členu typu hodnota takového objektu někde v aplikační doméně, dojde k výjimce běhu modulu runtime. Pokud chcete vyřešit toto varování, zkopírujte nejdřív člen do místní proměnné a pak u ní vyvolejte uvedenou metodu. '{0}' is not a valid warning number '{0} není platné číslo upozornění. Not a valid warning number Není platné číslo varování. 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. Číslo, které bylo předané do direktivy preprocesoru varování #pragma, nepředstavovalo platné číslo varování. Ověřte, že číslo představuje varování, ne chybu. Invalid number Neplatné číslo Invalid number Neplatné číslo Invalid filename specified for preprocessor directive. Filename is too long or not a valid filename. V direktivě preprocesoru je uvedený neplatný název souboru. Název souboru je moc dlouhý nebo se nejedná o platný název souboru. Invalid filename specified for preprocessor directive Byl zadaný neplatný název souboru pro direktivu preprocesoru. Invalid #pragma checksum syntax; should be #pragma checksum "filename" "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" "XXXX..." Syntaxe #pragma checksum není platná. Správná syntaxe: #pragma checksum "název_souboru" "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" "XXXX..." Invalid #pragma checksum syntax Neplatná syntaxe kontrolního součtu #pragma Single-line comment or end-of-line expected Očekával se jednořádkový komentář nebo konec řádku. Single-line comment or end-of-line expected after #pragma directive Po direktivě #pragma se očekával jednořádkový komentář nebo konec řádku. Different checksum values given for '{0}' Pro {0} jsou zadané různé hodnoty kontrolního součtu. Different #pragma checksum values given Jsou zadané různé hodnoty kontrolního součtu direktivy #pragma. Assembly reference '{0}' is invalid and cannot be resolved Odkaz na sestavení {0} je neplatný a nedá se vyhodnotit. Assembly reference is invalid and cannot be resolved Odkaz na sestavení je neplatný a nedá se vyhodnotit. This warning indicates that an attribute, such as InternalsVisibleToAttribute, was not specified correctly. Toto varování indikuje, že některý atribut, třeba InternalsVisibleToAttribute, nebyl zadaný správně. Assuming assembly reference '{0}' used by '{1}' matches identity '{2}' of '{3}', you may need to supply runtime policy Předpokládá se, že odkaz na sestavení {0}, který používá {1}, odpovídá identitě {2} pro {3}. Možná budete muset zadat zásady pro běh. Assuming assembly reference matches identity Předpokládá se, že odkaz na sestavení odpovídá identitě. 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. Tato dvě sestavení se liší číslem vydání nebo verze. Aby mohlo proběhnout sjednocení, musíte zadat direktivy v souboru .config aplikace a musíte poskytnout správný silný název sestavení. Assuming assembly reference '{0}' used by '{1}' matches identity '{2}' of '{3}', you may need to supply runtime policy Předpokládá se, že odkaz na sestavení {0}, který používá {1}, odpovídá identitě {2} pro {3}. Možná budete muset zadat zásady pro běh. Assuming assembly reference matches identity Předpokládá se, že odkaz na sestavení odpovídá identitě. 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. Tato dvě sestavení se liší číslem vydání nebo verze. Aby mohlo proběhnout sjednocení, musíte zadat direktivy v souboru .config aplikace a musíte poskytnout správný silný název sestavení. Multiple assemblies with equivalent identity have been imported: '{0}' and '{1}'. Remove one of the duplicate references. Naimportovalo se víc sestavení s ekvivalentní identitou: {0} a {1}. Odeberte jeden z duplicitních odkazů. 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. Už se naimportovalo sestavení se stejným jednoduchým názvem {0}. Zkuste odebrat jeden z odkazů (např. {1}) nebo je podepište, aby mohly fungovat vedle sebe. Assembly '{0}' with identity '{1}' uses '{2}' which has a higher version than referenced assembly '{3}' with identity '{4}' Sestavení {0} s identitou {1} používá {2} s vyšší verzí, než jakou má odkazované sestavení {3} s identitou {4}. Fixed size buffers can only be accessed through locals or fields K vyrovnávacím pamětem s pevnou velikostí jde získat přístup jenom prostřednictvím lokálních proměnných nebo polí. XML comment has a duplicate typeparam tag for '{0}' Komentář XML má duplicitní značku typeparam pro {0}. XML comment has a duplicate typeparam tag Komentář XML má duplicitní značku typeparam. XML comment has a typeparam tag for '{0}', but there is no type parameter by that name Komentář XML má značku typeparam pro {0}, ale neexistuje parametr typu s tímto názvem. XML comment has a typeparam tag, but there is no type parameter by that name Komentář XML má značku typeparam, ale neexistuje parametr typu s tímto názvem. XML comment on '{1}' has a typeparamref tag for '{0}', but there is no type parameter by that name Komentář XML u {1} má značku typeparamref pro {0}, ale neexistuje parametr typu s tímto názvem. XML comment has a typeparamref tag, but there is no type parameter by that name Komentář XML má značku typeparamref, ale neexistuje parametr typu s tímto názvem. Type parameter '{0}' has no matching typeparam tag in the XML comment on '{1}' (but other type parameters do) Parametr typu {0} nemá žádnou odpovídající značku typeparam v komentáři XML na {1} (ale jiné parametry typu ano). Type parameter has no matching typeparam tag in the XML comment (but other type parameters do) Parametr typu nemá odpovídající značku typeparam v komentáři XML (na rozdíl od jiných parametrů typu). '{0}': type must be '{2}' to match overridden member '{1}' '{0}: Typ musí být {2}, aby odpovídal přepsanému členu {1}. Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead. Nepoužívejte atribut System.Runtime.CompilerServices.FixedBuffer. Místo něj použijte modifikátor pole fixed. Assignment made to same variable; did you mean to assign something else? Přiřazení proběhlo u stejné proměnné. Měli jste v úmyslu jiné přiřazení? Assignment made to same variable Přiřazení provedené u stejné proměnné Comparison made to same variable; did you mean to compare something else? Porovnání proběhlo u stejné proměnné. Měli jste v úmyslu jiné porovnání? Comparison made to same variable Porovnání provedené u stejné proměnné Error opening Win32 resource file '{0}' -- '{1}' Chyba při otevírání souboru prostředků Win32 {0} -- {1} Expression will always cause a System.NullReferenceException because the default value of '{0}' is null Výraz způsobí výjimku System.NullReferenceException, protože výchozí hodnota {0} je null. Expression will always cause a System.NullReferenceException because the type's default value is null Výraz způsobí výjimku System.NullReferenceException, protože výchozí hodnota pro typ je null. Class '{0}' cannot have multiple base classes: '{1}' and '{2}' Třída {0} nemůže mít víc základních tříd: {1} a {2}. Base class '{0}' must come before any interfaces Základní třída {0} musí předcházet všem rozhraním. XML comment has cref attribute '{0}' that refers to a type parameter Komentář XML má atribut cref {0}, který odkazuje na parametr typu. XML comment has cref attribute that refers to a type parameter Komentář XML má atribut cref, který odkazuje na parametr typu. Friend assembly reference '{0}' is invalid. InternalsVisibleTo declarations cannot have a version, culture, public key token, or processor architecture specified. Odkaz na sestavení {0} typu Friend je neplatný. V deklaracích InternalsVisibleTo nesmí být zadaná verze, jazykové prostředí, token veřejného klíče ani architektura procesoru. Friend assembly reference '{0}' is invalid. Strong-name signed assemblies must specify a public key in their InternalsVisibleTo declarations. Odkaz na sestavení {0} typu Friend je neplatný. V deklaracích InternalsVisibleTo musí být u podepsaných sestavení se silným názvem uvedený veřejný klíč. Cannot bind delegate to '{0}' because it is a member of 'System.Nullable<T>' Nejde vytvořit vazbu delegáta s {0}, protože je členem struktury System.Nullable<T>. '{0}' does not contain a constructor that takes {1} arguments '{0} neobsahuje konstruktor, který přebírá tento počet argumentů: {1}. Assembly and module attributes must precede all other elements defined in a file except using clauses and extern alias declarations Atributy sestavení a modulu musí předcházet přede všemi ostatními prvky definovanými v souboru s výjimkou klauzulí using a deklarací externích aliasů. Expected expression Očekával se výraz. Invalid version {0} for /subsystemversion. The version must be 6.02 or greater for ARM or AppContainerExe, and 4.00 or greater otherwise Neplatná verze {0} pro /subsystemversion. Verze musí být 6.02 nebo vyšší pro ARM nebo AppContainerExe a 4.00 nebo vyšší v ostatních případech. Embedded interop method '{0}' contains a body. Vložená metoda spolupráce {0} obsahuje tělo. Warning level must be zero or greater Úroveň upozornění musí být v rozsahu 0 až 4. Invalid option '{0}' for /debug; must be 'portable', 'embedded', 'full' or 'pdbonly' Neplatný parametr {0} pro /debug; musí být portable, embedded, full nebo pdbonly. Invalid option '{0}'; Resource visibility must be either 'public' or 'private' Neplatná možnost {0}. Viditelnost zdroje musí být public nebo private. The type of the argument to the DefaultParameterValue attribute must match the parameter type Typ argumentu atributu DefaultParameterValue musí odpovídat typu parametru. Argument of type '{0}' is not applicable for the DefaultParameterValue attribute Argument typu {0} není použitelný pro atribut DefaultParameterValue. Duplicate initialization of member '{0}' Duplicitní inicializace členu {0} Member '{0}' cannot be initialized. It is not a field or property. Člen {0} nejde inicializovat. Nejedná se o pole ani vlastnost. Static field or property '{0}' cannot be assigned in an object initializer Statické pole nebo vlastnost {0} se nedá přiřadit k inicializátoru objektu. Members of readonly field '{0}' of type '{1}' cannot be assigned with an object initializer because it is of a value type Členy vlastnosti {0} typu {1} nejde přiřadit k inicializátoru objektu, protože tento inicializátor je hodnotového typu. Members of property '{0}' of type '{1}' cannot be assigned with an object initializer because it is of a value type Členy vlastnosti {0} typu {1} nejde přiřadit k inicializátoru objektu, protože tento inicializátor je hodnotového typu. Unsafe type '{0}' cannot be used in object creation K vytvoření objektu nejde použít nezabezpečený typ {0}. Element initializer cannot be empty Inicializátor prvku nemůže být prázdný. The best overloaded method match for '{0}' has wrong signature for the initializer element. The initializable Add must be an accessible instance method. Odpovídající optimální přetěžovaná metoda pro {0} má nesprávný podpis prvku inicializátoru. Jako inicializovatelná metoda Add se musí používat dostupná instanční metoda. Cannot initialize type '{0}' with a collection initializer because it does not implement 'System.Collections.IEnumerable' Nejde inicializovat typ {0} pomocí inicializátoru kolekce, protože neimplementuje System.Collections.IEnumerable. Error reading Win32 manifest file '{0}' -- '{1}' Chyba při čtení souboru manifestu Win32 {0} -- {1} Ignoring /win32manifest for module because it only applies to assemblies Přepínač /win32manifest pro modul se bude ignorovat, protože se vztahuje jenom k sestavením. Ignoring /win32manifest for module because it only applies to assemblies Přepínač /win32manifest pro modul se bude ignorovat, protože se vztahuje jenom k sestavením. '{0}' does not contain a definition for '{1}' and the best extension method overload '{2}' requires a receiver of type '{3}' '{0} neobsahuje definici pro {1} a přetížení optimální metody rozšíření {2} vyžaduje přijímač typu {3}. The range variable '{0}' has already been declared Proměnná rozsahu {0} je už deklarovaná. The range variable '{0}' conflicts with a previous declaration of '{0}' Proměnná rozsahu {0} je v konfliktu s předchozí deklarací {0}. Cannot assign {0} to a range variable {0} nejde přiřadit k proměnné rozsahu. 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}'. Nenašla se implementace vzorku dotazu pro typ zdroje {0}. Nenašel se prvek {1}. Zvažte možnost explicitního určení typu proměnné rozsahu {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'? Nenašla se implementace vzorku dotazu pro typ zdroje {0}. Nenašel se prvek {1}. Nechybí odkaz na System.Core.dll nebo na direktivu using pro System.Linq? Could not find an implementation of the query pattern for source type '{0}'. '{1}' not found. Nenašla se implementace vzorku dotazu pro typ zdroje {0}. Nenašel se prvek {1}. The name '{0}' is not in scope on the left side of 'equals'. Consider swapping the expressions on either side of 'equals'. Název {0} není v oboru levé strany operátoru equals. Zvažte možnost vzájemné záměny výrazů na obou stranách operátoru equals. The name '{0}' is not in scope on the right side of 'equals'. Consider swapping the expressions on either side of 'equals'. Název {0} není v oboru pravé strany operátoru equals. Zvažte možnost vzájemné záměny výrazů na obou stranách operátoru equals. Cannot pass the range variable '{0}' as an out or ref parameter Proměnnou rozsahu {0} nejde předat jako vnější nebo odkazovaný parametr. Multiple implementations of the query pattern were found for source type '{0}'. Ambiguous call to '{1}'. Našlo se víc implementací vzorku dotazu pro typ zdroje {0}. Nejednoznačné volání funkce {1}. The type of one of the expressions in the {0} clause is incorrect. Type inference failed in the call to '{1}'. Typ jednoho z výrazů v klauzuli {0} je nesprávný. Nepovedlo se odvození typu při volání funkce {1}. The type of the expression in the {0} clause is incorrect. Type inference failed in the call to '{1}'. Typ výrazu v klauzuli {0} je nesprávný. Nepovedlo se odvození typu při volání funkce {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}'. Není povolené použití výrazu typu {0} v následné klauzuli from ve výrazu dotazu s typem zdroje {1}. Nepovedlo se odvození typu při volání funkce {2}. An expression tree may not contain an unsafe pointer operation Strom výrazů nesmí obsahovat nezabezpečenou operaci s ukazatelem. An expression tree may not contain an anonymous method expression Strom výrazů nesmí obsahovat výraz anonymní metody. An anonymous method expression cannot be converted to an expression tree Výraz anonymní metody nejde převést na strom výrazu. Range variable '{0}' cannot be assigned to -- it is read only K proměnné rozsahu {0} nejde přiřazovat – je jenom pro čtení. The range variable '{0}' cannot have the same name as a method type parameter Proměnná rozsahu {0} nesmí mít stejný název jako parametr typu metody. The contextual keyword 'var' cannot be used in a range variable declaration V deklaraci proměnné rozsahu nejde použít kontextové klíčové slovo var. The best overloaded Add method '{0}' for the collection initializer has some invalid arguments Některé argumenty optimální přetěžované metody Add {0} pro inicializátor kolekce jsou neplatné. An expression tree lambda may not contain a ref, in or out parameter Strom výrazu lambda nesmí obsahovat parametr ref, in nebo out. An expression tree lambda may not contain a method with variable arguments Strom výrazu lambda nesmí obsahovat metodu s proměnnými argumenty. An expression tree lambda may not contain a method group Strom výrazu lambda nesmí obsahovat skupinu metod. The best overloaded method match '{0}' for the collection initializer element cannot be used. Collection initializer 'Add' methods cannot have ref or out parameters. Optimální nalezenou přetěžovanou metodu {0} pro element inicializátoru kolekce nejde použít. Metody Add inicializátoru kolekce nemůžou mít parametry Ref nebo Out. Non-invocable member '{0}' cannot be used like a method. Nevyvolatelného člena {0} nejde použít jako metodu. 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. Člen {0} implementuje člen rozhraní {1} v typu {2}. Za běhu existuje pro tohoto člena rozhraní víc shod. Volaná metoda závisí na konkrétní implementaci. Member implements interface member with multiple matches at run-time Člen za běhu implementuje člena rozhraní s více shodami. 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. Toto varování se může vygenerovat, když jsou dvě metody rozhraní odlišené jenom tím, že určitý parametr je označený jednou jako ref a podruhé jako out. Doporučuje se kód změnit tak, aby k tomuto varování nedocházelo, protože není úplně jasné nebo zaručené, která metoda se má za běhu vyvolat. Ačkoli C# rozlišuje mezi out a ref, pro CLR je to totéž. Při rozhodování, která metoda má implementovat rozhraní, modul CLR prostě jednu vybere. Poskytněte kompilátoru nějaký způsob, jak metody rozlišit. Můžete například zadat různé názvy nebo k jedné z nich přidat parametr navíc. 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. Člen {1} potlačuje člen {0}. Za běhu existuje víc kandidátů na potlačení. Volaná metoda závisí na konkrétní implementaci. Member overrides base member with multiple override candidates at run-time Člen za běhu přepíše základního člena s více kandidáty na přepsání. Object and collection initializer expressions may not be applied to a delegate creation expression Výrazy inicializátoru objektu a kolekce nejde použít na výraz vytvářející delegáta. '{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} je typu {1}. V deklaraci konstanty musí být uvedený typ sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, string, výčtový typ nebo typ odkazu. Source file '{0}' could not be found. Zdrojový soubor {0} se nenašel. Source file '{0}' specified multiple times Zdrojový soubor {0} je zadaný několikrát. Source file specified multiple times Zdrojový soubor je zadaný několikrát. Missing file specification for '{0}' option Pro možnost {0} chybí specifikace souboru. Command-line syntax error: Missing '{0}' for '{1}' option Chyba syntaxe příkazového řádku: Nenašla se hodnota {0} pro možnost {1}. Unrecognized option: '{0}' Nerozpoznaná možnost: {0} No source files specified. Nejsou zadané žádné zdrojové soubory. No source files specified Nejsou zadané žádné zdrojové soubory. Expected a script (.csx file) but none specified Očekával se skript (soubor .csx), žádný ale není zadaný. Error opening response file '{0}' Chyba při otevírání souboru odpovědí {0} Cannot open '{0}' for writing -- '{1}' {0} se nedá otevřít pro zápis -- {1}. Invalid image base number '{0}' Neplatné základní číslo obrázku {0} '{0}' is a binary file instead of a text file '{0} je binární, ne textový soubor. Code page '{0}' is invalid or not installed Znaková stránka {0} je neplatná nebo není nainstalovaná. Algorithm '{0}' is not supported Algoritmus {0} není podporovaný. Cannot specify /main if building a module or library Při vytváření modulu nebo knihovny nejde použít přepínač /main. Invalid target type for /target: must specify 'exe', 'winexe', 'library', or 'module' Neplatný typ cíle pro parametr /target: Je nutné použít možnost exe, winexe, library nebo module. Ignoring /noconfig option because it was specified in a response file Přepínač /noconfig se ignoroval, protože byl uvedený v souboru odpovědí. Ignoring /noconfig option because it was specified in a response file Přepínač /noconfig se ignoroval, protože byl uvedený v souboru odpovědí. Invalid file section alignment '{0}' Neplatný argument výběru souboru {0} Invalid output name: {0} Neplatný název výstupu: {0} Invalid debug information format: {0} Neplatný formát informací o ladění: {0} 'id#' syntax is no longer supported. Use '$id' instead. 'Syntaxe id# už není podporovaná. Použijte místo ní syntaxi $id. Invalid name for a preprocessing symbol; '{0}' is not a valid identifier Neplatný název pro symbol předzpracování; {0} není platný identifikátor. Invalid name for a preprocessing symbol; not a valid identifier Neplatný název pro symbol předzpracování; neplatný identifikátor Cannot create short filename '{0}' when a long filename with the same short filename already exists Nejde vytvořit krátký název souboru {0}, protože už existuje dlouhý název souboru se stejným krátkým názvem. A /reference option that declares an extern alias can only have one filename. To specify multiple aliases or filenames, use multiple /reference options. Parametr /reference deklarující externí alias může mít jenom jeden název souboru. Pokud chcete zadat víc aliasů nebo názvů souborů, použijte více parametrů /reference. Command-line syntax error: Missing ':<number>' for '{0}' option Chyba syntaxe příkazového řádku: Nenašla se hodnota :<číslo> parametru {0}. The /pdb option requires that the /debug option also be used Možnost /pdb vyžaduje taky použití možnosti /debug . An expression tree lambda may not contain a COM call with ref omitted on arguments Strom výrazu lambda nesmí obsahovat volání COM, které v argumentech vynechává parametr Ref. Command-line syntax error: Invalid Guid format '{0}' for option '{1}' Chyba syntaxe příkazového řádku: Neplatný formát GUID {0} pro možnost {1} Command-line syntax error: Missing Guid for option '{1}' Chyba syntaxe příkazového řádku: Chybí GUID pro možnost {1}. Methods with variable arguments are not CLS-compliant Metody s proměnnými argumenty nejsou kompatibilní se specifikací CLS. Methods with variable arguments are not CLS-compliant Metody s proměnnými argumenty nejsou kompatibilní se specifikací CLS. Argument type '{0}' is not CLS-compliant Typ argumentu {0} není kompatibilní se specifikací CLS. Argument type is not CLS-compliant Typ argumentu není kompatibilní se specifikací CLS. Return type of '{0}' is not CLS-compliant Typ vrácené hodnoty {0} není kompatibilní se specifikací CLS. Return type is not CLS-compliant Návratový typ není kompatibilní se specifikací CLS. Type of '{0}' is not CLS-compliant Typ {0} není kompatibilní se specifikací CLS. Type is not CLS-compliant Typ není kompatibilní se specifikací CLS. A public, protected, or protected internal variable must be of a type that is compliant with the Common Language Specification (CLS). Veřejná, chráněná nebo interně chráněná proměnná musí být typu, který je kompatibilní se specifikací CLS (Common Language Specification). Identifier '{0}' differing only in case is not CLS-compliant Identifikátor {0} lišící se jenom použitím velkých a malých písmen není kompatibilní se specifikací CLS. Identifier differing only in case is not CLS-compliant Identifikátor lišící se jenom použitím velkých a malých písmen není kompatibilní se specifikací CLS. Overloaded method '{0}' differing only in ref or out, or in array rank, is not CLS-compliant Přetěžovaná metoda {0} lišící se jen parametrem ref nebo out nebo rozměrem pole není kompatibilní se specifikací CLS. Overloaded method differing only in ref or out, or in array rank, is not CLS-compliant Přetěžovaná metoda lišící se jen parametrem ref nebo out nebo rozměrem pole není kompatibilní se specifikací CLS. Overloaded method '{0}' differing only by unnamed array types is not CLS-compliant Přetěžovaná metoda {0} lišící se jenom nepojmenovanými typy pole není kompatibilní se specifikací CLS. Overloaded method differing only by unnamed array types is not CLS-compliant Přetěžovaná metoda lišící se jenom nepojmenovanými typy pole není kompatibilní se specifikací 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. Tato chyba se objeví, pokud máte přetěžovanou metodu, která přebírá vícenásobné pole, a jediný rozdíl mezi signaturami metody je typ elementu tohoto pole. Aby nedošlo k této chybě, zvažte použití pravoúhlého pole namísto vícenásobného, použijte další parametr, aby volání této funkce bylo jednoznačné, přejmenujte nejmíň jednu přetěžovanou metodu nebo (pokud kompatibilita s CLS není nutná) odeberte atribut CLSCompliantAttribute. Identifier '{0}' is not CLS-compliant Identifikátor {0} není kompatibilní se specifikací CLS. Identifier is not CLS-compliant Identifikátor není kompatibilní se specifikací CLS. '{0}': base type '{1}' is not CLS-compliant '{0}: Základní typ {1} není kompatibilní se specifikací CLS. Base type is not CLS-compliant Základní typ není kompatibilní se specifikací 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. Základní typ byl označený tak, že nemusí být kompatibilní se specifikací CLS (Common Language Specification) v sestavení, které bylo označené jako kompatibilní s CLS. Buď odeberte atribut, který sestavení určuje jako kompatibilní s CLS, nebo odeberte atribut, který označuje typ jako nekompatibilní s CLS. '{0}': CLS-compliant interfaces must have only CLS-compliant members '{0}: Rozhraní kompatibilní se specifikací CLS musí obsahovat jenom členy kompatibilní se specifikací CLS. CLS-compliant interfaces must have only CLS-compliant members Rozhraní kompatibilní se specifikací CLS musí obsahovat jenom členy kompatibilní se specifikací CLS. '{0}': only CLS-compliant members can be abstract '{0}: Jenom členy kompatibilní se specifikací CLS můžou být abstraktní. Only CLS-compliant members can be abstract Jenom členy kompatibilní se specifikací CLS můžou být abstraktní. You must specify the CLSCompliant attribute on the assembly, not the module, to enable CLS compliance checking Pokud chcete povolit kontrolu kompatibility se specifikací CLS, musíte zadat atribut CLSCompliant sestavení, ne modulu. You must specify the CLSCompliant attribute on the assembly, not the module, to enable CLS compliance checking Pokud chcete povolit kontrolu kompatibility se specifikací CLS, musíte zadat atribut CLSCompliant sestavení, ne modulu. Added modules must be marked with the CLSCompliant attribute to match the assembly Aby přidávané moduly odpovídaly sestavení, musí být označené atributem CLSCompliant. Added modules must be marked with the CLSCompliant attribute to match the assembly Aby přidávané moduly odpovídaly sestavení, musí být označené atributem CLSCompliant. '{0}' cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute '{0} nejde označit jako kompatibilní se specifikací CLS, protože sestavení nemá atribut CLSCompliant. Type or member cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute Typ nebo člen nejde označit jako kompatibilní se specifikací CLS, protože sestavení nemá atribut CLSCompliant. '{0}' has no accessible constructors which use only CLS-compliant types '{0} nemá žádné přístupné konstruktory, které používají jenom typy kompatibilní se specifikací CLS. Type has no accessible constructors which use only CLS-compliant types Typ nemá žádné přístupné konstruktory, které používají jenom typy kompatibilní se specifikací CLS. Arrays as attribute arguments is not CLS-compliant Pole jako argumenty atributu nejsou kompatibilní se specifikací CLS. Arrays as attribute arguments is not CLS-compliant Pole jako argumenty atributu nejsou kompatibilní se specifikací CLS. You cannot specify the CLSCompliant attribute on a module that differs from the CLSCompliant attribute on the assembly Nejde zadat atribut CLSCompliant u modulu, který se liší od atributu CLSCompliant sestavení. You cannot specify the CLSCompliant attribute on a module that differs from the CLSCompliant attribute on the assembly Nejde zadat atribut CLSCompliant u modulu, který se liší od atributu CLSCompliant sestavení. '{0}' cannot be marked as CLS-compliant because it is a member of non-CLS-compliant type '{1}' '{0} nejde označit jako kompatibilní se specifikací CLS, protože se jedná o člen typu {1}, který není kompatibilní se specifikací CLS. Type cannot be marked as CLS-compliant because it is a member of non-CLS-compliant type Typ nejde označit jako kompatibilní se specifikací CLS, protože se jedná o člen typu, který není kompatibilní se specifikací CLS. CLS compliance checking will not be performed on '{0}' because it is not visible from outside this assembly Pro prvek {0} se neprovede kontrola kompatibility se specifikací CLS, protože není viditelný mimo toto sestavení. CLS compliance checking will not be performed because it is not visible from outside this assembly Kontrola kompatibility se specifikací CLS se neprovede, protože není viditelná zvnějšku tohoto sestavení. '{0}' does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute '{0} nepotřebuje atribut CLSCompliant, protože sestavení nemá atribut CLSCompliant. Type or member does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute Typ nebo člen nepotřebuje atribut CLSCompliant, protože sestavení nemá atribut CLSCompliant. CLSCompliant attribute has no meaning when applied to parameters. Try putting it on the method instead. Atribut CLSCompliant nemá žádný význam při použití u parametrů. Použijte jej místo toho u metody. CLSCompliant attribute has no meaning when applied to parameters Atribut CLSCompliant nemá žádný význam při použití u parametrů. CLSCompliant attribute has no meaning when applied to return types. Try putting it on the method instead. Atribut CLSCompliant nemá žádný význam při použití u typů vrácených hodnot. Použijte jej místo toho u metody. CLSCompliant attribute has no meaning when applied to return types Atribut CLSCompliant nemá žádný význam při použití u návratových typů. Constraint type '{0}' is not CLS-compliant Typ omezení {0} není kompatibilní se specifikací CLS. Constraint type is not CLS-compliant Typ omezení není kompatibilní se specifikací CLS. CLS-compliant field '{0}' cannot be volatile Pole kompatibilní se specifikací CLS {0} nemůže být typu volatile. CLS-compliant field cannot be volatile Pole kompatibilní se specifikací CLS nemůže být typu volatile. '{0}' is not CLS-compliant because base interface '{1}' is not CLS-compliant '{0} není kompatibilní se specifikací CLS, protože základní rozhraní {1} není kompatibilní se specifikací CLS. Type is not CLS-compliant because base interface is not CLS-compliant Typ není kompatibilní se specifikací CLS, protože základní rozhraní není kompatibilní se specifikací CLS. 'await' requires that the type {0} have a suitable 'GetAwaiter' method 'Operátor await vyžaduje, aby typ {0} měl odpovídající metodu GetAwaiter. Cannot await '{0}' Operátor await nejde použít pro {0}. 'await' requires that the return type '{0}' of '{1}.GetAwaiter()' have suitable 'IsCompleted', 'OnCompleted', and 'GetResult' members, and implement 'INotifyCompletion' or 'ICriticalNotifyCompletion' 'Operátor await vyžaduje, aby návratový typ {0} metody {1}.GetAwaiter() měl odpovídající členy IsCompleted, OnCompleted a GetResult a implementoval rozhraní INotifyCompletion nebo ICriticalNotifyCompletion. 'await' requires that the type '{0}' have a suitable 'GetAwaiter' method. Are you missing a using directive for 'System'? 'Operátor await vyžaduje, aby typ {0} měl odpovídající metodu GetAwaiter. Chybí vám direktiva using pro položku System? Cannot await 'void' Operátor await nejde použít pro void. 'await' cannot be used as an identifier within an async method or lambda expression 'Operátor Await nejde použít jako identifikátor v asynchronní metodě nebo výrazu lambda. '{0}' does not implement '{1}' '{0} neimplementuje {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>'? Protože metoda {0} je asynchronní a její návratový typ je Task, za klíčovým slovem return nesmí následovat objektový výraz. Měli jste v úmyslu vrátit hodnotu typu Task<T>? The return type of an async method must be void, Task, Task<T>, a task-like type, IAsyncEnumerable<T>, or IAsyncEnumerator<T> Návratový typ asynchronní metody musí být void, Task, Task<T>, typ podobný úloze, IAsyncEnumerable<T> nebo IAsyncEnumerator<T>. Cannot return an expression of type 'void' Nejde vrátit výraz typu void. __arglist is not allowed in the parameter list of async methods Klíčové slovo __arglist není povolené v seznamu parametrů asynchronních metod. 'await' cannot be used in an expression containing the type '{0}' 'Operátor await nejde použít ve výrazu, který obsahuje typ {0}. Async methods cannot have unsafe parameters or return types Asynchronní metody nemůžou mít návratové typy nebo parametry, které nejsou bezpečné. Async methods cannot have ref, in or out parameters Asynchronní metody nemůžou mít parametry ref, in nebo out. The 'await' operator can only be used when contained within a method or lambda expression marked with the 'async' modifier Operátor await jde použít, jenom pokud je obsažen v metodě nebo výrazu lambda označeném pomocí modifikátoru async. The 'await' operator can only be used within an async {0}. Consider marking this {0} with the 'async' modifier. Operátor await jde použít jenom v asynchronní metodě {0}. Zvažte označení této metody modifikátorem 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}>'. Operátor await jde použít jenom v asynchronních metodách. Zvažte označení této metody modifikátorem async a změnu jejího návratového typu na 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'. Operátor await jde použít jenom v asynchronní metodě. Zvažte označení této metody pomocí modifikátoru async a změnu jejího návratového typu na Task. Cannot await in the body of a finally clause Nejde použít operátor await v těle klauzule finally. Cannot await in a catch clause Operátor await nejde použít v klauzuli catch. Cannot await in the filter expression of a catch clause Nejde použít operátor await ve výrazu filtru klauzule catch. Cannot await in the body of a lock statement Operátor await nejde použít v příkazu lock. The 'await' operator cannot be used in a static script variable initializer. Operátor await nejde použít v inicializátoru proměnné statického skriptu. Cannot await in an unsafe context Operátor await nejde použít v nezabezpečeném kontextu. The 'async' modifier can only be used in methods that have a body. Modifikátor async se dá použít jenom v metodách, které mají tělo. Parameters or locals of type '{0}' cannot be declared in async methods or lambda expressions. Parametry nebo lokální proměnné typu {0} nemůžou být deklarované v asynchronních metodách nebo lambda výrazech. foreach statement cannot operate on enumerators of type '{0}' in async or iterator methods because '{0}' is a ref struct. Výraz foreach nejde použít na enumerátorech typu {0} v asynchronních metodách nebo metodách iterátoru, protože {0} je struktura REF. Security attribute '{0}' cannot be applied to an Async method. Atribut zabezpečení {0} nejde použít pro metodu Async. Async methods are not allowed in an Interface, Class, or Structure which has the 'SecurityCritical' or 'SecuritySafeCritical' attribute. Asynchronní metody nejsou povolené v rozhraní, třídě nebo struktuře, které mají atribut SecurityCritical nebo 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 Operátor await jde použít jenom ve výrazu dotazu v rámci první kolekce výrazu počáteční klauzule from nebo v rámci výrazu kolekce klauzule 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. V této asynchronní metodě chybí operátory await a spustí se synchronně. Zvažte použití operátoru await pro čekání na neblokující volání rozhraní API nebo vykonání činnosti vázané na procesor ve vlákně na pozadí pomocí výrazu await Task.Run(...). Async method lacks 'await' operators and will run synchronously V této asynchronní metodě chybí operátory await a spustí se synchronně. 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. Protože se toto volání neočekává, vykonávání aktuální metody pokračuje před dokončením volání. Zvažte použití operátoru await na výsledek volání. Because this call is not awaited, execution of the current method continues before the call is completed Protože se toto volání neočekává, vykonávání aktuální metody pokračuje před dokončením volání. 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. Aktuální metoda volá asynchronní metodu, která vrací úlohu nebo úlohu<TResult> a ve výsledku nepoužije operátor await. Volání asynchronní metody spustí asynchronní úlohu. Vzhledem k tomu, že se ale nepoužil žádný operátor await, bude program pokračovat bez čekání na dokončení úlohy. Ve většině případů se nejedná o chování, které byste očekávali. Ostatní aspekty volání metody obvykle závisí na výsledcích volání nebo se aspoň očekává, že se volaná metoda dokončí před vaším návratem z metody obsahující volání. Stejně důležité je i to, co se stane s výjimkami, ke kterým dojde ve volané asynchronní metodě. Výjimka, ke které dojde v metodě vracející úlohu nebo úlohu<TResult>, se uloží do vrácené úlohy. Pokud úlohu neočekáváte nebo explicitně výjimky nekontrolujete, dojde ke ztrátě výjimky. Pokud úlohu očekáváte, dojde k výjimce znovu. Nejvhodnějším postupem je volání vždycky očekávat. Potlačení upozornění zvažte jenom v případě, když určitě nechcete čekat na dokončení asynchronního volání a jste si jistí, že volaná metoda nevyvolá žádné výjimky. V takovém případě můžete upozornění potlačit tak, že výsledek úlohy volání přidružíte proměnné. 'MethodImplOptions.Synchronized' cannot be applied to an async method 'Možnost MethodImplOptions.Synchronized nejde použít pro asynchronní metodu. CallerLineNumberAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}' CallerLineNumberAttribute nejde použít, protože neexistuje žádný standardní převod z typu {0} na {1}. CallerFilePathAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}' CallerFilePathAttribute nejde použít, protože neexistuje žádný standardní převod z typu {0} na {1}. CallerMemberNameAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}' CallerMemberNameAttribute nejde použít, protože neexistuje žádný standardní převod z typu {0} na {1}. The CallerLineNumberAttribute may only be applied to parameters with default values Atribut CallerLineNumberAttribute jde použít jenom pro parametry s výchozími hodnotami. The CallerFilePathAttribute may only be applied to parameters with default values Atribut CallerFilePathAttribute jde použít jenom pro parametry s výchozími hodnotami. The CallerMemberNameAttribute may only be applied to parameters with default values Atribut CallerMemberNameAttribute jde použít jenom pro parametry s výchozími hodnotami. 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 CallerLineNumberAttribute použitý u parametru {0} nebude mít žádný účinek, protože se aplikuje u člena, který se používá v kontextech nepovolujících volitelné argumenty. The CallerLineNumberAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments CallerLineNumberAttribute nebude mít žádný efekt, protože platí pro člena, který se používá v kontextech nedovolujících nepovinné argumenty. 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 CallerFilePathAttribute použitý u parametru {0} nebude mít žádný vliv, protože se vztahuje na člen, který je použitý v kontextech nepovolujících volitelné argumenty. The CallerFilePathAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments CallerFilePathAttribute nebude mít žádný vliv, protože se vztahuje na člen, který je použitý v kontextech nepovolujících volitelné argumenty. 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 CallerMemberNameAttribute použitý u parametru {0} nebude mít žádný účinek, protože se aplikuje u člena, který se používá v kontextech nepovolujících volitelné argumenty. The CallerMemberNameAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments CallerMemberNameAttribute nebude mít žádný efekt, protože platí pro člena, který se používá v kontextech nedovolujících nepovinné argumenty. Program does not contain a static 'Main' method suitable for an entry point Program neobsahuje statickou metodu Main vhodnou pro vstupní bod. An array initializer of length '{0}' is expected Očekává se inicializátor pole s délkou {0}. A nested array initializer is expected Očekává se inicializátor vnořeného pole. Invalid variance modifier. Only interface and delegate type parameters can be specified as variant. Modifikátor odchylky je neplatný. Jako variant můžou být určeny jenom parametry typu delegát nebo rozhraní. Unexpected use of an aliased name Neočekávané použití názvu v aliasu Unexpected use of a generic name Neočekávané použití obecného názvu Unexpected use of an unbound generic name Neočekávané použití odvázaného obecného názvu Expressions and statements can only occur in a method body Výrazy a příkazy se můžou vyskytnout jenom v těle metody. An array access may not have a named argument specifier Přístup k poli nemůže mít specifikátor pojmenovaného argumentu. This language feature ('{0}') is not yet implemented. Tato jazyková funkce ({0}) zatím není implementovaná. Default values are not valid in this context. Výchozí hodnoty nejsou v tomto kontextu platné. Error opening icon file {0} -- {1} Chyba při otevírání souboru ikony {0} -- {1} Error opening Win32 manifest file {0} -- {1} Chyba při otevírání souboru manifestu Win32 {0} -- {1} Error building Win32 resources -- {0} Chyba při sestavování prostředků Win32 -- {0} Optional parameters must appear after all required parameters Volitelné parametry musí následovat po všech povinných parametrech Cannot inherit interface '{0}' with the specified type parameters because it causes method '{1}' to contain overloads which differ only on ref and out Nejde dědit rozhraní {0} se zadanými parametry typu, protože to způsobuje, že metoda {1} obsahuje víc přetížení, která se liší jen deklaracemi ref a out. Partial declarations of '{0}' must have the same type parameter names and variance modifiers in the same order Částečné deklarace {0} musí obsahovat názvy parametrů stejného typu a modifikátory odchylek ve stejném pořadí. Invalid variance: The type parameter '{1}' must be {3} valid on '{0}'. '{1}' is {2}. Neplatná odchylka: Parametr typu {1} musí být {3} platný v {0}. {1} je {2}. '{0}': cannot derive from the dynamic type '{0}: Nejde odvozovat z dynamického typu. '{0}': cannot implement a dynamic interface '{1}' '{0}: Nemůže implementovat dynamické rozhraní {1}. Constraint cannot be the dynamic type Omezení nemůže být dynamický typ. Constraint cannot be a dynamic type '{0}' Omezení nemůže být dynamický typ {0}. One or more types required to compile a dynamic expression cannot be found. Are you missing a reference? Jeden nebo více typů požadovaných pro kompilaci dynamického výrazu nejde najít. Nechybí odkaz? Name '{0}' exceeds the maximum length allowed in metadata. Název {0} překračuje maximální délku povolenou v metadatech. Attributes are not valid in this context. Atributy nejsou v tomto kontextu platné. 'extern alias' is not valid in this context 'Alias extern není v tomto kontextu platný. Using '{0}' to test compatibility with '{1}' is essentially identical to testing compatibility with '{2}' and will succeed for all non-null values Použití operátoru {0} pro testování kompatibility s typem {1} je v podstatě totožné s testováním kompatibility s typem {2} a bude úspěšné pro všechny hodnoty, které nejsou null. Using 'is' to test compatibility with 'dynamic' is essentially identical to testing compatibility with 'Object' Použití operátoru is pro testování kompatibility s typem dynamic je v podstatě totožné s testováním kompatibility s typem Object. Cannot use 'yield' in top-level script code Příkaz yield se nedá použít v kódu skriptu nejvyšší úrovně. Cannot declare namespace in script code Obor názvů se nedá deklarovat v kódu skriptu. Assembly and module attributes are not allowed in this context Atributy sestavení a modulů nejsou v tomto kontextu povolené. Delegate '{0}' has no invoke method or an invoke method with a return type or parameter types that are not supported. Delegát {0} nemá žádnou metodu invoke nebo má jeho metoda invoke nepodporovaný návratový typ nebo typy parametrů. The entry point of the program is global code; ignoring '{0}' entry point. Vstupní bod programu je globální kód skriptu; vstupní bod se bude ignorovat {0}. The entry point of the program is global code; ignoring entry point Vstupním bodem programu je globální kód skriptu. Vstupní bod se ignoruje. Inconsistent accessibility: event type '{1}' is less accessible than event '{0}' Nekonzistentní dostupnost: Typ události {1} je míň dostupný než událost {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. Specifikace pojmenovaných argumentů musí následovat po specifikaci všech pevných argumentů. Pokud chcete povolit pojmenované argumenty, které nejsou na konci, použijte prosím jazyk verze {0} nebo vyšší. Named argument specifications must appear after all fixed arguments have been specified in a dynamic invocation. Specifikace pojmenovaných argumentů musí následovat po specifikaci všech pevných argumentů v dynamickém vyvolání. The best overload for '{0}' does not have a parameter named '{1}' Nejlepší přetížení pro {0} neobsahuje parametr s názvem {1}. The delegate '{0}' does not have a parameter named '{1}' Delegát {0} neobsahuje parametr s názvem {1}. Named argument '{0}' cannot be specified multiple times Pojmenovaný argument {0} nejde zadat víckrát. Named argument '{0}' specifies a parameter for which a positional argument has already been given Pojmenovaný argument {0} určuje parametr, pro který už byl poskytnut poziční argument. Named argument '{0}' is used out-of-position but is followed by an unnamed argument Pojmenovaný argument {0} se používá mimo pozici, je ale následovaný nepojmenovaným argumentem. Cannot specify default parameter value in conjunction with DefaultParameterAttribute or OptionalAttribute Nejde zadat výchozí hodnotu parametru v kombinaci s atributy DefaultParameterAttribute nebo OptionalAttribute. Default parameter value for '{0}' must be a compile-time constant Výchozí hodnota parametru pro {0} musí být konstanta definovaná při kompilaci. A ref or out parameter cannot have a default value Parametr Ref nebo Uut nemůže mít výchozí hodnotu. Cannot specify a default value for the 'this' parameter Nejde zadat výchozí hodnotu pro parametr this. Cannot specify a default value for a parameter array Nejde zadat výchozí hodnotu pro pole parametrů. A value of type '{0}' cannot be used as a default parameter because there are no standard conversions to type '{1}' Hodnotu typu {0} nejde použít jako výchozí parametr, protože neexistují žádné standardní převody na typ {1}. A value of type '{0}' cannot be used as default parameter for nullable parameter '{1}' because '{0}' is not a simple type Hodnotu typu {0} nejde použít jako výchozí hodnotu parametru {1} s možnou hodnotou null, protože {0} není jednoduchý typ. '{0}' is of type '{1}'. A default parameter value of a reference type other than string can only be initialized with null '{0} je typu {1}. Výchozí hodnotu parametru s jiným než řetězcovým typem odkazu jde inicializovat jenom hodnotou 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 Výchozí hodnota zadaná pro parametr {0} nebude mít žádný efekt, protože platí pro člen, který se používá v kontextech nedovolujících nepovinné argumenty. 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 Určená výchozí hodnota nebude mít žádný efekt, protože platí pro člena, který se používá v kontextech nedovolujících nepovinné argumenty. Error signing output with public key from file '{0}' -- {1} Chyba při podepisování výstupu pomocí veřejného klíče ze souboru {0} -- {1} Error signing output with public key from container '{0}' -- {1} Chyba při podepisování výstupu pomocí veřejného klíče z kontejneru {0} -- {1} The typeof operator cannot be used on the dynamic type Operátor typeof nejde použít na tento dynamický typ. An expression tree may not contain a dynamic operation Strom výrazu nemůže obsahovat dynamickou operaci. Async lambda expressions cannot be converted to expression trees Asynchronní výrazy lambda nejde převést na stromy výrazů. Cannot define a class or member that utilizes 'dynamic' because the compiler required type '{0}' cannot be found. Are you missing a reference? Nejde definovat třídu nebo člen, který používá typ dynamic, protože se nedá najít typ {0} požadovaný kompilátorem. Nechybí odkaz? Cannot pass null for friend assembly name Jako název sestavení typu Friend nejde předat hodnotu Null. Key file '{0}' is missing the private key needed for signing V souboru klíče {0} chybí privátní klíč potřebný k podepsání. Public signing was specified and requires a public key, but no public key was specified. Byl určený veřejný podpis, který vyžaduje veřejný klíč, nebyl ale zadaný žádný veřejný klíč. Public signing is not supported for netmodules. Veřejné podepisování netmodulů se nepodporuje. Delay signing was specified and requires a public key, but no public key was specified Je určené zpožděné podepsání, které vyžaduje veřejný klíč, ale není zadaný žádný veřejný klíč. Delay signing was specified and requires a public key, but no public key was specified Je určené zpožděné podepsání, které vyžaduje veřejný klíč, ale není zadaný žádný veřejný klíč. The specified version string does not conform to the required format - major[.minor[.build[.revision]]] Zadaný řetězec verze není v souladu s požadovaným formátem – hlavní_verze[.dílčí_verze[.build[.revize]]]. 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 Zadaný řetězec verze obsahuje zástupné znaky, které nejsou kompatibilní s determinismem. Odeberte zástupné znaky z řetězce verze nebo pro tuto kompilaci zakažte determinismus. The specified version string does not conform to the required format - major.minor.build.revision (without wildcards) Zadaný řetězec verze není v souladu s požadovaným formátem – hlavní_verze.dílčí_verze.build.revize (bez zástupných znaků). The specified version string does not conform to the recommended format - major.minor.build.revision Zadaný řetězec verze není v souladu s doporučeným formátem – hlavní_verze.dílčí_verze.build.revize. The specified version string does not conform to the recommended format - major.minor.build.revision Zadaný řetězec verze není v souladu s doporučeným formátem – hlavní_verze.dílčí_verze.build.revize. Executables cannot be satellite assemblies; culture should always be empty Spustitelné soubory nemůžou být satelitními sestaveními; jazyková verze by vždy měla být prázdná. There is no argument given that corresponds to the required formal parameter '{0}' of '{1}' Není dán žádný argument, který by odpovídal požadovanému formálnímu parametru {0} v {1}. The command line switch '{0}' is not yet implemented and was ignored. Přepínač příkazového řádku {0} ještě není implementovaný, a tak se ignoroval. Command line switch is not yet implemented Přepínač příkazového řádku zatím není implementovaný. Failed to emit module '{0}': {1} Nepovedlo se vygenerovat modul {0}: {1} Cannot use fixed local '{0}' inside an anonymous method, lambda expression, or query expression Pevnou lokální proměnnou {0} nejde použít v anonymní metodě, lambda výrazu nebo výrazu dotazu. An expression tree may not contain a named argument specification Strom výrazu nemůže obsahovat specifikaci pojmenovaného argumentu. An expression tree may not contain a call or invocation that uses optional arguments Strom výrazu nemůže obsahovat volání, které používá nepovinné argumenty. An expression tree may not contain an indexed property Strom výrazu nemůže obsahovat indexovanou vlastnost. Indexed property '{0}' has non-optional arguments which must be provided Indexovaná vlastnost {0} má argumenty, které nejsou nepovinné a je třeba je zadat. Indexed property '{0}' must have all arguments optional Indexovaná vlastnost {0} musí mít všechny argumenty volitelné. Instance of type '{0}' cannot be used inside a nested function, query expression, iterator block or async method Instance typu {0} nelze použít uvnitř vnořené funkce, výrazu dotazu, bloku iterátoru nebo asynchronní metody. First argument to a security attribute must be a valid SecurityAction První argument atributu zabezpečení musí být platný SecurityAction. Security attribute '{0}' has an invalid SecurityAction value '{1}' Atribut zabezpečení {0} má neplatnou hodnotu SecurityAction {1}. SecurityAction value '{0}' is invalid for security attributes applied to an assembly Hodnota SecurityAction {0} není platná pro atributy zabezpečení použité u sestavení. SecurityAction value '{0}' is invalid for security attributes applied to a type or a method Hodnota SecurityAction {0} není platná pro atributy zabezpečení použité u typu nebo metody. SecurityAction value '{0}' is invalid for PrincipalPermission attribute Hodnota SecurityAction {0} není platná pro atribut PrincipalPermission. An expression tree may not contain '{0}' Strom výrazu nesmí obsahovat {0}. Unable to resolve file path '{0}' specified for the named argument '{1}' for PermissionSet attribute Nejde vyřešit cestu k souboru {0} zadanému pro pojmenovaný argument {1} pro atribut PermissionSet. Error reading file '{0}' specified for the named argument '{1}' for PermissionSet attribute: '{2}' Chyba při čtení souboru {0} zadaného pro pojmenovaný argument {1} pro atribut 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. Název typu {0} se nepovedlo najít v globálním oboru názvů. Tento typ se předal do sestavení {1}. Zvažte přidání odkazu do tohoto sestavení. 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. Název typu {0} se nepovedlo najít v oboru názvů {1}. Tento typ se předal do sestavení {2}. Zvažte přidání odkazu do tohoto sestavení. The type name '{0}' could not be found. This type has been forwarded to assembly '{1}'. Consider adding a reference to that assembly. Název typu {0} se nenašel. Typ se předal do sestavení {1}. Zvažte přidání odkazu do tohoto sestavení. 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. Sestavení {0} a {1} odkazují na stejná metadata, ale jenom v jednom případě je to propojený odkaz (zadaný s možností /link). Zvažte odebrání jednoho z odkazů. The best overloaded Add method '{0}' for the collection initializer element is obsolete. Optimální přetěžovaná metoda Add {0} pro element inicializátoru kolekce je zastaralá. The best overloaded Add method for the collection initializer element is obsolete Optimální přetěžovaná metoda Add pro element inicializátoru kolekce je zastaralá. The best overloaded Add method '{0}' for the collection initializer element is obsolete. {1} Optimální přetěžovaná metoda Add {0} pro element inicializátoru kolekce je zastaralá. {1} The best overloaded Add method for the collection initializer element is obsolete Optimální přetěžovaná metoda Add pro element inicializátoru kolekce je zastaralá. The best overloaded Add method '{0}' for the collection initializer element is obsolete. {1} Optimální přetěžovaná metoda Add {0} pro element inicializátoru kolekce je zastaralá. {1} Yield statements may not appear at the top level in interactive code. Příkazy yield se nesmí objevit na horní úrovni v interaktivním kódu. Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations. Atribut zabezpečení {0} není platný u tohoto typu deklarace. Atributy zabezpečení jsou platné jenom u deklarací sestavení, typu a metody. Cannot use an expression of type '{0}' as an argument to a dynamically dispatched operation. Nejde použít výraz typu {0} jako argument pro dynamicky volanou operaci. Cannot use a lambda expression as an argument to a dynamically dispatched operation without first casting it to a delegate or expression tree type. Výraz lambda nejde použít jako argument dynamicky volané operace, aniž byste ho nejprve použili na typy delegát nebo strom výrazů. Cannot use a method group as an argument to a dynamically dispatched operation. Did you intend to invoke the method? Skupinu metod nejde použít jako argument v dynamicky volané operaci. Měli jste v úmyslu tuto metodu vyvolat? 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. Volání do metody {0} je nutné volat dynamicky, což ale není možné, protože je součástí výrazu základního přístupu. Zvažte přetypování dynamických argumentů nebo eliminaci základního přístupu. Query expressions over source type 'dynamic' or with a join sequence of type 'dynamic' are not allowed Výrazy dotazů se zdrojovým typem dynamic nebo se spojenou sekvencí typu dynamic nejsou povolené. 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. Přístup indexeru je nutné volat dynamicky, což ale není možné, protože je součástí výrazu základního přístupu. Zvažte použití dynamických argumentů nebo eliminaci základního přístupu. The dynamically dispatched call to method '{0}' may fail at runtime because one or more applicable overloads are conditional methods. Dynamicky volané volání do metody {0} se za běhu nemusí zdařit, protože nejmíň jedno použitelné přetížení je podmíněná metoda. Dynamically dispatched call may fail at runtime because one or more applicable overloads are conditional methods Dynamicky volané volání může za běhu selhat, protože nejmíň jedno použitelné přetížení představuje podmíněnou metodu. '{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} nemá žádnou použitelnou metodu s názvem {1}, ale zřejmě má metodu rozšíření s tímto názvem. Metody rozšíření se nedají volat dynamicky. Zvažte použití dynamických argumentů nebo volání metody rozšíření bez syntaxe metody rozšíření. The CallerMemberNameAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerFilePathAttribute. CallerMemberNameAttribute použitý u parametru {0} nebude mít žádný účinek. Přepíše ho CallerFilePathAttribute. The CallerMemberNameAttribute will have no effect; it is overridden by the CallerFilePathAttribute CallerMemberNameAttribute nebude mít žádný efekt. Přepisuje ho CallerFilePathAttribute. The CallerMemberNameAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerLineNumberAttribute. CallerMemberNameAttribute použitý u parametru {0} nebude mít žádný účinek. Přepíše ho CallerLineNumberAttribute. The CallerMemberNameAttribute will have no effect; it is overridden by the CallerLineNumberAttribute CallerMemberNameAttribute nebude mít žádný efekt. Přepisuje ho CallerLineNumberAttribute. The CallerFilePathAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerLineNumberAttribute. CallerFilePathAttribute použitý u parametru {0} nebude mít žádný účinek. Přepíše ho CallerLineNumberAttribute. The CallerFilePathAttribute will have no effect; it is overridden by the CallerLineNumberAttribute CallerFilePathAttribute nebude mít žádný efekt. Přepisuje ho CallerLineNumberAttribute. Expression must be implicitly convertible to Boolean or its type '{0}' must define operator '{1}'. Výraz musí být implicitně převeditelný na logickou hodnotu nebo její typ {0} musí definovat operátor {1}. '{0}' cannot implement '{1}' because '{2}' is a Windows Runtime event and '{3}' is a regular .NET event. '{0} nemůže implementovat {1}, protože {2} je událost Windows Runtimu a {3} je normální událost .NET. Call System.IDisposable.Dispose() on allocated instance of {0} before all references to it are out of scope. Vyvolejte System.IDisposable.Dispose() na přidělenou instanci {0} dřív, než budou všechny odkazy na ni mimo obor. Call System.IDisposable.Dispose() on allocated instance before all references to it are out of scope Vyvolejte System.IDisposable.Dispose() u přidělené instance, než budou všechny odkazy na ni mimo rozsah. Allocated instance of {0} is not disposed along all exception paths. Call System.IDisposable.Dispose() before all references to it are out of scope. Přidělená instance {0} se neuvolní v průběhu všech cest výjimky. Vyvolejte System.IDisposable.Dispose() dřív, než budou všechny odkazy na ni mimo obor. Allocated instance is not disposed along all exception paths Přidělená instance není uvolněná v průběhu všech cest výjimek. Object '{0}' can be disposed more than once. Objekt {0} se dá uvolnit víc než jednou. Object can be disposed more than once Objekt se dá uvolnit víc než jednou. Interop type '{0}' cannot be embedded. Use the applicable interface instead. Typ spolupráce {0} nemůže být vložený. Místo něho použijte použitelné rozhraní. Type '{0}' cannot be embedded because it is a nested type. Consider setting the 'Embed Interop Types' property to false. Typ {0} nemůže být vložený, protože je vnořeným typem. Zvažte nastavení vlastnosti Vložit typy spolupráce na false. Type '{0}' cannot be embedded because it has a generic argument. Consider setting the 'Embed Interop Types' property to false. Typ {0} nemůže být vložený, protože má obecný argument. Zvažte nastavení vlastnosti Vložit typy spolupráce na hodnotu false. Embedded interop struct '{0}' can contain only public instance fields. Vložená struktura spolupráce {0} může obsahovat jenom veřejné položky instance. A Windows Runtime event may not be passed as an out or ref parameter. Událost Windows Runtimu se nesmí předat jako parametr out nebo ref. Source interface '{0}' is missing method '{1}' which is required to embed event '{2}'. Zdrojovému rozhraní {0} chybí metoda {1}, která se vyžaduje pro vložení události {2}. Interface '{0}' has an invalid source interface which is required to embed event '{1}'. Rozhraní {0} má neplatné zdrojové rozhraní, které se vyžaduje pro vložení události {1}. Interop type '{0}' cannot be embedded because it is missing the required '{1}' attribute. Typ spolupráce {0} nemůže být vložený, protože postrádá požadovaný atribut {1}. Cannot embed interop types from assembly '{0}' because it is missing the '{1}' attribute. Nejde vložit typy spolupráce pro sestavení {0}, protože postrádá atribut {1}. Cannot embed interop types from assembly '{0}' because it is missing either the '{1}' attribute or the '{2}' attribute. Nejde vložit typy spolupráce ze sestavení {0}, protože postrádá buď atribut {1}, nebo atribut {2}. Cannot embed interop type '{0}' found in both assembly '{1}' and '{2}'. Consider setting the 'Embed Interop Types' property to false. Nejde vložit typ spolupráce {0} nalezený v sestavení {1} i {2}. Zvažte nastavení vlastnosti Vložit typy spolupráce na hodnotu 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. Vložení typu spolupráce {0} ze sestavení {1} způsobí konflikt názvů v aktuálním sestavení. Zvažte nastavení vlastnosti Vložit typy spolupráce na 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. Vytvořil se odkaz na vložené sestavení vzájemné spolupráce {0}, protože existuje nepřímý odkaz na toto sestavení ze sestavení {1}. Zvažte změnu vlastnosti Vložit typy vzájemné spolupráce u obou sestavení. A reference was created to embedded interop assembly because of an indirect assembly reference Byl vytvořený odkaz na vložené definiční sestavení z důvodu nepřímého odkazu na toto sestavení. 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. Přidali jste odkaz na sestavení pomocí parametru /link (vlastnost Přibalit definované typy nastavená na True). Tím se kompilátoru dává instrukce, aby vložil informace o typech spolupráce z tohoto sestavení. Kompilátor ale nemůže tyto informace z tohoto sestavení vložit, protože jiné sestavení, na které jste nastavili odkaz, odkazuje taky na toto sestavení, a to pomocí parametru /reference (vlastnost Přibalit definované typy nastavená na False). Pokud chcete vložit informace o typech spolupráce pro obě sestavení, odkazujte na každé z nich pomocí parametru /link (vlastnost Přibalit definované typy nastavená na True). Pokud chcete odstranit toto varování, můžete místo toho použít /reference (vlastnost Přibalit definované typy nastavená na False). V tomto případě uvedené informace poskytne primární definiční sestavení (PIA). Type '{0}' from assembly '{1}' cannot be used across assembly boundaries because it has a generic type argument that is an embedded interop type. Typ {0} ze sestavení {1} se nedá použít přes hranice sestavení, protože má argument obecného typu, který je vloženým definičním typem. Cannot find the interop type that matches the embedded interop type '{0}'. Are you missing an assembly reference? Nejde najít typ spolupráce, který odpovídá vloženému typu {0}. Nechybí odkaz na sestavení? By-reference return type 'ref {0}' is not supported. Návratový typ podle odkazu ref {0} se nepodporuje. Module name '{0}' stored in '{1}' must match its filename. Název modulu {0} uložený v {1} musí odpovídat svému názvu souboru. Invalid module name: {0} Neplatný název modulu: {0} Invalid '{0}' value: '{1}'. Neplatná hodnota {0}: {1} AppConfigPath must be absolute. AppConfigPath musí být absolutní. Attribute '{0}' from module '{1}' will be ignored in favor of the instance appearing in source Atribut {0} z modulu {1} se bude ignorovat ve prospěch instance, která se objeví ve zdroji. Attribute will be ignored in favor of the instance appearing in source Atribut se bude ignorovat ve prospěch instance zobrazené ve zdroji. Attribute '{0}' given in a source file conflicts with option '{1}'. Atribut {0} daný ve zdrojovém souboru je v konfliktu s možností {1}. A fixed buffer may only have one dimension. Pevná vyrovnávací paměť může mít jen jednu dimenzi. Referenced assembly '{0}' does not have a strong name. Odkazované sestavení {0} nemá silný název. Referenced assembly does not have a strong name Odkazované sestavení nemá silný název. Invalid signature public key specified in AssemblySignatureKeyAttribute. V atributu AssemblySignatureKeyAttribute je uvedený neplatný veřejný klíč podpisu. Type '{0}' exported from module '{1}' conflicts with type declared in primary module of this assembly. Typ {0} exportovaný z modulu {1} je v konfliktu s typem deklarovaným v primárním modulu tohoto sestavení. Type '{0}' exported from module '{1}' conflicts with type '{2}' exported from module '{3}'. Typ {0} exportovaný z modulu {1} je v konfliktu s typem {2} exportovaným z modulu {3}. Forwarded type '{0}' conflicts with type declared in primary module of this assembly. Předaný typ {0} je v konfliktu s typem deklarovaným v primárním modulu tohoto sestavení. Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' forwarded to assembly '{3}'. Typ {0} předaný do sestavení {1} je v konfliktu s typem {2} předaným do sestavení {3}. Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' exported from module '{3}'. Typ {0} předaný do sestavení {1} je v konfliktu s typem {2} exportovaným z modulu {3}. Referenced assembly '{0}' has different culture setting of '{1}'. Odkazované sestavení {0} má jiné nastavení jazykové verze {1}. Referenced assembly has different culture setting Odkazované sestavení má jiné nastavení jazykové verze. Agnostic assembly cannot have a processor specific module '{0}'. Agnostické sestavení nemůže mít modul {0} určený pro konkrétní procesor. Assembly and module '{0}' cannot target different processors. Sestavení a modul {0} nemůžou mířit na různé procesory. Referenced assembly '{0}' targets a different processor. Odkazované sestavení {0} míří na jiný procesor. Referenced assembly targets a different processor Odkazované sestavení míří na jiný procesor. Cryptographic failure while creating hashes. Při vytváření čísel hash došlo ke kryptografické chybě. Reference to '{0}' netmodule missing. Chybí odkaz na netmodule {0}. Module '{0}' is already defined in this assembly. Each module must have a unique filename. Modul {0} je už v tomto sestavení definovaný. Každý modul musí mít jedinečný název souboru. Cannot read config file '{0}' -- '{1}' Nejde přečíst konfigurační soubor {0} -- {1}. Cannot continue since the edit includes a reference to an embedded type: '{0}'. Nedá se pokračovat, protože úprava obsahuje odkaz na vložený typ: {0} Member '{0}' added during the current debug session can only be accessed from within its declaring assembly '{1}'. Ke členu {0} přidanému během aktuální relace ladění se dá přistupovat jenom z jeho deklarovaného sestavení {1}. Compilation options '{0}' and '{1}' can't both be specified at the same time. Možnosti kompilace {0} a {1} se nedají zadat současně. Linked netmodule metadata must provide a full PE image: '{0}'. Propojená metadata netmodule musí poskytovat plnou image PE: {0}. /platform:anycpu32bitpreferred can only be used with /t:exe, /t:winexe and /t:appcontainerexe Možnost /platform:anycpu32bitpreferred jde použít jenom s možnostmi /t:exe, /t:winexe a /t:appcontainerexe. <path list> <seznam cest> <text> <text> null propagating operator operátor šířící null expression-bodied method metoda s výrazem v těle expression-bodied property vlastnost s výrazem v těle expression-bodied indexer indexer s výrazem v těle auto property initializer automatický inicializátor vlastnosti <namespace> <obor názvů> byref locals and returns lokální proměnné a vrácení podle odkazu readonly references odkazy jen pro čtení ref structs struktury REF Compilation (C#): Kompilace (C#): Syntax node is not within syntax tree Uzel syntaxe není ve stromu syntaxe. Location must be provided in order to provide minimal type qualification. Musí být zadané umístění, aby se zajistila minimální kvalifikace typu. SyntaxTreeSemanticModel must be provided in order to provide minimal type qualification. Musí být zadaný SyntaxTreeSemanticModel, aby se zajistila minimální kvalifikace typu. Can't reference compilation of type '{0}' from {1} compilation. Na kompilaci typu {0} nejde odkazovat z kompilace {1}. Syntax tree already present Strom syntaxe už je přítomný. Submission can only include script code. Odeslání může zahrnovat jenom kód skriptu. Submission can have at most one syntax tree. Odeslání musí mít aspoň jeden strom syntaxe. tree must have a root node with SyntaxKind.CompilationUnit strom musí mít kořenový uzel s prvkem SyntaxKind.CompilationUnit Type argument cannot be null Argument typu nemůže být null. Wrong number of type arguments Chybný počet argumentů typu Name conflict for name {0} Konflikt u názvu {0} LookupOptions has an invalid combination of options LookupOptions má neplatnou kombinaci možností. items: must be non-empty Položky: Nesmí být prázdné. Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier or Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier to create identifier tokens. Pomocí Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier nebo Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier můžete vytvořit tokeny identifikátorů. Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal to create character literal tokens. Pomocí Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal můžete vytvořit znakové literálové tokeny. Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal to create numeric literal tokens. Pomocí Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal můžete vytvořit numerické literálové tokeny. This method can only be used to create tokens - {0} is not a token kind. Tato metoda se dá používat jenom k vytváření tokenů – {0} není druh tokenu. Generic parameter is definition when expected to be reference {0} Obecný parametr je definice, i když se očekával odkaz {0}. Called GetDeclarationName for a declaration node that can possibly contain multiple variable declarators. Proběhlo volání funkce GetDeclarationName kvůli uzlu deklarací, který by mohl obsahovat několik variabilních deklarátorů. tree not part of compilation strom není součástí kompilace Position is not within syntax tree with full span {0} Pozice není v rámci stromu syntaxe s plným rozpětím {0}. The language name '{0}' is invalid. Název jazyka {0} je neplatný. The language name is invalid Název jazyka je neplatný. Transparent identifier member access failed for field '{0}' of '{1}'. Does the data being queried implement the query pattern? U pole {0} v {1} selhal přístup pro členy s transparentním identifikátorem. Implementují dotazovaná data vzor dotazu? The parameter has multiple distinct default values. Parametr má víc odlišných výchozích hodnot. The field has multiple distinct constant values. Pole má víc odlišných konstantních hodnot. Within cref attributes, nested types of generic types should be qualified. V atributech cref by měly být kvalifikované vnořené typy obecných typů. Within cref attributes, nested types of generic types should be qualified V atributech cref by měly být kvalifikované vnořené typy obecných typů. Not a C# symbol. Nepředstavuje symbol C#. Unnecessary using directive. Nepotřebná direktiva using Unused extern alias. Nepoužívaný alias extern Elements cannot be null. Elementy nemůžou mít hodnotu null. LIB environment variable proměnná prostředí LIB /LIB option parametr /LIB /REFERENCEPATH option Možnost /REFERENCEPATH directory does not exist adresář neexistuje path is too long or invalid cesta je moc dlouhá nebo neplatná. No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options. Nenašla se žádná hodnota RuntimeMetadataVersion, žádné sestavení obsahující System.Object ani nebyla v možnostech zadaná hodnota pro RuntimeMetadataVersion. No value for RuntimeMetadataVersion found Nenašla se žádná hodnota pro RuntimeMetadataVersion. Expected a {0} SemanticModel. Očekával se SemanticModel {0}. lambda expression výraz lambda Feature '{0}' is not available in C# 1. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 1. Použijte prosím jazyk verze {1} nebo vyšší. Feature '{0}' is not available in C# 2. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 2. Použijte prosím jazyk verze {1} nebo vyšší. Feature '{0}' is not available in C# 3. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 3. Použijte prosím jazyk verze {1} nebo vyšší. Feature '{0}' is not available in C# 4. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 4. Použijte prosím jazyk verze {1} nebo vyšší. Feature '{0}' is not available in C# 5. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 5. Použijte prosím jazyk verze {1} nebo vyšší. Feature '{0}' is not available in C# 6. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 6. Použijte prosím jazyk verze {1} nebo vyšší. Feature '{0}' is not available in C# 7.0. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 7.0. Použijte prosím jazyk verze {1} nebo vyšší. 'experimental' '"experimentální" Position must be within span of the syntax tree. Pozice musí být v rozpětí stromu syntaxe. Syntax node to be speculated cannot belong to a syntax tree from the current compilation. Uzel syntaxe určený ke spekulaci nemůže patřit do stromu syntaxe z aktuální kompilace. Chaining speculative semantic model is not supported. You should create a speculative model from the non-speculative ParentModel. Zřetězení spekulativního sémantického modelu se nepodporuje. Měli byste vytvořit spekulativní model z nespekulativního modelu ParentModel. Microsoft (R) Visual C# Compiler Kompilátor Microsoft (R) Visual C# {0} version {1} {0} verze {1} Copyright (C) Microsoft Corporation. All rights reserved. Copyright (C) Microsoft Corporation. Všechna práva vyhrazena. Supported language versions: Podporované jazykové verze: '{0}': a class with the ComImport attribute cannot specify field initializers. '{0}: Třída s atributem ComImport nemůže určovat inicializátory polí. Local name '{0}' is too long for PDB. Consider shortening or compiling without /debug. Místní název {0} je moc dlouhý pro PDB. Zvažte jeho zkrácení nebo kompilaci bez /debug. Local name is too long for PDB Lokální název je moc dlouhý pro PDB. Anonymous function converted to a void returning delegate cannot return a value Anonymní funkce převedená na void, která vrací delegáta, nemůže vracet hodnotu. Async lambda expression converted to a 'Task' returning delegate cannot return a value. Did you intend to return 'Task<T>'? Asynchronní lambda výraz převedený na Task a vracející delegáta nemůže vrátit hodnotu. Měli jste v úmyslu vrátit Task<T>? An instance of analyzer {0} cannot be created from {1} : {2}. Instance analyzátoru {0} nejde vytvořit z {1} : {2}. An analyzer instance cannot be created Nedá se vytvořit instance analyzátoru. The assembly {0} does not contain any analyzers. Sestavení {0} neobsahuje žádné analyzátory. Assembly does not contain any analyzers Sestavení neobsahuje žádné analyzátory. Unable to load Analyzer assembly {0} : {1} Nejde načíst sestavení analyzátoru {0} : {1}. Unable to load Analyzer assembly Nejde načíst sestavení analyzátoru. Skipping some types in analyzer assembly {0} due to a ReflectionTypeLoadException : {1}. Přeskočí se některé typy v sestavení analyzátoru {0} kvůli výjimce ReflectionTypeLoadException: {1}. Error reading ruleset file {0} - {1} Chyba při čtení souboru sady pravidel {0} - {1} Error reading debug information for '{0}' Chyba při čtení informací ladění pro {0} Operation caused a stack overflow. Operace způsobila přetečení zásobníku. Expected identifier or numeric literal. Očekával se identifikátor nebo číselný literál. Expected identifier or numeric literal Očekával se identifikátor nebo číselný literál. Only auto-implemented properties can have initializers. Jenom automaticky implementované vlastnosti můžou mít inicializátory. Auto-implemented properties must have get accessors. Automaticky implementované vlastnosti musí mít přistupující objekty get. Auto-implemented properties must override all accessors of the overridden property. Automaticky implementované vlastnosti musí přepsat všechny přistupující objekty přepsané vlastnosti. Structs without explicit constructors cannot contain members with initializers. Struktury bez explicitních konstruktorů nemůžou obsahovat členy s inicializátory. Cannot emit debug information for a source text without encoding. Nejde vygenerovat ladicí informace pro zdrojový text bez kódování. Block bodies and expression bodies cannot both be provided. Nejde zadat těla bloků i těla výrazů. Control cannot fall out of switch from final case label ('{0}') Řízení nemůže opustit příkaz switch z posledního příkazu case ('{0}') Type arguments are not allowed in the nameof operator. Argumenty typů nejsou v operátoru nameof povoleny. An expression tree lambda may not contain a null propagating operator. Strom výrazu lambda nesmí obsahovat operátor šířící null. An expression tree lambda may not contain a dictionary initializer. Strom výrazu lambda nesmí obsahovat inicializátor slovníku. An extension Add method is not supported for a collection initializer in an expression lambda. Rozšiřující metoda Add není pro inicializátor kolekce v lambda výrazu podporovaná. nameof operator operátor nameof dictionary initializer inicializátor slovníku Missing close delimiter '}' for interpolated expression started with '{'. Chybí uzavírací oddělovač } pro interpolovaný výraz začínající na {. A single-line comment may not be used in an interpolated string. V interpolovaném řetězci se nemůže používat jednořádkový komentář. An expression is too long or complex to compile Výraz je pro zkompilování moc dlouhý nebo složitý. Expression does not have a name. Výraz není pojmenovaný. Sub-expression cannot be used in an argument to nameof. Dílčí výraz se jako argument nameof nedá použít. An alias-qualified name is not an expression. Název kvalifikovaný pomocí aliasu není výraz. Type parameters are not allowed on a method group as an argument to 'nameof'. Parametry typu se u skupiny metod nedají použít jako argument nameof. SearchCriteria is expected. Očekává se třída SearchCriteria. Assembly culture strings may not contain embedded NUL characters. Řetězce jazykové verze sestavení nesmí obsahovat vložené znaky NUL. using static using static interpolated strings interpolované řetězce await in catch blocks and finally blocks očekávat v blocích catch a blocích finally binary literals binární literály digit separators oddělovače číslic local functions místní funkce A '{0}' character must be escaped (by doubling) in an interpolated string. Znak {0} musí být v interpolovaném řetězci uvozený (zdvojeným znakem). A '{0}' character may only be escaped by doubling '{0}{0}' in an interpolated string. V interpolovaném řetězci může být znak {0} uvozený jenom zdvojeným znakem ({0}{0}). A format specifier may not contain trailing whitespace. Specifikátor formátu nesmí na konci obsahovat mezeru. Empty format specifier. Prázdný specifikátor formátu There is an error in a referenced assembly '{0}'. V odkazovaném sestavení {0} je chyba. Expression or declaration statement expected. Očekával se příkaz s výrazem nebo deklarací. Extension method groups are not allowed as an argument to 'nameof'. Skupiny metod rozšíření nejsou povolené jako argument pro nameof. Alignment value {0} has a magnitude greater than {1} and may result in a large formatted string. Hodnota zarovnání {0} má velikost větší než {1} a jejím výsledkem může být velký formátovaný řetězec. Unused extern alias Nepoužívaný externí alias Unnecessary using directive Nepotřebná direktiva using Skip loading types in analyzer assembly that fail due to a ReflectionTypeLoadException Přeskočí načtení typů v sestavení analyzátoru, které selžou kvůli výjimce ReflectionTypeLoadException. Alignment value has a magnitude that may result in a large formatted string Hodnota zarovnání má velikost, jejímž výsledkem může být velký formátovaný řetězec. Length of String constant resulting from concatenation exceeds System.Int32.MaxValue. Try splitting the string into multiple constants. Délka konstanty String, která je výsledkem zřetězení, překračuje hodnotu System.Int32.MaxValue. Zkuste rozdělit řetězec na více konstant. Tuple must contain at least two elements. Řazená kolekce členů musí obsahovat minimálně dva elementy. Debug entry point must be a definition of a method declared in the current compilation. Vstupní bod ladění musí být definicí metody deklarované v aktuální kompilaci. #load is only allowed in scripts #load se povoluje jenom ve skriptech Cannot use #load after first token in file Za prvním tokenem v souboru se nedá použít #load. Could not find file. Nepovedlo se najít soubor. File path referenced in source (#load) could not be resolved. SyntaxTree resulted from a #load directive and cannot be removed or replaced directly. SyntaxTree je výsledkem direktivy #load a nedá se odebrat nebo nahradit přímo. Source file references are not supported. Odkazy na zdrojový soubor se nepodporují. The pathmap option was incorrectly formatted. Možnost pathmap nebyla správně naformátovaná. Invalid real literal. Neplatný literál real Auto-implemented properties cannot return by reference Automaticky implementované vlastnosti nejde vrátit pomocí odkazu. Properties which return by reference must have a get accessor Vlastnosti, které vracejí pomocí odkazu, musí mít přístupový objekt get. Properties which return by reference cannot have set accessors Vlastnosti, které vracejí pomocí odkazu, nemůžou mít přístupové objekty set. '{0}' must match by reference return of overridden member '{1}' '{0} musí odpovídat návratu pomocí odkazu přepsaného člena {1}. By-reference returns may only be used in methods that return by reference Vrácení podle odkazu se dají používat jenom v metodách, které vracejí pomocí odkazu. By-value returns may only be used in methods that return by value Vrácení podle hodnoty se dají používat jenom v metodách, které vracejí podle hodnoty. The return expression must be of type '{0}' because this method returns by reference Návratový výraz musí být typu {0}, protože tato metoda vrací pomocí odkazu. '{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}' because it does not have matching return by reference. '{0} neimplementuje člena rozhraní {1}. {2} nemůže implementovat {1}, protože nemá odpovídající návrat pomocí odkazu. The body of '{0}' cannot be an iterator block because '{0}' returns by reference Hlavní část objektu {0} nemůže představovat blok iterátoru, protože {0} se vrací pomocí odkazu. Lambda expressions that return by reference cannot be converted to expression trees Výrazy lambda, které se vrací pomocí odkazu, nejde převést na stromy výrazů. An expression tree lambda may not contain a call to a method, property, or indexer that returns by reference Lambda stromu výrazů nesmí obsahovat volání do metody, vlastnosti nebo indexeru, které vrací pomocí odkazu. An expression cannot be used in this context because it may not be passed or returned by reference Výraz nelze v tomto kontextu použít, protože nesmí být předaný nebo vrácený pomocí odkazu. Cannot return '{0}' by reference because it was initialized to a value that cannot be returned by reference {0} nejde vrátit pomocí odkazu, protože bylo inicializované na hodnotu, která nemůže být vrácená pomocí odkazu. Cannot return by reference a member of '{0}' because it was initialized to a value that cannot be returned by reference Člen pro {0} nejde vrátit pomocí odkazu, protože bylo inicializované na hodnotu, která nemůže být vrácená pomocí odkazu. Cannot return '{0}' by reference because it is read-only {0} nejde vrátit pomocí odkazu, protože je to hodnota jen pro čtení. Cannot return the range variable '{0}' by reference Proměnnou rozsahu {0} nejde vrátit pomocí odkazu. Cannot return '{0}' by reference because it is a '{1}' {0} nejde vrátit pomocí odkazu, protože je to {1}. Cannot return fields of '{0}' by reference because it is a '{1}' Pole elementu {0} nejde vrátit pomocí odkazu, protože je to {1}. A readonly field cannot be returned by writable reference Pole jen pro čtení nejde vrátit zapisovatelným odkazem. A static readonly field cannot be returned by writable reference Statické pole jen pro čtení nejde vrátit zapisovatelným odkazem. Members of readonly field '{0}' cannot be returned by writable reference Členy pole jen pro čtení {0} nejde vrátit zapisovatelným odkazem. Fields of static readonly field '{0}' cannot be returned by writable reference Pole statického pole jen pro čtení {0} nejdou vrátit zapisovatelným odkazem. Cannot return a parameter by reference '{0}' because it is not a ref or out parameter Parametr nejde vrátit pomocí odkazu {0}, protože nejde o parametr Ref nebo Out. Cannot return by reference a member of parameter '{0}' because it is not a ref or out parameter Člen parametru {0} nejde vrátit pomocí odkazu, protože nejde o parametr ref nebo out. Cannot return local '{0}' by reference because it is not a ref local Lokální proměnnou {0} nejde vrátit pomocí odkazu, protože nejde o lokální proměnnou podle odkazu. Cannot return a member of local '{0}' by reference because it is not a ref local Člen lokální proměnné {0} nejde vrátit pomocí odkazu, protože nejde o lokální proměnnou podle odkazu. Struct members cannot return 'this' or other instance members by reference Členy struktury nemůžou vracet this nebo jiné členy instance pomocí odkazu. Expression cannot be used in this context because it may indirectly expose variables outside of their declaration scope V tomto kontextu nejde výraz použít, protože může nepřímo vystavit proměnné mimo jejich rozsah deklarace. Cannot use local '{0}' in this context because it may expose referenced variables outside of their declaration scope V tomto kontextu nejde použít místní {0}, protože může vystavit odkazované proměnné mimo jejich rozsah deklarace. Cannot use a result of '{0}' in this context because it may expose variables referenced by parameter '{1}' outside of their declaration scope V tomto kontextu nejde použít výsledek z {0}, protože může vystavit proměnné, na které odkazuje parametr {1}, mimo jejich rozsah deklarace. 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 V tomto kontextu nejde použít člena výsledku z {0}, protože může vystavit proměnné, na které odkazuje parametr {1}, mimo jejich rozsah deklarace. This combination of arguments to '{0}' is disallowed because it may expose variables referenced by parameter '{1}' outside of their declaration scope Tato kombinace argumentů pro {0} je zakázaná, protože může vystavit proměnné, na které odkazuje parametr {1}, mimo jejich rozsah deklarace. Branches of a ref conditional operator cannot refer to variables with incompatible declaration scopes Větve podmíněného operátoru REF nemůžou odkazovat na proměnné s nekompatibilními obory deklarace. 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 Výsledek výrazu stackalloc typu {0} nejde v tomto kontextu použít, protože může být vystavený mimo obsahující metodu. Cannot initialize a by-value variable with a reference Proměnnou podle hodnoty nejde inicializovat odkazem. Cannot initialize a by-reference variable with a value Proměnnou podle odkazu nejde inicializovat hodnotou. The expression must be of type '{0}' because it is being assigned by reference Výraz musí být typu {0}, protože se přiřazuje pomocí odkazu. A declaration of a by-reference variable must have an initializer Deklarace proměnné podle odkazu musí mít inicializátor. Cannot use ref local '{0}' inside an anonymous method, lambda expression, or query expression Místní hodnotu odkazu {0} nejde použít uvnitř anonymní metody, výrazu lambda nebo výrazu dotazu. Iterators cannot have by-reference locals Iterátory nemůžou mít lokální proměnné podle odkazu. Async methods cannot have by-reference locals Asynchronní metody nemůžou mít lokální proměnné podle odkazu. 'await' cannot be used in an expression containing a call to '{0}' because it returns by reference 'Argument await nejde použít ve výrazu obsahujícím volání do {0}, protože se vrací pomocí odkazu. 'await' cannot be used in an expression containing a ref conditional operator 'Await nejde použít ve výrazu, který obsahuje podmíněný operátor REF. Both conditional operator values must be ref values or neither may be a ref value Obě hodnoty podmíněného operátoru musí být hodnoty ref nebo ani jedna z nich nesmí být hodnota ref. The expression must be of type '{0}' to match the alternative ref value Výraz musí být typu {0}, aby odpovídal alternativní hodnotě ref. An expression tree may not contain a reference to a local function Strom výrazů nesmí obsahovat odkaz na místní funkci. Cannot pass argument with dynamic type to params parameter '{0}' of local function '{1}'. Nejde předat argument dynamického typu s parametrem params {0} místní funkce {1}. Syntax tree should be created from a submission. Strom syntaxe by se měl vytvořit z odeslání. Combined length of user strings used by the program exceeds allowed limit. Try to decrease use of string literals. Kombinovaná délka uživatelských řetězců, které používá tento program, překročila povolený limit. Zkuste omezit použití řetězcových literálů. 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}. Při zápisu výstupního souboru došlo k chybě: {0}. Tuple element names must be unique. Názvy elementů řazené kolekce členů musí být jedinečné. Tuple element name '{0}' is only allowed at position {1}. Název elementu řazené kolekce členů {0} je povolený jenom v pozici {1}. Tuple element name '{0}' is disallowed at any position. Název elementu řazené kolekce členů {0} je zakázaný v jakékoliv pozici. Member '{0}' was not found on type '{1}' from assembly '{2}'. Nenašel se člen {0} v typu {1} ze sestavení {2}. tuples řazené kolekce členů No suitable 'Deconstruct' instance or extension method was found for type '{0}', with {1} out parameters and a void return type. Pro typ {0} s výstupními parametry ({1}) a návratovým typem void se nenašla žádná vhodná instance Deconstruct nebo rozšiřující metoda. Deconstruct assignment requires an expression with a type on the right-hand-side. Dekonstrukční přiřazení vyžaduje výraz s typem na pravé straně. The switch expression must be a value; found '{0}'. Výraz switch musí být hodnota. Bylo nalezeno: {0}. An expression of type '{0}' cannot be handled by a pattern of type '{1}'. Výraz typu {0} nelze zpracovat vzorem typu {1}. Attribute '{0}' is ignored when public signing is specified. Atribut {0} se ignoruje, když je zadané veřejné podepisování. Attribute is ignored when public signing is specified. Atribut se ignoruje, když je zadané veřejné podepisování. Option '{0}' must be an absolute path. Možnost {0} musí být absolutní cesta. Tuple with {0} elements cannot be converted to type '{1}'. Řazená kolekce členů s {0} elementy se nedá převést na typ {1}. out variable declaration deklarace externí proměnné Reference to an implicitly-typed out variable '{0}' is not permitted in the same argument list. Odkaz na implicitně typovanou externí proměnnou {0} není povolený ve stejném seznamu argumentů. Cannot infer the type of implicitly-typed out variable '{0}'. Nejde odvodit typ implicitně typované externí proměnné {0}. Cannot infer the type of implicitly-typed deconstruction variable '{0}'. Nejde odvodit typ dekonstrukční proměnné {0} s implicitním typem. Cannot infer the type of implicitly-typed discard. Nejde odvodit typ zahození s implicitním typem. Cannot deconstruct a tuple of '{0}' elements into '{1}' variables. Řazenou kolekci členů s {0} prvky nejde dekonstruovat na proměnné {1}. Cannot deconstruct dynamic objects. Dynamické objekty nejde dekonstruovat. Deconstruction must contain at least two variables. Dekonstrukce musí obsahovat aspoň dvě proměnné. The tuple element name '{0}' is ignored because a different name or no name is specified by the target type '{1}'. Název elementu řazené kolekce členů {0} se ignoruje, protože cílovým typem {1} je určený jiný nebo žádný název. The tuple element name is ignored because a different name or no name is specified by the assignment target. Název elementu řazené kolekce členů se ignoruje, protože cílem přiřazení je určený jiný nebo žádný název. Predefined type '{0}' must be a struct. Předdefinovaný typ {0} musí být struktura. 'new' cannot be used with tuple type. Use a tuple literal expression instead. 'new není možné použít s typem řazené kolekce členů. Použijte raději literálový výraz řazené kolekce členů. Deconstruction 'var (...)' form disallows a specific type for 'var'. Forma dekonstrukce var (...) neumožňuje použít pro var konkrétní typ. Cannot define a class or member that utilizes tuples because the compiler required type '{0}' cannot be found. Are you missing a reference? Nejde definovat třídu nebo člen, který používá řazenou kolekci členů, protože se nenašel kompilátor požadovaný typem {0}. Chybí vám odkaz? Cannot reference 'System.Runtime.CompilerServices.TupleElementNamesAttribute' explicitly. Use the tuple syntax to define tuple names. System.Runtime.CompilerServices.TupleElementNamesAttribute nejde odkazovat explicitně. K definici názvů řazené kolekce členů použijte její syntaxi. An expression tree may not contain an out argument variable declaration. Strom výrazů nesmí obsahovat deklaraci proměnné argumentu out. An expression tree may not contain a discard. Strom výrazů nesmí obsahovat zahození. An expression tree may not contain an 'is' pattern-matching operator. Strom výrazů nesmí obsahovat operátor odpovídající vzoru is. An expression tree may not contain a tuple literal. Strom výrazů nesmí obsahovat literál řazené kolekce členů. An expression tree may not contain a tuple conversion. Strom výrazů nesmí obsahovat převod řazené kolekce členů. /sourcelink switch is only supported when emitting PDB. Přepínač /sourcelink je podporovaný jen při vydávání PDB. /embed switch is only supported when emitting a PDB. Přepínač /embed je podporovaný jen při vydávání souboru PDB. Invalid instrumentation kind: {0} Neplatný typ instrumentace: {0} The syntax 'var (...)' as an lvalue is reserved. Syntaxe 'var (...)' jako l-hodnota je vyhrazená. { or ; or => expected Očekávaly se znaky { nebo ; nebo =>. A throw expression is not allowed in this context. Výraz throw není v tomto kontextu povolený. A deconstruction cannot mix declarations and expressions on the left-hand-side. Při dekonstrukci nejde na levé straně kombinovat deklarace a výrazy. A declaration is not allowed in this context. Deklarace není v tomto kontextu povolená. A foreach loop must declare its iteration variables. Smyčka foreach musí deklarovat své proměnné iterace. Tuple element names are not permitted on the left of a deconstruction. Na levé straně dekonstrukce nejsou povolené názvy prvků řazené kolekce členů. To cast a negative value, you must enclose the value in parentheses. Pokud se má přetypovat záporná hodnota, musí být uzavřená v závorkách. An expression tree may not contain a throw-expression. Strom výrazů nesmí obsahovat výraz throw. Invalid assembly name: {0} Neplatný název sestavení: {0} For type '{0}' to be used as an AsyncMethodBuilder for type '{1}', its Task property should return type '{1}' instead of type '{2}'. Aby se typ {0} mohl použít jako AsyncMethodBuilder pro typ {1}, měla by jeho vlastnost Task vracet typ {1} místo typu {2}. Attributes are not allowed on local function parameters or type parameters V parametrech místní funkce nebo v parametrech typu se atributy nepovolují. Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'. Modul {0} v sestavení {1} předává typ {2} několika sestavením: {3} a {4}. It is not legal to use the type 'dynamic' in a pattern. Není povoleno použít typ dynamic ve vzorku. Provided documentation mode is unsupported or invalid: '{0}'. Zadaný režim dokumentace je nepodporovaný nebo neplatný: {0}. Provided source code kind is unsupported or invalid: '{0}' Zadaný druh zdrojového kódu je nepodporovaný nebo neplatný: {0}. Provided language version is unsupported or invalid: '{0}'. Zadaná verze jazyka je nepodporovaná nebo neplatná: {0}. Invalid name for a preprocessing symbol; '{0}' is not a valid identifier Neplatný název pro symbol předzpracování; {0} není platný identifikátor. Feature '{0}' is not available in C# 7.1. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 7.1. Použijte prosím jazyk verze {1} nebo vyšší. Feature '{0}' is not available in C# 7.2. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 7.2. Použijte prosím jazyk verze {1} nebo vyšší. Specified language version '{0}' cannot have leading zeroes Zadaná verze jazyka {0} nemůže obsahovat úvodní nuly. A value of type 'void' may not be assigned. Hodnota typu void se nesmí přiřazovat. '{0}' is for evaluation purposes only and is subject to change or removal in future updates. '{0} slouží jen pro účely vyhodnocení a v budoucích aktualizacích může dojít ke změně nebo odebrání. Type is for evaluation purposes only and is subject to change or removal in future updates. Typ slouží jen pro účely vyhodnocení a v budoucích aktualizacích může dojít ke změnám nebo odebrání. Compiler version: '{0}'. Language version: {1}. Verze kompilátoru: {0}. Jazyková verze: {1} async main Asynchronní funkce main Tuple element name '{0}' is inferred. Please use language version {1} or greater to access an element by its inferred name. Název elementu řazené kolekce členů {0} je odvozený. Pokud k elementu chcete získat přístup pomocí jeho odvozeného názvu, použijte prosím jazyk verze {1} nebo vyšší. A tuple may not contain a value of type 'void'. Řazená kolekce členů nemůže obsahovat hodnotu typu void. A void or int returning entry point cannot be async Vstupní bod, který vrací void nebo int, nemůže být asynchronní. An expression of type '{0}' cannot be handled by a pattern of type '{1}' in C# {2}. Please use language version {3} or greater. V C# {2} nelze výraz typu {0} zpracovat vzorem typu {1}. Použijte prosím jazyk verze {3} nebo vyšší. The local function '{0}' is declared but never used Lokální funkce {0} je deklarovaná, ale vůbec se nepoužívá. Local function is declared but never used Lokální funkce je deklarovaná, ale vůbec se nepoužívá. Local function '{0}' must declare a body because it is not marked 'static extern'. '{0} je lokální funkce a musí proto vždy obsahovat text. Unable to read debug information of method '{0}' (token 0x{1:X8}) from assembly '{2}' Informace o ladění metody {0} (token 0x{1:X8}) ze sestavení {2} nelze přečíst. {0} is not a valid C# conversion expression Výraz {0} není platným výrazem převodu C#. Cannot pass argument with dynamic type to generic local function '{0}' with inferred type arguments. Obecné lokální funkci {0} s odvozenými argumenty typu nelze předat argument s dynamickým typem. leading digit separator oddělovač úvodní číslice Do not use '{0}'. This is reserved for compiler usage. Nepoužívejte {0}. Je vyhrazený pro použití v kompilátoru. The type name '{0}' is reserved to be used by the compiler. Název typu {0} je vyhrazený pro použití kompilátorem. The first parameter of the 'in' extension method '{0}' must be a concrete (non-generic) value type. Prvním parametrem metody rozšíření in {0} musí být konkrétní (neobecný) typ hodnoty. Instance fields of readonly structs must be readonly. Pole instancí struktur jen pro čtení musí být jen pro čtení. Auto-implemented instance properties in readonly structs must be readonly. Vlastnosti automaticky implementované instance ve strukturách jen pro čtení musí být jen pro čtení. Field-like events are not allowed in readonly structs. Události podobné poli nejsou povolené ve strukturách jen pro čtení. ref extension methods rozšiřující metody REF Conversion of a stackalloc expression of type '{0}' to type '{1}' is not possible. Převod výrazu stackalloc typu {0} na typ {1} není možný. The first parameter of a 'ref' extension method '{0}' must be a value type or a generic type constrained to struct. První parametr rozšiřující metody ref {0} musí být typem hodnoty nebo obecným typem omezeným na strukturu. An in parameter cannot have the Out attribute. Parametr in nemůže obsahovat atribut Out. {0} is not a valid C# compound assignment operation {0} není platná operace složeného přiřazení jazyka C#. Filter expression is a constant 'false', consider removing the catch clause Výraz filtru je konstantní hodnota false. Zvažte odebrání klauzule catch. Filter expression is a constant 'false' Výraz filtru je konstantní hodnota false. Filter expression is a constant 'false', consider removing the try-catch block Výraz filtru je konstantní hodnota false. Zvažte odebrání bloku try-catch. Filter expression is a constant 'false'. Výraz filtru je konstantní hodnota false. __arglist cannot have an argument of void type __arglist nemůže mít argument typu void. A conditional expression cannot be used directly in a string interpolation because the ':' ends the interpolation. Parenthesize the conditional expression. Podmíněný výraz se nedá použít přímo v interpolaci řetězce, protože na konci interpolace je dvojtečka. Dejte podmíněný výraz do závorek. Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute on a property Nepoužívejte u vlastnosti atribut System.Runtime.CompilerServices.FixedBuffer. Feature '{0}' is not available in C# 7.3. Please use language version {1} or greater. Funkce {0} není dostupná v jazyce C# 7.3. Použijte prosím jazyk verze {1} nebo vyšší. Field-targeted attributes on auto-properties are not supported in language version {0}. Please use language version {1} or greater. Atributy cílící na pole se u automatických vlastností v jazyku verze {0} nepodporují. Použijte prosím jazyk verze {1} nebo vyšší. Field-targeted attributes on auto-properties are not supported in this version of the language. Atributy cílící na pole se u automatických vlastností v této verzi jazyka nepodporují. async streams asynchronní streamy '{0}': type used in an asynchronous using statement must be implicitly convertible to 'System.IAsyncDisposable' or implement a suitable 'DisposeAsync' method. {0}: typ použitý v asynchronním příkazu using musí být implicitně převoditelný na System.IAsyncDisposable nebo musí implementovat odpovídající metodu DisposeAsync. Asynchronous foreach requires that the return type '{0}' of '{1}' must have a suitable public 'MoveNextAsync' method and public 'Current' property Asynchronní příkaz foreach vyžaduje, aby návratový typ {0} pro {1} měl vhodnou veřejnou metodu MoveNextAsync a veřejnou vlastnost Current. Asynchronous foreach statement cannot operate on variables of type '{0}' because it implements multiple instantiations of '{1}'; try casting to a specific interface instantiation Asynchronní příkaz foreach nejde použít pro proměnné typu {0}, protože implementuje vytváření víc instancí {1}. Zkuste přetypování na konkrétní instanci rozhraní. Interfaces cannot contain conversion, equality, or inequality operators Rozhraní nemůžou obsahovat operátory převodu, rovnosti nebo nerovnosti. Target runtime doesn't support default interface implementation. Cílový modul runtime nepodporuje implementaci výchozího rozhraní. '{0}' cannot implement interface member '{1}' in type '{2}' because the target runtime doesn't support default interface implementation. {0} nemůže implementovat člen rozhraní {1} v typu {2}, protože cílový modul runtime nepodporuje implementaci výchozího rozhraní. The modifier '{0}' is not valid for this item in C# {1}. Please use language version '{2}' or greater. Modifikátor {0} není platný pro tuto položku v jazyce C# {1}. Použijte prosím verzi jazyka {2} nebo vyšší. '{0}' does not implement interface member '{1}'. '{2}' cannot implicitly implement a non-public member. {0} neimplementuje člen rozhraní {1}. {2} nemůže implicitně implementovat neveřejný člen rozhraní. Interface member '{0}' does not have a most specific implementation. Neither '{1}', nor '{2}' are most specific. Člen rozhraní {0} nemá nejvíce specifickou implementaci. {1} ani {2} nejsou nejvíce specifické. '{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} nemůže implementovat člen rozhraní {1} v typu {2}, protože funkce {3} není v jazyce C# {4} k dispozici. Použijte prosím verzi jazyka {5} nebo vyšší.