text/microsoft-resx
2.0
System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
<null>
<throw expression>
(Location of symbol related to previous error)
(Location of symbol related to previous warning)
<!-- Badly formed XML comment ignored for member "{0}" -->
Badly formed XML file "{0}" cannot be included
Failed to insert some or all of included XML
Include tag is invalid
No matching elements were found for the following include tag
Missing file attribute
Missing path attribute
<global namespace>
generics
anonymous methods
module as an attribute target specifier
namespace alias qualifier
fixed size buffers
#pragma
static classes
readonly structs
partial types
async function
switch on boolean type
method group
anonymous method
lambda expression
collection
access modifiers on properties
extern alias
iterators
default operator
default literal
private protected
nullable types
pattern matching
expression body property accessor
expression body constructor and destructor
throw expression
implicitly typed array
implicitly typed local variable
anonymous types
automatically implemented properties
readonly automatically implemented properties
object initializer
collection initializer
query expression
extension method
partial method
method
type
namespace
field
property
element
variable
label
event
type parameter
using alias
extern alias
constructor
foreach iteration variable
fixed variable
using variable
contravariant
contravariantly
covariant
covariantly
invariantly
dynamic
named argument
optional parameter
exception filter
type variance
The character(s) '{0}' cannot be used at this location.
Incorrect syntax was used in a comment.
An invalid character was found inside an entity reference.
Expected '>' or '/>' to close tag '{0}'.
An identifier was expected.
Invalid unicode character.
Whitespace is not allowed at this location.
The character '<' cannot be used in an attribute value.
Missing equals sign between attribute and attribute value.
Reference to undefined entity '{0}'.
A string literal was expected, but no opening quotation mark was found.
Missing closing quotation mark for string literal.
Non-ASCII quotations marks may not be used around string literals.
End tag was not expected at this location.
End tag '{0}' does not match the start tag '{1}'.
Expected an end tag for element '{0}'.
Required white space was missing.
Unexpected character at this location.
The literal string ']]>' is not allowed in element content.
Duplicate '{0}' attribute
Metadata file '{0}' could not be found
Metadata references are not supported.
Metadata file '{0}' could not be opened -- {1}
The type '{0}' is defined in an assembly that is not referenced. You must add a reference to assembly '{1}'.
The type '{0}' is defined in a module that has not been added. You must add the module '{1}'.
Could not write to output file '{0}' -- '{1}'
Program has more than one entry point defined. Compile with /main to specify the type that contains the entry point.
Operator '{0}' cannot be applied to operands of type '{1}' and '{2}'
Division by constant zero
Cannot apply indexing with [] to an expression of type '{0}'
Wrong number of indices inside []; expected {0}
Operator '{0}' cannot be applied to operand of type '{1}'
Operator '{0}' cannot be applied to operand '{1}'
Keyword 'this' is not valid in a static property, static method, or static field initializer
Keyword 'this' is not available in the current context
'{0}' has the wrong signature to be an entry point
Method has the wrong signature to be an entry point
Cannot implicitly convert type '{0}' to '{1}'
Cannot convert type '{0}' to '{1}'
Constant value '{0}' cannot be converted to a '{1}'
Operator '{0}' is ambiguous on operands of type '{1}' and '{2}'
Operator '{0}' is ambiguous on operands 'default' and 'default'
Operator '{0}' is ambiguous on an operand of type '{1}'
An out parameter cannot have the In attribute
Cannot convert null to '{0}' because it is a non-nullable value type
Cannot convert type '{0}' to '{1}' via a reference conversion, boxing conversion, unboxing conversion, wrapping conversion, or null type conversion
Unexpected error writing debug information -- '{0}'
Inconsistent accessibility: return type '{1}' is less accessible than method '{0}'
Inconsistent accessibility: parameter type '{1}' is less accessible than method '{0}'
Inconsistent accessibility: field type '{1}' is less accessible than field '{0}'
Inconsistent accessibility: property type '{1}' is less accessible than property '{0}'
Inconsistent accessibility: indexer return type '{1}' is less accessible than indexer '{0}'
Inconsistent accessibility: parameter type '{1}' is less accessible than indexer '{0}'
Inconsistent accessibility: return type '{1}' is less accessible than operator '{0}'
Inconsistent accessibility: parameter type '{1}' is less accessible than operator '{0}'
Inconsistent accessibility: return type '{1}' is less accessible than delegate '{0}'
Inconsistent accessibility: parameter type '{1}' is less accessible than delegate '{0}'
Inconsistent accessibility: base class '{1}' is less accessible than class '{0}'
Inconsistent accessibility: base interface '{1}' is less accessible than interface '{0}'
'{0}': event property must have both add and remove accessors
'{0}': event must be of a delegate type
The event '{0}' is never used
Event is never used
'{0}': event in interface cannot have initializer
An event in an interface cannot have add or remove accessors
The event '{0}' can only appear on the left hand side of += or -= (except when used from within the type '{1}')
An explicit interface implementation of an event must use event accessor syntax
'{0}': cannot override; '{1}' is not an event
An add or remove accessor must have a body
'{0}': abstract event cannot have initializer
The assembly name '{0}' is reserved and cannot be used as a reference in an interactive session
The enumerator name '{0}' is reserved and cannot be used
The as operator must be used with a reference type or nullable type ('{0}' is a non-nullable value type)
The 'l' suffix is easily confused with the digit '1' -- use 'L' for clarity
The 'l' suffix is easily confused with the digit '1'
The event '{0}' can only appear on the left hand side of += or -=
Constraints are not allowed on non-generic declarations
Type parameter declaration must be an identifier not a type
Type '{1}' already reserves a member called '{0}' with the same parameter types
The parameter name '{0}' is a duplicate
The namespace '{1}' already contains a definition for '{0}'
The type '{0}' already contains a definition for '{1}'
The name '{0}' does not exist in the current context
The name '{0}' does not exist in the current context (are you missing a reference to assembly '{1}'?)
'{0}' is an ambiguous reference between '{1}' and '{2}'
The using directive for '{0}' appeared previously in this namespace
Using directive appeared previously in this namespace
The modifier '{0}' is not valid for this item
More than one protection modifier
'{0}' hides inherited member '{1}'. Use the new keyword if hiding was intended.
Member hides inherited member; missing new keyword
A variable was declared with the same name as a variable in a base class. However, the new keyword was not used. This warning informs you that you should use new; the variable is declared as if new had been used in the declaration.
The member '{0}' does not hide an accessible member. The new keyword is not required.
Member does not hide an inherited member; new keyword is not required
The evaluation of the constant value for '{0}' involves a circular definition
Type '{1}' already defines a member called '{0}' with the same parameter types
A static member '{0}' cannot be marked as override, virtual, or abstract
A member '{0}' marked as override cannot be marked as new or virtual
'{0}' hides inherited member '{1}'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.
Member hides inherited member; missing override keyword
'{0}': no suitable method found to override
A namespace cannot directly contain members such as fields or methods
'{0}' does not contain a definition for '{1}'
'{0}' is a {1} but is used like a {2}
'{0}' is a {1}, which is not valid in the given context
An object reference is required for the non-static field, method, or property '{0}'
The call is ambiguous between the following methods or properties: '{0}' and '{1}'
'{0}' is inaccessible due to its protection level
No overload for '{0}' matches delegate '{1}'
An object of a type convertible to '{0}' is required
Since '{0}' returns void, a return keyword must not be followed by an object expression
A local variable or function named '{0}' is already defined in this scope
The left-hand side of an assignment must be a variable, property or indexer
'{0}': a static constructor must be parameterless
The expression being assigned to '{0}' must be constant
'{0}' is of type '{1}'. A const field of a reference type other than string can only be initialized with 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
A 'using namespace' directive can only be applied to namespaces; '{0}' is a type not a namespace. Consider a 'using static' directive instead
A 'using static' directive can only be applied to types; '{0}' is a namespace not a type. Consider a 'using namespace' directive instead
A 'using static' directive cannot be used to declare an alias
No enclosing loop out of which to break or continue
The label '{0}' is a duplicate
The type '{0}' has no constructors defined
Cannot create an instance of the abstract class or interface '{0}'
A const field requires a value to be provided
Circular base class dependency involving '{0}' and '{1}'
The delegate '{0}' does not have a valid constructor
Method name expected
A constant value is expected
A switch expression or case label must be a bool, char, string, integral, enum, or corresponding nullable type in C# 6 and earlier.
A value of an integral type expected
The switch statement contains multiple cases with the label value '{0}'
A goto case is only valid inside a switch statement
The property or indexer '{0}' cannot be used in this context because it lacks the get accessor
The type caught or thrown must be derived from System.Exception
A throw statement with no arguments is not allowed outside of a catch clause
Control cannot leave the body of a finally clause
The label '{0}' shadows another label by the same name in a contained scope
No such label '{0}' within the scope of the goto statement
A previous catch clause already catches all exceptions of this or of a super type ('{0}')
Filter expression is a constant 'true', consider removing the filter
Filter expression is a constant 'true'
'{0}': not all code paths return a value
Unreachable code detected
Unreachable code detected
Control cannot fall through from one case label ('{0}') to another
This label has not been referenced
This label has not been referenced
Use of unassigned local variable '{0}'
The variable '{0}' is declared but never used
Variable is declared but never used
The field '{0}' is never used
Field is never used
Use of possibly unassigned field '{0}'
Use of possibly unassigned auto-implemented property '{0}'
Field '{0}' must be fully assigned before control is returned to the caller
Type of conditional expression cannot be determined because '{0}' and '{1}' implicitly convert to one another
Type of conditional expression cannot be determined because there is no implicit conversion between '{0}' and '{1}'
A base class is required for a 'base' reference
Use of keyword 'base' is not valid in this context
Member '{0}' cannot be accessed with an instance reference; qualify it with a type name instead
The out parameter '{0}' must be assigned to before control leaves the current method
Invalid rank specifier: expected ',' or ']'
'{0}' cannot be extern and declare a body
'{0}' cannot be extern and have a constructor initializer
'{0}' cannot be both extern and abstract
Attribute constructor parameter '{0}' has type '{1}', which is not a valid attribute parameter type
An attribute argument must be a constant expression, typeof expression or array creation expression of an attribute parameter type
Attribute constructor parameter '{0}' is optional, but no default parameter value was specified.
The given expression is always of the provided ('{0}') type
'is' expression's given expression is always of the provided type
The given expression is never of the provided ('{0}') type
'is' expression's given expression is never of the provided type
'{0}' is not a reference type as required by the lock statement
Use of null is not valid in this context
Use of default literal is not valid in this context
The 'this' object cannot be used before all of its fields are assigned to
The __arglist construct is valid only within a variable argument method
The * or -> operator must be applied to a pointer
A pointer must be indexed by only one value
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
Using a field of a marshal-by-reference class as a ref or out value or taking its address may cause a runtime exception
A static readonly field cannot be assigned to (except in a static constructor or a variable initializer)
A static readonly field cannot be used as a ref or out value (except in a static constructor)
Property or indexer '{0}' cannot be assigned to -- it is read only
Only assignment, call, increment, decrement, and new object expressions can be used as a statement
foreach requires that the return type '{0}' of '{1}' must have a suitable public MoveNext method and public Current property
Only 65534 locals, including those generated by the compiler, are allowed
Cannot call an abstract base member: '{0}'
A property or indexer may not be passed as an out or ref parameter
Cannot take the address of, get the size of, or declare a pointer to a managed type ('{0}')
The type of a local declared in a fixed statement must be a pointer type
You must provide an initializer in a fixed or using statement declaration
Cannot take the address of the given expression
You can only take the address of an unfixed expression inside of a fixed statement initializer
You cannot use the fixed statement to take the address of an already fixed expression
Pointers and fixed size buffers may only be used in an unsafe context
The return type of operator True or False must be bool
The operator '{0}' requires a matching operator '{1}' to also be defined
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
In order for '{0}' to be applicable as a short circuit operator, its declaring type '{1}' must define operator true and operator false
The variable '{0}' is assigned but its value is never used
Variable is assigned but its value is never used
The operation overflows at compile time in checked mode
Constant value '{0}' cannot be converted to a '{1}' (use 'unchecked' syntax to override)
A method with vararg cannot be generic, be in a generic type, or have a params parameter
The params parameter must be a single dimensional array
An __arglist expression may only appear inside of a call or new expression
Unsafe code may only appear if compiling with /unsafe
Ambiguity between '{0}' and '{1}'
Type and identifier are both required in a foreach statement
A params parameter must be the last parameter in a formal parameter list
'{0}' does not have a predefined size, therefore sizeof can only be used in an unsafe context (consider using System.Runtime.InteropServices.Marshal.SizeOf)
The type or namespace name '{0}' does not exist in the namespace '{1}' (are you missing an assembly reference?)
A field initializer cannot reference the non-static field, method, or property '{0}'
'{0}' cannot be sealed because it is not an override
'{0}': cannot override inherited member '{1}' because it is sealed
The operation in question is undefined on void pointers
The Conditional attribute is not valid on '{0}' because it is an override method
Neither 'is' nor 'as' is valid on pointer types
Destructors and object.Finalize cannot be called directly. Consider calling IDisposable.Dispose if available.
The type or namespace name '{0}' could not be found (are you missing a using directive or an assembly reference?)
Cannot use a negative size with stackalloc
Cannot create an array with a negative size
Do not override object.Finalize. Instead, provide a destructor.
Do not directly call your base class Finalize method. It is called automatically from your destructor.
Indexing an array with a negative index (array indices always start at zero)
Indexing an array with a negative index
Possible unintended reference comparison; to get a value comparison, cast the left hand side to type '{0}'
Possible unintended reference comparison; left hand side needs cast
Possible unintended reference comparison; to get a value comparison, cast the right hand side to type '{0}'
Possible unintended reference comparison; right hand side needs cast
The right hand side of a fixed statement assignment may not be a cast expression
stackalloc may not be used in a catch or finally block
An __arglist parameter must be the last parameter in a formal parameter list
Missing partial modifier on declaration of type '{0}'; another partial declaration of this type exists
Partial declarations of '{0}' must be all classes, all structs, or all interfaces
Partial declarations of '{0}' have conflicting accessibility modifiers
Partial declarations of '{0}' must not specify different base classes
Partial declarations of '{0}' must have the same type parameter names in the same order
Partial declarations of '{0}' have inconsistent constraints for type parameter '{1}'
Cannot implicitly convert type '{0}' to '{1}'. An explicit conversion exists (are you missing a cast?)
The 'partial' modifier can only appear immediately before 'class', 'struct', 'interface', or 'void'
Imported type '{0}' is invalid. It contains a circular base class dependency.
Use of unassigned out parameter '{0}'
Array size cannot be specified in a variable declaration (try initializing with a 'new' expression)
The property or indexer '{0}' cannot be used in this context because the get accessor is inaccessible
The property or indexer '{0}' cannot be used in this context because the set accessor is inaccessible
The accessibility modifier of the '{0}' accessor must be more restrictive than the property or indexer '{1}'
Cannot specify accessibility modifiers for both accessors of the property or indexer '{0}'
'{0}': accessibility modifiers may not be used on accessors in an interface
'{0}': accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor
'{0}' does not implement interface member '{1}'. '{2}' is not public.
'{0}' does not implement the '{1}' pattern. '{2}' is ambiguous with '{3}'.
Type does not implement the collection pattern; members are ambiguous
'{0}' does not implement the '{1}' pattern. '{2}' is either static or not public.
Type does not implement the collection pattern; member is either static or not public
'{0}' does not implement the '{1}' pattern. '{2}' has the wrong signature.
Type does not implement the collection pattern; member has the wrong signature
Friend access was granted by '{0}', but the public key of the output assembly does not match that specified by the attribute in the granting assembly.
Friend access was granted by '{0}', but the strong name signing state of the output assembly does not match that of the granting assembly.
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.
There is no defined ordering between fields in multiple declarations of partial struct
The type '{0}' cannot be declared const
Cannot create an instance of the variable type '{0}' because it does not have the new() constraint
Using the generic {1} '{0}' requires {2} type arguments
The type '{0}' may not be used as a type argument
The {1} '{0}' cannot be used with type arguments
The non-generic {1} '{0}' cannot be used with type arguments
'{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}'
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}'.
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}'.
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.
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}'.
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}'.
The parameter name '{0}' conflicts with an automatically-generated parameter name
The type or namespace name '{0}' could not be found in the global namespace (are you missing an assembly reference?)
The new() constraint must be the last constraint specified
'{0}': an entry point cannot be generic or in a generic type
An entry point cannot be generic or in a generic type
Cannot convert null to type parameter '{0}' because it could be a non-nullable value type. Consider using 'default({0})' instead.
Cannot apply attribute class '{0}' because it is generic
Duplicate constraint '{0}' for type parameter '{1}'
The class type constraint '{0}' must come before any other constraints
'{1} {0}' has the wrong return type
Ref mismatch between '{0}' and delegate '{1}'
A constraint clause has already been specified for type parameter '{0}'. All of the constraints for a type parameter must be specified in a single where clause.
The type arguments for method '{0}' cannot be inferred from the usage. Try specifying the type arguments explicitly.
'{0}': a parameter, local variable, or local function cannot have the same name as a method type parameter
The type parameter '{0}' cannot be used with the 'as' operator because it does not have a class type constraint nor a 'class' constraint
The field '{0}' is assigned but its value is never used
Field is assigned but its value is never used
The '{0}' attribute is valid only on an indexer that is not an explicit interface member declaration
'{0}': an attribute argument cannot use type parameters
'{0}': cannot provide arguments when creating an instance of a variable type
'{0}': an abstract class cannot be sealed or static
Ambiguous reference in cref attribute: '{0}'. Assuming '{1}', but could have also matched other overloads including '{2}'.
Ambiguous reference in cref attribute
'{0}': a reference to a volatile field will not be treated as volatile
A reference to a volatile field will not be treated as 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.
Since '{1}' has the ComImport attribute, '{0}' must be extern or abstract
'{0}': a class with the ComImport attribute cannot specify a base class
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.
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).
The type name '{0}' does not exist in the type '{1}'
Cannot convert method group '{0}' to non-delegate type '{1}'. Did you intend to invoke the method?
The extern alias '{0}' was not specified in a /reference option
Cannot use alias '{0}' with '::' since the alias references a type. Use '.' instead.
Alias '{0}' not found
The type '{1}' exists in both '{0}' and '{2}'
The namespace '{1}' in '{0}' conflicts with the type '{3}' in '{2}'
The namespace '{1}' in '{0}' conflicts with the imported type '{3}' in '{2}'. Using the namespace defined in '{0}'.
Namespace conflicts with imported type
The type '{1}' in '{0}' conflicts with the imported type '{3}' in '{2}'. Using the type defined in '{0}'.
Type conflicts with imported type
The type '{1}' in '{0}' conflicts with the imported namespace '{3}' in '{2}'. Using the type defined in '{0}'.
Type conflicts with imported namespace
The type '{1}' in '{0}' conflicts with the namespace '{3}' in '{2}'
An extern alias declaration must precede all other elements defined in the namespace
Defining an alias named 'global' is ill-advised since 'global::' always references the global namespace and not an alias
Defining an alias named 'global' is ill-advised
'{0}': a class cannot be both static and sealed
'{0}': abstract properties cannot have private accessors
Syntax error; value expected
Cannot modify the result of an unboxing conversion
Foreach cannot operate on a '{0}'. Did you intend to invoke the '{0}'?
The return type for ++ or -- operator must match the parameter type or be derived from the parameter type
The 'class' or 'struct' constraint must come before any other constraints
'{0}': cannot specify both a constraint class and the 'class' or 'struct' constraint
The 'new()' constraint cannot be used with the 'struct' constraint
The type '{2}' must be a reference type in order to use it as parameter '{1}' in the generic type or method '{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}'
Circular constraint dependency involving '{0}' and '{1}'
Type parameter '{0}' inherits conflicting constraints '{1}' and '{2}'
Type parameter '{1}' has the 'struct' constraint so '{1}' cannot be used as a constraint for '{0}'
Ambiguous user defined conversions '{0}' and '{1}' when converting from '{2}' to '{3}'
The result of the expression is always 'null' of type '{0}'
The result of the expression is always 'null'
Cannot return 'this' by reference.
Cannot use attribute constructor '{0}' because it is has 'in' parameters.
Constraints for override and explicit interface implementation methods are inherited from the base method, so they cannot be specified directly
The inherited members '{0}' and '{1}' have the same signature in type '{2}', so they cannot be overridden
Evaluation of the decimal constant expression failed
Comparing with null of type '{0}' always produces 'false'
Comparing with null of struct type always produces 'false'
Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor?
Introducing a 'Finalize' method can interfere with destructor invocation
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.
'{0}' should not have a params parameter since '{1}' does not
The 'goto case' value is not implicitly convertible to type '{0}'
The 'goto case' value is not implicitly convertible to the switch type
Method '{0}' cannot implement interface accessor '{1}' for type '{2}'. Use an explicit interface implementation.
The result of the expression is always '{0}' since a value of type '{1}' is never equal to 'null' of type '{2}'
The result of the expression is always the same since a value of this type is never equal to 'null'
The result of the expression is always '{0}' since a value of type '{1}' is never equal to 'null' of type '{2}'
The result of the expression is always the same since a value of this type is never equal to '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.
Explicit interface implementation matches more than one interface member
'{0}' cannot declare a body because it is marked abstract
'{0}' must declare a body because it is not marked abstract, extern, or partial
'{0}' cannot be both abstract and sealed
The abstract {0} '{1}' cannot be marked virtual
The constant '{0}' cannot be marked static
'{0}': cannot override because '{1}' is not a function
'{0}': cannot override inherited member '{1}' because it is not marked virtual, abstract, or override
'{0}': cannot change access modifiers when overriding '{1}' inherited member '{2}'
'{0}': cannot change tuple element names when overriding inherited member '{1}'
'{0}': return type must be '{2}' to match overridden member '{1}'
'{0}': cannot derive from sealed type '{1}'
'{0}' is abstract but it is contained in non-abstract class '{1}'
'{0}': static constructor cannot have an explicit 'this' or 'base' constructor call
'{0}': access modifiers are not allowed on static constructors
Constructor '{0}' cannot call itself
Constructor '{0}' cannot call itself through another constructor
'{0}' has no base class and cannot call a base constructor
Predefined type '{0}' is not defined or imported
Predefined type '{0}' is not defined or imported
Predefined type '{0}' is declared in multiple referenced assemblies: '{1}' and '{2}'
'{0}': structs cannot call base class constructors
Struct member '{0}' of type '{1}' causes a cycle in the struct layout
'{0}': interfaces cannot declare types
Interfaces cannot contain fields
Interfaces cannot contain constructors
Type '{0}' in interface list is not an interface
'{0}' is already listed in interface list
'{0}' is already listed in the interface list on type '{2}' with different tuple element names, as '{1}'.
Inherited interface '{1}' causes a cycle in the interface hierarchy of '{0}'
'{0}': interface members cannot have a definition
'{0}' hides inherited abstract member '{1}'
'{0}' does not implement inherited abstract member '{1}'
'{0}' does not implement interface member '{1}'
The class System.Object cannot have a base class or implement an interface
'{0}' in explicit interface declaration is not an interface
'{0}' in explicit interface declaration is not a member of interface
'{0}': containing type does not implement interface '{1}'
'{0}': explicit interface declaration can only be declared in a class or struct
'{0}': member names cannot be the same as their enclosing type
'{0}': the enumerator value is too large to fit in its type
'{0}': cannot override because '{1}' is not a property
'{0}': cannot override because '{1}' does not have an overridable get accessor
'{0}': cannot override because '{1}' does not have an overridable set accessor
'{0}': property or indexer cannot have void type
'{0}': property or indexer must have at least one accessor
__arglist cannot have an argument of void type
'{0}' is a new virtual member in sealed class '{1}'
'{0}' adds an accessor not found in interface member '{1}'
Explicit interface implementation '{0}' is missing accessor '{1}'
'{0}': user-defined conversions to or from an interface are not allowed
'{0}': user-defined conversions to or from a base class are not allowed
'{0}': user-defined conversions to or from a derived class are not allowed
User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type
User-defined conversion must convert to or from the enclosing type
Duplicate user-defined conversion in type '{0}'
User-defined operator '{0}' must be declared static and public
The parameter type for ++ or -- operator must be the containing type
The parameter of a unary operator must be the containing type
One of the parameters of a binary operator must be the containing type
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
Interfaces cannot contain operators
Structs cannot contain explicit parameterless constructors
Enums cannot contain explicit parameterless constructors
'{0}': cannot override '{1}' because it is not supported by the language
'{0}' is not supported by the language
'{0}': cannot explicitly call operator or accessor
'{0}': cannot reference a type through an expression; try '{1}' instead
'{0}': cannot have instance property or field initializers in structs
Name of destructor must match name of class
Only class types can contain destructors
Namespace '{1}' contains a definition conflicting with alias '{0}'
Alias '{0}' conflicts with {1} definition
The Conditional attribute is not valid on '{0}' because it is a constructor, destructor, operator, or explicit interface implementation
The Conditional attribute is not valid on '{0}' because its return type is not void
Duplicate '{0}' attribute
Duplicate '{0}' attribute in '{1}'
The Conditional attribute is not valid on interface members
User-defined operators cannot return void
'{0}': user-defined conversions to or from the dynamic type are not allowed
Invalid value for argument to '{0}' attribute
Parameter not valid for the specified unmanaged type.
Attribute parameter '{0}' must be specified.
Attribute parameter '{0}' or '{1}' must be specified.
Unmanaged type '{0}' not valid for fields.
Unmanaged type '{0}' is only valid for fields.
Attribute '{0}' is not valid on this declaration type. It is only valid on '{1}' declarations.
Floating-point constant is outside the range of type '{0}'
The Guid attribute must be specified with the ComImport attribute
Invalid value for named attribute argument '{0}'
The DllImport attribute must be specified on a method marked 'static' and 'extern'
Cannot update '{0}'; attribute '{1}' is missing.
The DllImport attribute cannot be applied to a method that is generic or contained in a generic type.
Field or property cannot be of type '{0}'
Field or auto-implemented property cannot be of type '{0}' unless it is an instance member of a ref struct.
Array elements cannot be of type '{0}'
'{0}' is obsolete
Type or member is obsolete
'{0}' is not an attribute class
'{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}' is obsolete: '{1}'
Type or member is obsolete
'{0}' is obsolete: '{1}'
Indexers cannot have void type
'{0}': virtual or abstract members cannot be private
Can only use array initializer expressions to assign to array types. Try using a new expression instead.
Array initializers can only be used in a variable or field initializer. Try using a new expression instead.
'{0}': instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute
Method, operator, or accessor '{0}' is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation.
Method, operator, or accessor is marked external and has no attributes on it
'{0}': new protected member declared in sealed class
New protected member declared in sealed class
Conditional member '{0}' cannot implement interface member '{1}' in type '{2}'
'{0}' cannot implement interface member '{1}' in type '{2}' because it has an __arglist parameter
ref and out are not valid in this context
The argument to the '{0}' attribute must be a valid identifier
The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit)
The FieldOffset attribute is not allowed on static or const fields
Attribute '{0}' is only valid on classes derived from System.Attribute
Possible mistaken empty statement
Possible mistaken empty statement
'{0}' duplicate named attribute argument
'{0}' cannot derive from special class '{1}'
Cannot specify the DefaultMember attribute on a type containing an indexer
'{0}' is a type not supported by the language
Field '{0}' is never assigned to, and will always have its default value {1}
Field is never assigned to, and will always have its default value
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.
Comparison to integral constant is useless; the constant is outside the range of type '{0}'
Comparison to integral constant is useless; the constant is outside the range of the type
Cannot apply attribute class '{0}' because it is abstract
'{0}' is not a valid named attribute argument because it is not a valid attribute parameter type
Missing compiler required member '{0}.{1}'
'{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.
Not a valid attribute location for this declaration
'{0}' is not a recognized attribute location. Valid attribute locations for this declaration are '{1}'. All attributes in this block will be ignored.
Not a recognized attribute location
'{0}' overrides Object.Equals(object o) but does not override Object.GetHashCode()
Type overrides Object.Equals(object o) but does not override Object.GetHashCode()
'{0}' defines operator == or operator != but does not override Object.Equals(object o)
Type defines operator == or operator != but does not override Object.Equals(object o)
'{0}' defines operator == or operator != but does not override Object.GetHashCode()
Type defines operator == or operator != but does not override Object.GetHashCode()
Cannot specify the Out attribute on a ref parameter without also specifying the In attribute.
'{0}' cannot define an overloaded {1} that differs only on parameter modifiers '{2}' and '{3}'
Literal of type double cannot be implicitly converted to type '{1}'; use an '{0}' suffix to create a literal of this type
Assignment in conditional expression is always constant; did you mean to use == instead of = ?
Assignment in conditional expression is always constant
'{0}': new protected member declared in struct
Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type
A class with the ComImport attribute cannot have a user-defined constructor
Field cannot have void type
Member '{0}' overrides obsolete member '{1}'. Add the Obsolete attribute to '{0}'.
Member overrides obsolete member
System.Void cannot be used from C# -- use typeof(void) to get the void type object
Do not use 'System.ParamArrayAttribute'. Use the 'params' keyword instead.
Bitwise-or operator used on a sign-extended operand; consider casting to a smaller unsigned type first
Bitwise-or operator used on a sign-extended operand
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.
'{0}': a volatile field cannot be of the type '{1}'
'{0}': a field cannot be both volatile and readonly
The modifier 'abstract' is not valid on fields. Try using a property instead.
'{0}' cannot implement '{1}' because it is not supported by the language
'{0}' explicit method implementation cannot implement '{1}' because it is an accessor
'{0}' interface marked with 'CoClassAttribute' not marked with 'ComImportAttribute'
Interface marked with 'CoClassAttribute' not marked with 'ComImportAttribute'
Conditional member '{0}' cannot have an out parameter
Accessor '{0}' cannot implement interface member '{1}' for type '{2}'. Use an explicit interface implementation.
The namespace alias qualifier '::' always resolves to a type or namespace so is illegal here. Consider using '.' instead.
Cannot derive from '{0}' because it is a type parameter
Duplicate type parameter '{0}'
Type parameter '{0}' has the same name as the type parameter from outer type '{1}'
Type parameter has the same name as the type parameter from outer type
Type parameter '{0}' has the same name as the containing type, or method
'{0}' cannot implement both '{1}' and '{2}' because they may unify for some type parameter substitutions
A generic type cannot derive from '{0}' because it is an attribute class
'{1}' does not define type parameter '{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.
Constraint cannot be special class '{0}'
Inconsistent accessibility: constraint type '{1}' is less accessible than '{0}'
Cannot do member lookup in '{0}' because it is a type parameter
Invalid constraint type. A type used as a constraint must be an interface, a non-sealed class or a type parameter.
'{0}': cannot declare instance members in a static class
'{1}': cannot derive from static class '{0}'
Static classes cannot have instance constructors
Static classes cannot contain destructors
Cannot create an instance of the static class '{0}'
Static class '{0}' cannot derive from type '{1}'. Static classes must derive from object.
'{0}': static classes cannot implement interfaces
'{0}': ref structs cannot implement interfaces
'{0}': static classes cannot contain user-defined operators
Cannot convert to static type '{0}'
'{0}': static classes cannot be used as constraints
'{0}': static types cannot be used as type arguments
'{0}': array elements cannot be of static type
'{0}': cannot declare indexers in a static class
'{0}': static types cannot be used as parameters
'{0}': static types cannot be used as return types
Cannot declare a variable of static type '{0}'
A throw statement with no arguments is not allowed in a finally clause that is nested inside the nearest enclosing catch clause
'{0}' is not a valid format specifier
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.
Possibly incorrect assignment to local which is the argument to a using or lock statement
Type '{0}' is defined in this assembly, but a type forwarder is specified for it
Cannot forward type '{0}' because it is a nested type of '{1}'
The type forwarder for type '{0}' in assembly '{1}' causes a cycle
The /moduleassemblyname option may only be specified when building a target type of 'module'
Assembly reference '{0}' is invalid and cannot be resolved
Invalid type specified as an argument for TypeForwardedTo attribute
'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is static.
'{0}' does not implement interface member '{1}'. '{2}' cannot implement an interface member because it is not public.
'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}' because it does not have the matching return type of '{3}'.
'{0}' duplicate TypeForwardedToAttribute
A query body must end with a select clause or a group clause
Expected contextual keyword 'on'
Expected contextual keyword 'equals'
Expected contextual keyword 'by'
Invalid anonymous type member declarator. Anonymous type members must be declared with a member assignment, simple name or member access.
Invalid initializer member declarator
Inconsistent lambda parameter usage; parameter types must be all explicit or all implicit
A partial method cannot have access modifiers or the virtual, abstract, override, new, sealed, or extern modifiers
A partial method must be declared within a partial class or partial struct
A partial method cannot have out parameters
A partial method may not explicitly implement an interface method
Both partial method declarations must be extension methods or neither may be an extension method
A partial method may not have multiple defining declarations
A partial method may not have multiple implementing declarations
Both partial method declarations must use a params parameter or neither may use a params parameter
No defining declaration found for implementing declaration of partial method '{0}'
Both partial method declarations, '{0}' and '{1}', must use the same tuple element names.
Partial method declarations of '{0}' have inconsistent type parameter constraints
Cannot create delegate from method '{0}' because it is a partial method without an implementing declaration
Both partial method declarations must be static or neither may be static
Both partial method declarations must be unsafe or neither may be unsafe
Partial methods with only a defining declaration or removed conditional methods cannot be used in expression trees
Partial methods must have a void return type
Obsolete member '{0}' overrides non-obsolete member '{1}'
Obsolete member overrides non-obsolete member
The fully qualified name for '{0}' is too long for debug information. Compile without '/debug' option.
Fully qualified name is too long for debug information
Cannot assign {0} to an implicitly-typed variable
Implicitly-typed variables must be initialized
Implicitly-typed variables cannot have multiple declarators
Cannot initialize an implicitly-typed variable with an array initializer
Implicitly-typed local variables cannot be fixed
Implicitly-typed variables cannot be constant
Constructor '{0}' is marked external
Constructor is marked external
The contextual keyword 'var' may only appear within a local variable declaration or in script code
No best type found for implicitly-typed array
Cannot assign '{0}' to anonymous type property
An expression tree may not contain a base access
An expression tree may not contain an assignment operator
An anonymous type cannot have multiple properties with the same name
A lambda expression with a statement body cannot be converted to an expression tree
Cannot convert lambda to an expression tree whose type argument '{0}' is not a delegate type
Cannot use anonymous type in a constant expression
The first operand of an 'is' or 'as' operator may not be a lambda expression, anonymous method, or method group.
The first operand of an 'as' operator may not be a tuple literal without a natural type.
An expression tree may not contain a multidimensional array initializer
Argument missing
Cannot use local variable '{0}' before it is declared
Type of '{0}' cannot be inferred since its initializer directly or indirectly refers to the definition.
'{0}': Auto-implemented properties cannot be used inside a type marked with StructLayout(LayoutKind.Explicit)
Auto-implemented property '{0}' must be fully assigned before control is returned to the caller.
Cannot use local variable '{0}' before it is declared. The declaration of the local variable hides the field '{1}'.
An expression tree lambda may not contain a coalescing operator with a null or default literal left-hand side
Identifier expected
; expected
Syntax error, '{0}' expected
Duplicate '{0}' modifier
Property accessor already defined
Type byte, sbyte, short, ushort, int, uint, long, or ulong expected
Unrecognized escape sequence
Newline in constant
Empty character literal
Too many characters in character literal
Invalid number
A get or set accessor expected
An object, string, or class type expected
Named attribute argument expected
Catch clauses cannot follow the general catch clause of a try statement
Keyword 'this' or 'base' expected
Overloadable unary operator expected
Overloadable binary operator expected
Integral constant is too large
Type or namespace definition, or end-of-file expected
Member definition, statement, or end-of-file expected
Embedded statement cannot be a declaration or labeled statement
Preprocessor directive expected
Single-line comment or end-of-line expected
) expected
#endif directive expected
Unexpected preprocessor directive
#error: '{0}'
#warning: '{0}'
#warning directive
Type expected
Cannot define/undefine preprocessor symbols after first token in file
Cannot use #r after first token in file
End-of-file found, '*/' expected
Merge conflict marker encountered
Do not use refout when using refonly.
Cannot compile net modules when using /refout or /refonly.
Overloadable operator expected
#endregion directive expected
Unterminated string literal
Preprocessor directives must appear as the first non-whitespace character on a line
Identifier expected; '{1}' is a keyword
{ or ; expected
Cannot use more than one type in a for, using, fixed, or declaration statement
An add or remove accessor expected
Unexpected character '{0}'
Unexpected token '{0}'
'{0}': static classes cannot contain protected members
A previous catch clause already catches all exceptions. All non-exceptions thrown will be wrapped in a System.Runtime.CompilerServices.RuntimeWrappedException.
A previous catch clause already catches all exceptions
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.
The operand of an increment or decrement operator must be a variable, property or indexer
'{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 or an assembly reference?)
'{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}'?)
Method '{0}' has a parameter modifier 'this' which is not on the first parameter
The parameter modifier '{0}' cannot be used with '{1}'
The first parameter of an extension method cannot be of type '{0}'
A parameter array cannot be used with 'this' modifier on an extension method
Extension method must be static
Extension method must be defined in a non-generic static class
A parameter can only have one '{0}' modifier
Extension methods must be defined in a top level static class; {0} is a nested class
Cannot define a new extension method because the compiler required type '{0}' cannot be found. Are you missing a reference to System.Core.dll?
Do not use 'System.Runtime.CompilerServices.ExtensionAttribute'. Use the 'this' keyword instead.
Do not use 'System.Runtime.CompilerServices.DynamicAttribute'. Use the 'dynamic' keyword instead.
The constructor call needs to be dynamically dispatched, but cannot be because it is part of a constructor initializer. Consider casting the dynamic arguments.
Extension method '{0}' defined on value type '{1}' cannot be used to create delegates
No overload for method '{0}' takes {1} arguments
Argument {0}: cannot convert from '{1}' to '{2}'
Source file '{0}' could not be opened -- {1}
Cannot link resource files when building a module
Resource identifier '{0}' has already been used in this assembly
Each linked resource and module must have a unique filename. Filename '{0}' is specified more than once in this assembly
The referenced file '{0}' is not an assembly
A ref or out value must be an assignable variable
Keyword 'base' is not available in a static method
Keyword 'base' is not available in the current context
} expected
{ expected
'in' expected
Invalid preprocessor expression
Invalid token '{0}' in class, struct, or interface member declaration
Method must have a return type
Invalid base type
Empty switch block
Empty switch block
Expected catch or finally
Invalid expression term '{0}'
A new expression requires (), [], or {} after type
Elements defined in a namespace cannot be explicitly declared as private, protected, protected internal, or private protected
Expected ; or = (cannot specify constructor arguments in declaration)
A using clause must precede all other elements defined in the namespace except extern alias declarations
Overloaded binary operator '{0}' takes two parameters
Overloaded unary operator '{0}' takes one parameter
Invalid parameter type 'void'
The using alias '{0}' appeared previously in this namespace
Cannot access protected member '{0}' via a qualifier of type '{1}'; the qualifier must be of type '{2}' (or derived from it)
'{0}' cannot be added to this assembly because it already is an assembly
Property, indexer, or event '{0}' is not supported by the language; try directly calling accessor methods '{1}' or '{2}'
Property, indexer, or event '{0}' is not supported by the language; try directly calling accessor method '{1}'
Keyword 'void' cannot be used in this context
Indexers must have at least one parameter
Array type specifier, [], must appear before parameter name
Declaration is not valid; use '{0} operator <dest-type> (...' instead
Could not find '{0}' specified for Main method
'{0}' specified for Main method must be a valid non-generic class or struct
'{0}' does not have a suitable static Main method
Cannot use '{0}' for Main method because it is imported
Outputs without source must have the /out option specified
Conflicting options specified: Win32 resource file; Win32 manifest
Conflicting options specified: Win32 resource file; Win32 icon
Error reading resource '{0}' -- '{1}'
Error writing to XML documentation file: {0}
XML comment has badly formed XML -- '{0}'
XML comment has badly formed XML
XML comment has a duplicate param tag for '{0}'
XML comment has a duplicate param tag
XML comment has a param tag for '{0}', but there is no parameter by that name
XML comment has a param tag, but there is no parameter by that name
XML comment on '{1}' has a paramref tag for '{0}', but there is no parameter by that name
XML comment has a paramref tag, but there is no parameter by that name
Parameter '{0}' has no matching param tag in the XML comment for '{1}' (but other parameters do)
Parameter has no matching param tag in the XML comment (but other parameters do)
XML comment has cref attribute '{0}' that could not be resolved
XML comment has cref attribute that could not be resolved
A stackalloc expression requires [] after type
The line number specified for #line directive is missing or invalid
Quoted file name, single-line comment or end-of-line expected
Quoted file name expected
#r is only allowed in scripts
foreach statement cannot operate on variables of type '{0}' because '{0}' does not contain a public definition for '{1}'
Invalid type for parameter {0} in XML comment cref attribute: '{1}'
Invalid type for parameter in XML comment cref attribute
Invalid return type in XML comment cref attribute
Invalid return type in XML comment cref attribute
Error reading Win32 resources -- {0}
XML comment has syntactically incorrect cref attribute '{0}'
XML comment has syntactically incorrect cref attribute
Member modifier '{0}' must precede the member type and name
Array creation must have array size or array initializer
XML comment is not placed on a valid language element
XML comment is not placed on a valid language element
Unable to include XML fragment '{1}' of file '{0}' -- {2}
Unable to include XML fragment
Invalid XML include element -- {0}
Invalid XML include element
Missing XML comment for publicly visible type or member '{0}'
Missing XML comment for publicly visible type or member
The /doc compiler option was specified, but one or more constructs did not have comments.
Badly formed XML in included comments file -- '{0}'
Badly formed XML in included comments file
Delegate '{0}' does not take {1} arguments
Semicolon after method or accessor block is not valid
Method or delegate cannot return type '{0}'
Compilation cancelled by user
Cannot make reference to variable of type '{0}'
Cannot assign to '{0}' because it is read-only
Cannot use '{0}' as a ref or out value because it is read-only
The RequiredAttribute attribute is not permitted on C# types
Modifiers cannot be placed on event accessor declarations
The params parameter cannot be declared as {0}
Cannot modify the return value of '{0}' because it is not a variable
The managed coclass wrapper class '{0}' for interface '{1}' cannot be found (are you missing an assembly reference?)
'{0}' is ambiguous between '{1}' and '{2}'; use either '@{0}' or '{0}Attribute'
Argument {0} may not be passed with the '{1}' keyword
Option '{0}' overrides attribute '{1}' given in a source file or added module
Option overrides attribute given in a source file or added module
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.
Invalid option '{0}' for /langversion. Use '/langversion:?' to list supported values.
Cannot create delegate with '{0}' because it or a method it overrides has a Conditional attribute
Cannot create temporary file -- {0}
Argument {0} must be passed with the '{1}' keyword
The yield statement cannot be used inside an anonymous method or lambda expression
Cannot return a value from an iterator. Use the yield return statement to return a value, or yield break to end the iteration.
Iterators cannot have ref or out parameters
The body of '{0}' cannot be an iterator block because '{1}' is not an iterator interface type
Cannot yield in the body of a finally clause
Cannot yield a value in the body of a try block with a catch clause
Expression expected after yield return
Cannot use ref, out, or in parameter '{0}' inside an anonymous method, lambda expression, or query expression
Unsafe code may not appear in iterators
Cannot yield a value in the body of a catch clause
Control cannot leave the body of an anonymous method or lambda expression
Unrecognized #pragma directive
Unrecognized #pragma directive
Expected disable or restore
Expected disable or restore after #pragma warning
Cannot restore warning 'CS{0}' because it was disabled globally
Cannot restore warning because it was disabled globally
__arglist is not allowed in the parameter list of iterators
Iterators cannot have unsafe parameters or yield types
The managed coclass wrapper class signature '{0}' for interface '{1}' is not a valid class name signature
foreach statement cannot operate on variables of type '{0}' because it implements multiple instantiations of '{1}'; try casting to a specific interface instantiation
A fixed size buffer field must have the array size specifier after the field name
Fixed size buffer fields may only be members of structs
Not all code paths return a value in {0} of type '{1}'
Feature '{0}' is not part of the standardized ISO C# language specification, and may not be accepted by other compilers
Feature is not part of the standardized ISO C# language specification, and may not be accepted by other compilers
Keyword, identifier, or string expected after verbatim specifier: @
A readonly field cannot be used as a ref or out value (except in a constructor)
Members of readonly field '{0}' cannot be used as a ref or out value (except in a constructor)
A readonly field cannot be assigned to (except in a constructor or a variable initializer)
Members of readonly field '{0}' cannot be modified (except in a constructor or a variable initializer)
Cannot use {0} '{1}' as a ref or out value because it is a readonly variable
Members of {0} '{1}' cannot be used as a ref or out value because it is a readonly variable
Cannot assign to {0} '{1}' because it is a readonly variable
Cannot assign to a member of {0} '{1}' because it is a readonly variable
Cannot return {0} '{1}' by writable reference because it is a readonly variable
Members of {0} '{1}' cannot be returned by writable reference because it is a readonly variable
Fields of static readonly field '{0}' cannot be assigned to (except in a static constructor or a variable initializer)
Fields of static readonly field '{0}' cannot be used as a ref or out value (except in a static constructor)
Cannot modify members of '{0}' because it is a '{1}'
Cannot use fields of '{0}' as a ref or out value because it is a '{1}'
Cannot assign to '{0}' because it is a '{1}'
Cannot use '{0}' as a ref or out value because it is a '{1}'
{0}. See also error CS{1}.
Warning is overriding an error
The compiler emits this warning when it overrides an error with a warning. For information about the problem, search for the error code mentioned.
Cannot convert {0} to type '{1}' because it is not a delegate type
Cannot convert {0} to delegate type '{1}' because the parameter types do not match the delegate parameter types
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
Since this is an async method, the return expression must be of type '{0}' rather than '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}'.
Fixed size buffer type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double
Fixed size buffer of length {0} and type '{1}' is too big
Fixed size buffers must have a length greater than zero
You cannot use fixed size buffers contained in unfixed expressions. Try using the fixed statement.
Attribute '{0}' is not valid on property or event accessors. It is only valid on '{1}' declarations.
Invalid search path '{0}' specified in '{1}' -- '{2}'
Invalid search path specified
__arglist is not valid in this context
params is not valid in this context
A namespace declaration cannot have modifiers or attributes
Invalid option '{0}' for /platform; must be anycpu, x86, Itanium, arm, arm64 or x64
Anonymous methods, lambda expressions, and query expressions inside structs cannot access instance members of 'this'. Consider copying 'this' to a local variable outside the anonymous method, lambda expression or query expression and using the local instead.
'{0}': type used in a using statement must be implicitly convertible to 'System.IDisposable'
Parameter {0} must be declared with the '{1}' keyword
Parameter {0} should not be declared with the '{1}' keyword
Parameter {0} is declared as type '{1}{2}' but should be '{3}{4}'
Invalid extern alias for '/reference'; '{0}' is not a valid identifier
Invalid reference alias option: '{0}=' -- missing filename
You cannot redefine the global extern alias
Reference to type '{0}' claims it is defined in this assembly, but it is not defined in source or any added modules
Reference to type '{0}' claims it is defined in '{1}', but it could not be found
The predefined type '{0}' is defined in multiple assemblies in the global alias; using definition from '{1}'
Predefined type is defined in multiple assemblies in the global alias
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.
Local '{0}' or its members cannot have their address taken and be used inside an anonymous method or lambda expression
Source file has exceeded the limit of 16,707,565 lines representable in the PDB; debug information will be incorrect
Source file has exceeded the limit of 16,707,565 lines representable in the PDB; debug information will be incorrect
Cannot convert anonymous method block without a parameter list to delegate type '{0}' because it has one or more out parameters
Attribute '{0}' is only valid on methods or attribute classes
Accessing a member on '{0}' may cause a runtime exception because it is a field of a marshal-by-reference class
Accessing a member on a field of a marshal-by-reference class may cause a runtime exception
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.
'{0}' is not a valid warning number
Not a valid warning number
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.
Invalid number
Invalid number
Invalid filename specified for preprocessor directive. Filename is too long or not a valid filename.
Invalid filename specified for preprocessor directive
Invalid #pragma checksum syntax; should be #pragma checksum "filename" "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" "XXXX..."
Invalid #pragma checksum syntax
Single-line comment or end-of-line expected
Single-line comment or end-of-line expected after #pragma directive
Different checksum values given for '{0}'
Different #pragma checksum values given
Assembly reference '{0}' is invalid and cannot be resolved
Assembly reference is invalid and cannot be resolved
This warning indicates that an attribute, such as InternalsVisibleToAttribute, was not specified correctly.
Assuming assembly reference '{0}' used by '{1}' matches identity '{2}' of '{3}', you may need to supply runtime policy
Assuming assembly reference matches identity
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.
Assuming assembly reference '{0}' used by '{1}' matches identity '{2}' of '{3}', you may need to supply runtime policy
Assuming assembly reference matches identity
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.
Multiple assemblies with equivalent identity have been imported: '{0}' and '{1}'. Remove one of the duplicate references.
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.
Assembly '{0}' with identity '{1}' uses '{2}' which has a higher version than referenced assembly '{3}' with identity '{4}'
Fixed size buffers can only be accessed through locals or fields
XML comment has a duplicate typeparam tag for '{0}'
XML comment has a duplicate typeparam tag
XML comment has a typeparam tag for '{0}', but there is no type parameter by that name
XML comment has a typeparam tag, but there is no type parameter by that name
XML comment on '{1}' has a typeparamref tag for '{0}', but there is no type parameter by that name
XML comment has a typeparamref tag, but there is no type parameter by that name
Type parameter '{0}' has no matching typeparam tag in the XML comment on '{1}' (but other type parameters do)
Type parameter has no matching typeparam tag in the XML comment (but other type parameters do)
'{0}': type must be '{2}' to match overridden member '{1}'
Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead.
Assignment made to same variable; did you mean to assign something else?
Assignment made to same variable
Comparison made to same variable; did you mean to compare something else?
Comparison made to same variable
Error opening Win32 resource file '{0}' -- '{1}'
Expression will always cause a System.NullReferenceException because the default value of '{0}' is null
Expression will always cause a System.NullReferenceException because the type's default value is null
Class '{0}' cannot have multiple base classes: '{1}' and '{2}'
Base class '{0}' must come before any interfaces
XML comment has cref attribute '{0}' that refers to a type parameter
XML comment has cref attribute that refers to a type parameter
Friend assembly reference '{0}' is invalid. InternalsVisibleTo declarations cannot have a version, culture, public key token, or processor architecture specified.
Friend assembly reference '{0}' is invalid. Strong-name signed assemblies must specify a public key in their InternalsVisibleTo declarations.
Cannot bind delegate to '{0}' because it is a member of 'System.Nullable<T>'
'{0}' does not contain a constructor that takes {1} arguments
Assembly and module attributes must precede all other elements defined in a file except using clauses and extern alias declarations
Expected expression
Invalid version {0} for /subsystemversion. The version must be 6.02 or greater for ARM or AppContainerExe, and 4.00 or greater otherwise
Embedded interop method '{0}' contains a body.
Warning level must be in the range 0-4
Invalid option '{0}' for /debug; must be 'portable', 'embedded', 'full' or 'pdbonly'
Invalid option '{0}'; Resource visibility must be either 'public' or 'private'
The type of the argument to the DefaultParameterValue attribute must match the parameter type
Argument of type '{0}' is not applicable for the DefaultParameterValue attribute
Duplicate initialization of member '{0}'
Member '{0}' cannot be initialized. It is not a field or property.
Static field or property '{0}' cannot be assigned in an object initializer
Members of readonly field '{0}' of type '{1}' cannot be assigned with an object initializer because it is of a value type
Members of property '{0}' of type '{1}' cannot be assigned with an object initializer because it is of a value type
Unsafe type '{0}' cannot be used in object creation
Element initializer cannot be empty
The best overloaded method match for '{0}' has wrong signature for the initializer element. The initializable Add must be an accessible instance method.
Cannot initialize type '{0}' with a collection initializer because it does not implement 'System.Collections.IEnumerable'
Error reading Win32 manifest file '{0}' -- '{1}'
Ignoring /win32manifest for module because it only applies to assemblies
Ignoring /win32manifest for module because it only applies to assemblies
'{0}' does not contain a definition for '{1}' and the best extension method overload '{2}' requires a receiver of type '{3}'
The range variable '{0}' has already been declared
The range variable '{0}' conflicts with a previous declaration of '{0}'
Cannot assign {0} to a range variable
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}'.
Could not find an implementation of the query pattern for source type '{0}'. '{1}' not found. Are you missing a reference to 'System.Core.dll' or a using directive for 'System.Linq'?
Could not find an implementation of the query pattern for source type '{0}'. '{1}' not found.
The name '{0}' is not in scope on the left side of 'equals'. Consider swapping the expressions on either side of 'equals'.
The name '{0}' is not in scope on the right side of 'equals'. Consider swapping the expressions on either side of 'equals'.
Cannot pass the range variable '{0}' as an out or ref parameter
Multiple implementations of the query pattern were found for source type '{0}'. Ambiguous call to '{1}'.
The type of one of the expressions in the {0} clause is incorrect. Type inference failed in the call to '{1}'.
The type of the expression in the {0} clause is incorrect. Type inference failed in the call to '{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}'.
An expression tree may not contain an unsafe pointer operation
An expression tree may not contain an anonymous method expression
An anonymous method expression cannot be converted to an expression tree
Range variable '{0}' cannot be assigned to -- it is read only
The range variable '{0}' cannot have the same name as a method type parameter
The contextual keyword 'var' cannot be used in a range variable declaration
The best overloaded Add method '{0}' for the collection initializer has some invalid arguments
An expression tree lambda may not contain an out or ref parameter
An expression tree lambda may not contain a method with variable arguments
An expression tree lambda may not contain a method group
The best overloaded method match '{0}' for the collection initializer element cannot be used. Collection initializer 'Add' methods cannot have ref or out parameters.
Non-invocable member '{0}' cannot be used like a method.
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.
Member implements interface member with multiple matches at run-time
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.
Member '{1}' overrides '{0}'. There are multiple override candidates at run-time. It is implementation dependent which method will be called.
Member overrides base member with multiple override candidates at run-time
Object and collection initializer expressions may not be applied to a delegate creation expression
'{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.
Source file '{0}' could not be found.
Source file '{0}' specified multiple times
Source file specified multiple times
Missing file specification for '{0}' option
Command-line syntax error: Missing '{0}' for '{1}' option
Unrecognized option: '{0}'
No source files specified.
No source files specified
Expected a script (.csx file) but none specified
Error opening response file '{0}'
Cannot open '{0}' for writing -- '{1}'
Invalid image base number '{0}'
'{0}' is a binary file instead of a text file
Code page '{0}' is invalid or not installed
Algorithm '{0}' is not supported
Cannot specify /main if building a module or library
Invalid target type for /target: must specify 'exe', 'winexe', 'library', or 'module'
File name '{0}' is empty, contains invalid characters, has a drive specification without an absolute path, or is too long
Ignoring /noconfig option because it was specified in a response file
Ignoring /noconfig option because it was specified in a response file
Invalid file section alignment '{0}'
Invalid output name: {0}
Invalid debug information format: {0}
'id#' syntax is no longer supported. Use '$id' instead.
Invalid name for a preprocessing symbol; '{0}' is not a valid identifier
Invalid name for a preprocessing symbol; not a valid identifier
Cannot create short filename '{0}' when a long filename with the same short filename already exists
A /reference option that declares an extern alias can only have one filename. To specify multiple aliases or filenames, use multiple /reference options.
Command-line syntax error: Missing ':<number>' for '{0}' option
The /pdb option requires that the /debug option also be used
An expression tree lambda may not contain a COM call with ref omitted on arguments
Command-line syntax error: Invalid Guid format '{0}' for option '{1}'
Command-line syntax error: Missing Guid for option '{1}'
Methods with variable arguments are not CLS-compliant
Methods with variable arguments are not CLS-compliant
Argument type '{0}' is not CLS-compliant
Argument type is not CLS-compliant
Return type of '{0}' is not CLS-compliant
Return type is not CLS-compliant
Type of '{0}' is not CLS-compliant
Type is not CLS-compliant
A public, protected, or protected internal variable must be of a type that is compliant with the Common Language Specification (CLS).
Identifier '{0}' differing only in case is not CLS-compliant
Identifier differing only in case is not CLS-compliant
Overloaded method '{0}' differing only in ref or out, or in array rank, is not CLS-compliant
Overloaded method differing only in ref or out, or in array rank, is not CLS-compliant
Overloaded method '{0}' differing only by unnamed array types is not CLS-compliant
Overloaded method differing only by unnamed array types is not CLS-compliant
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.
Identifier '{0}' is not CLS-compliant
Identifier is not CLS-compliant
'{0}': base type '{1}' is not CLS-compliant
Base type is not CLS-compliant
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.
'{0}': CLS-compliant interfaces must have only CLS-compliant members
CLS-compliant interfaces must have only CLS-compliant members
'{0}': only CLS-compliant members can be abstract
Only CLS-compliant members can be abstract
You must specify the CLSCompliant attribute on the assembly, not the module, to enable CLS compliance checking
You must specify the CLSCompliant attribute on the assembly, not the module, to enable CLS compliance checking
Added modules must be marked with the CLSCompliant attribute to match the assembly
Added modules must be marked with the CLSCompliant attribute to match the assembly
'{0}' cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute
Type or member cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute
'{0}' has no accessible constructors which use only CLS-compliant types
Type has no accessible constructors which use only CLS-compliant types
Arrays as attribute arguments is not CLS-compliant
Arrays as attribute arguments is not CLS-compliant
You cannot specify the CLSCompliant attribute on a module that differs from the CLSCompliant attribute on the assembly
You cannot specify the CLSCompliant attribute on a module that differs from the CLSCompliant attribute on the assembly
'{0}' cannot be marked as CLS-compliant because it is a member of non-CLS-compliant type '{1}'
Type cannot be marked as CLS-compliant because it is a member of non-CLS-compliant type
CLS compliance checking will not be performed on '{0}' because it is not visible from outside this assembly
CLS compliance checking will not be performed because it is not visible from outside this assembly
'{0}' does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute
Type or member does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute
CLSCompliant attribute has no meaning when applied to parameters. Try putting it on the method instead.
CLSCompliant attribute has no meaning when applied to parameters
CLSCompliant attribute has no meaning when applied to return types. Try putting it on the method instead.
CLSCompliant attribute has no meaning when applied to return types
Constraint type '{0}' is not CLS-compliant
Constraint type is not CLS-compliant
CLS-compliant field '{0}' cannot be volatile
CLS-compliant field cannot be volatile
'{0}' is not CLS-compliant because base interface '{1}' is not CLS-compliant
Type is not CLS-compliant because base interface is not CLS-compliant
'await' requires that the type {0} have a suitable GetAwaiter method
Cannot await '{0}'
'await' requires that the return type '{0}' of '{1}.GetAwaiter()' have suitable IsCompleted, OnCompleted, and GetResult members, and implement INotifyCompletion or ICriticalNotifyCompletion
'await' requires that the type '{0}' have a suitable GetAwaiter method. Are you missing a using directive for 'System'?
Cannot await 'void'
'await' cannot be used as an identifier within an async method or lambda expression
'{0}' does not implement '{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>'?
The return type of an async method must be void, Task or Task<T>
Cannot return an expression of type 'void'
__arglist is not allowed in the parameter list of async methods
'await' cannot be used in an expression containing the type '{0}'
Async methods cannot have unsafe parameters or return types
Async methods cannot have ref or out parameters
The 'await' operator can only be used when contained within a method or lambda expression marked with the 'async' modifier
The 'await' operator can only be used within an async {0}. Consider marking this {0} with the 'async' modifier.
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}>'.
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'.
Cannot await in the body of a finally clause
Cannot await in a catch clause
Cannot await in the filter expression of a catch clause
Cannot await in the body of a lock statement
The 'await' operator cannot be used in a static script variable initializer.
Cannot await in an unsafe context
The 'async' modifier can only be used in methods that have a body.
Parameters or locals of type '{0}' cannot be declared in async methods or lambda expressions.
foreach statement cannot operate on enumerators of type '{0}' in async or iterator methods because '{0}' is a ref struct.
Security attribute '{0}' cannot be applied to an Async method.
Async methods are not allowed in an Interface, Class, or Structure which has the 'SecurityCritical' or 'SecuritySafeCritical' attribute.
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
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.
Async method lacks 'await' operators and will run synchronously
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.
Because this call is not awaited, execution of the current method continues before the call is completed
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.
'MethodImplOptions.Synchronized' cannot be applied to an async method
CallerLineNumberAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}'
CallerFilePathAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}'
CallerMemberNameAttribute cannot be applied because there are no standard conversions from type '{0}' to type '{1}'
The CallerLineNumberAttribute may only be applied to parameters with default values
The CallerFilePathAttribute may only be applied to parameters with default values
The CallerMemberNameAttribute may only be applied to parameters with default values
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
The CallerLineNumberAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments
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
The CallerFilePathAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments
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
The CallerMemberNameAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments
Program does not contain a static 'Main' method suitable for an entry point
An array initializer of length '{0}' is expected
A nested array initializer is expected
Invalid variance modifier. Only interface and delegate type parameters can be specified as variant.
Unexpected use of an aliased name
Unexpected use of a generic name
Unexpected use of an unbound generic name
Expressions and statements can only occur in a method body
An array access may not have a named argument specifier
This language feature ('{0}') is not yet implemented.
Default values are not valid in this context.
Error opening icon file {0} -- {1}
Error opening Win32 manifest file {0} -- {1}
Error building Win32 resources -- {0}
Optional parameters must appear after all required parameters
Cannot inherit interface '{0}' with the specified type parameters because it causes method '{1}' to contain overloads which differ only on ref and out
Partial declarations of '{0}' must have the same type parameter names and variance modifiers in the same order
Invalid variance: The type parameter '{1}' must be {3} valid on '{0}'. '{1}' is {2}.
'{0}': cannot derive from the dynamic type
'{0}': cannot implement a dynamic interface '{1}'
Constraint cannot be the dynamic type
Constraint cannot be a dynamic type '{0}'
One or more types required to compile a dynamic expression cannot be found. Are you missing a reference?
Name '{0}' exceeds the maximum length allowed in metadata.
Attributes are not valid in this context.
'extern alias' is not valid in this context
Using '{0}' to test compatibility with '{1}' is essentially identical to testing compatibility with '{2}' and will succeed for all non-null values
Using 'is' to test compatibility with 'dynamic' is essentially identical to testing compatibility with 'Object'
Cannot use 'yield' in top-level script code
Cannot declare namespace in script code
Assembly and module attributes are not allowed in this context
Delegate '{0}' has no invoke method or an invoke method with a return type or parameter types that are not supported.
The entry point of the program is global script code; ignoring '{0}' entry point.
The entry point of the program is global script code; ignoring entry point
The second operand of an 'is' or 'as' operator may not be static type '{0}'
Inconsistent accessibility: event type '{1}' is less accessible than event '{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.
Named argument specifications must appear after all fixed arguments have been specified in a dynamic invocation.
The best overload for '{0}' does not have a parameter named '{1}'
The delegate '{0}' does not have a parameter named '{1}'
Named argument '{0}' cannot be specified multiple times
Named argument '{0}' specifies a parameter for which a positional argument has already been given
Named argument '{0}' is used out-of-position but is followed by an unnamed argument
Cannot specify default parameter value in conjunction with DefaultParameterAttribute or OptionalAttribute
Default parameter value for '{0}' must be a compile-time constant
A ref or out parameter cannot have a default value
Cannot specify a default value for the 'this' parameter
Cannot specify a default value for a parameter array
A value of type '{0}' cannot be used as a default parameter because there are no standard conversions to type '{1}'
A value of type '{0}' cannot be used as default parameter for nullable parameter '{1}' because '{0}' is not a simple type
'{0}' is of type '{1}'. A default parameter value of a reference type other than string can only be initialized with 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
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
Error signing output with public key from file '{0}' -- {1}
Error signing output with public key from container '{0}' -- {1}
The typeof operator cannot be used on the dynamic type
An expression tree may not contain a dynamic operation
Async lambda expressions cannot be converted to expression trees
Cannot define a class or member that utilizes 'dynamic' because the compiler required type '{0}' cannot be found. Are you missing a reference?
Cannot pass null for friend assembly name
Key file '{0}' is missing the private key needed for signing
Public signing was specified and requires a public key, but no public key was specified.
Public signing is not supported for netmodules.
Delay signing was specified and requires a public key, but no public key was specified
Delay signing was specified and requires a public key, but no public key was specified
The specified version string does not conform to the required format - major[.minor[.build[.revision]]]
The specified version string contains wildcards, which are not compatible with determinism. Either remove wildcards from the version string, or disable determinism for this compilation
The specified version string does not conform to the required format - major.minor.build.revision (without wildcards)
The specified version string does not conform to the recommended format - major.minor.build.revision
The specified version string does not conform to the recommended format - major.minor.build.revision
Executables cannot be satellite assemblies; culture should always be empty
There is no argument given that corresponds to the required formal parameter '{0}' of '{1}'
The command line switch '{0}' is not yet implemented and was ignored.
Command line switch is not yet implemented
Failed to emit module '{0}'.
Cannot use fixed local '{0}' inside an anonymous method, lambda expression, or query expression
An expression tree may not contain a named argument specification
An expression tree may not contain a call or invocation that uses optional arguments
An expression tree may not contain an indexed property
Indexed property '{0}' has non-optional arguments which must be provided
Indexed property '{0}' must have all arguments optional
Instance of type '{0}' cannot be used inside a nested function, query expression, iterator block or async method
First argument to a security attribute must be a valid SecurityAction
Security attribute '{0}' has an invalid SecurityAction value '{1}'
SecurityAction value '{0}' is invalid for security attributes applied to an assembly
SecurityAction value '{0}' is invalid for security attributes applied to a type or a method
SecurityAction value '{0}' is invalid for PrincipalPermission attribute
An expression tree may not contain '{0}'
Unable to resolve file path '{0}' specified for the named argument '{1}' for PermissionSet attribute
Error reading file '{0}' specified for the named argument '{1}' for PermissionSet attribute: '{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.
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.
The type name '{0}' could not be found. This type has been forwarded to assembly '{1}'. Consider adding a reference to that assembly.
Assemblies '{0}' and '{1}' refer to the same metadata but only one is a linked reference (specified using /link option); consider removing one of the references.
The best overloaded Add method '{0}' for the collection initializer element is obsolete.
The best overloaded Add method for the collection initializer element is obsolete
The best overloaded Add method '{0}' for the collection initializer element is obsolete. {1}
The best overloaded Add method for the collection initializer element is obsolete
The best overloaded Add method '{0}' for the collection initializer element is obsolete. {1}
Yield statements may not appear at the top level in interactive code.
Security attribute '{0}' is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.
Cannot use an expression of type '{0}' as an argument to a dynamically dispatched operation.
Cannot use a lambda expression as an argument to a dynamically dispatched operation without first casting it to a delegate or expression tree type.
Cannot use a method group as an argument to a dynamically dispatched operation. Did you intend to invoke the method?
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.
Query expressions over source type 'dynamic' or with a join sequence of type 'dynamic' are not allowed
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.
The dynamically dispatched call to method '{0}' may fail at runtime because one or more applicable overloads are conditional methods.
Dynamically dispatched call may fail at runtime because one or more applicable overloads are conditional methods
'{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.
The CallerMemberNameAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerFilePathAttribute.
The CallerMemberNameAttribute will have no effect; it is overridden by the CallerFilePathAttribute
The CallerMemberNameAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerLineNumberAttribute.
The CallerMemberNameAttribute will have no effect; it is overridden by the CallerLineNumberAttribute
The CallerFilePathAttribute applied to parameter '{0}' will have no effect. It is overridden by the CallerLineNumberAttribute.
The CallerFilePathAttribute will have no effect; it is overridden by the CallerLineNumberAttribute
Expression must be implicitly convertible to Boolean or its type '{0}' must define operator '{1}'.
'{0}' cannot implement '{1}' because '{2}' is a Windows Runtime event and '{3}' is a regular .NET event.
Call System.IDisposable.Dispose() on allocated instance of {0} before all references to it are out of scope.
Call System.IDisposable.Dispose() on allocated instance before all references to it are out of scope
Allocated instance of {0} is not disposed along all exception paths. Call System.IDisposable.Dispose() before all references to it are out of scope.
Allocated instance is not disposed along all exception paths
Object '{0}' can be disposed more than once.
Object can be disposed more than once
Interop type '{0}' cannot be embedded. Use the applicable interface instead.
Type '{0}' cannot be embedded because it is a nested type. Consider setting the 'Embed Interop Types' property to false.
Type '{0}' cannot be embedded because it has a generic argument. Consider setting the 'Embed Interop Types' property to false.
Embedded interop struct '{0}' can contain only public instance fields.
A Windows Runtime event may not be passed as an out or ref parameter.
Source interface '{0}' is missing method '{1}' which is required to embed event '{2}'.
Interface '{0}' has an invalid source interface which is required to embed event '{1}'.
Interop type '{0}' cannot be embedded because it is missing the required '{1}' attribute.
Cannot embed interop types from assembly '{0}' because it is missing the '{1}' attribute.
Cannot embed interop types from assembly '{0}' because it is missing either the '{1}' attribute or the '{2}' attribute.
Cannot embed interop type '{0}' found in both assembly '{1}' and '{2}'. Consider setting the 'Embed Interop Types' property to 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.
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.
A reference was created to embedded interop assembly because of an indirect assembly reference
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.
Type '{0}' from assembly '{1}' cannot be used across assembly boundaries because it has a generic type argument that is an embedded interop type.
Cannot find the interop type that matches the embedded interop type '{0}'. Are you missing an assembly reference?
By-reference return type 'ref {0}' is not supported.
Module name '{0}' stored in '{1}' must match its filename.
Invalid module name: {0}
Invalid '{0}' value: '{1}'.
AppConfigPath must be absolute.
Attribute '{0}' from module '{1}' will be ignored in favor of the instance appearing in source
Attribute will be ignored in favor of the instance appearing in source
Attribute '{0}' given in a source file conflicts with option '{1}'.
A fixed buffer may only have one dimension.
Referenced assembly '{0}' does not have a strong name.
Referenced assembly does not have a strong name
Invalid signature public key specified in AssemblySignatureKeyAttribute.
Type '{0}' exported from module '{1}' conflicts with type declared in primary module of this assembly.
Type '{0}' exported from module '{1}' conflicts with type '{2}' exported from module '{3}'.
Forwarded type '{0}' conflicts with type declared in primary module of this assembly.
Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' forwarded to assembly '{3}'.
Type '{0}' forwarded to assembly '{1}' conflicts with type '{2}' exported from module '{3}'.
Referenced assembly '{0}' has different culture setting of '{1}'.
Referenced assembly has different culture setting
Agnostic assembly cannot have a processor specific module '{0}'.
Assembly and module '{0}' cannot target different processors.
Referenced assembly '{0}' targets a different processor.
Referenced assembly targets a different processor
Cryptographic failure while creating hashes.
Reference to '{0}' netmodule missing.
Module '{0}' is already defined in this assembly. Each module must have a unique filename.
Cannot read config file '{0}' -- '{1}'
Cannot continue since the edit includes a reference to an embedded type: '{0}'.
Member '{0}' added during the current debug session can only be accessed from within its declaring assembly '{1}'.
Compilation options '{0}' and '{1}' can't both be specified at the same time.
Linked netmodule metadata must provide a full PE image: '{0}'.
/platform:anycpu32bitpreferred can only be used with /t:exe, /t:winexe and /t:appcontainerexe
<path list>
<text>
null propagating operator
expression-bodied method
expression-bodied property
expression-bodied indexer
auto property initializer
<namespace>
byref locals and returns
readonly references
ref structs
ref conditional expression
Compilation (C#):
Syntax node is not within syntax tree
Location must be provided in order to provide minimal type qualification.
SyntaxTreeSemanticModel must be provided in order to provide minimal type qualification.
Can't reference compilation of type '{0}' from {1} compilation.
Syntax tree already present
Submission can only include script code.
Submission can have at most one syntax tree.
SyntaxTree '{0}' not found to remove
tree must have a root node with SyntaxKind.CompilationUnit
Type argument cannot be null
Wrong number of type arguments
Name conflict for name {0}
LookupOptions has an invalid combination of options
items: must be non-empty
Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Identifier or Microsoft.CodeAnalysis.CSharp.SyntaxFactory.VerbatimIdentifier to create identifier tokens.
Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal to create character literal tokens.
Use Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Literal to create numeric literal tokens.
This method can only be used to create tokens - {0} is not a token kind.
Generic parameter is definition when expected to be reference {0}
Called GetDeclarationName for a declaration node that can possibly contain multiple variable declarators.
tree not part of compilation
Position is not within syntax tree with full span {0}
The language name '{0}' is invalid.
The language name is invalid
Transparent identifier member access failed for field '{0}' of '{1}'. Does the data being queried implement the query pattern?
The parameter has multiple distinct default values.
The field has multiple distinct constant values.
Within cref attributes, nested types of generic types should be qualified.
Within cref attributes, nested types of generic types should be qualified
Not a C# symbol.
Unnecessary using directive.
Unused extern alias.
Elements cannot be null.
LIB environment variable
/LIB option
/REFERENCEPATH option
directory does not exist
path is too long or invalid
No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options.
No value for RuntimeMetadataVersion found
Expected a {0} SemanticModel.
lambda expression
Feature '{0}' is not available in C# 1. Please use language version {1} or greater.
Feature '{0}' is not available in C# 2. Please use language version {1} or greater.
Feature '{0}' is not available in C# 3. Please use language version {1} or greater.
Feature '{0}' is not available in C# 4. Please use language version {1} or greater.
Feature '{0}' is not available in C# 5. Please use language version {1} or greater.
Feature '{0}' is not available in C# 6. Please use language version {1} or greater.
Feature '{0}' is not available in C# 7.0. Please use language version {1} or greater.
Feature '{0}' is not implemented in this compiler.
'experimental'
Position must be within span of the syntax tree.
Syntax node to be speculated cannot belong to a syntax tree from the current compilation.
Chaining speculative semantic model is not supported. You should create a speculative model from the non-speculative ParentModel.
Microsoft (R) Visual C# Compiler
{0} version {1}
Copyright (C) Microsoft Corporation. All rights reserved.
Supported language versions:
Visual C# Compiler Options
- OUTPUT FILES -
/out:<file> Specify output file name (default: base name of
file with main class or first file)
/target:exe Build a console executable (default) (Short
form: /t:exe)
/target:winexe Build a Windows executable (Short form:
/t:winexe)
/target:library Build a library (Short form: /t:library)
/target:module Build a module that can be added to another
assembly (Short form: /t:module)
/target:appcontainerexe Build an Appcontainer executable (Short form:
/t:appcontainerexe)
/target:winmdobj Build a Windows Runtime intermediate file that
is consumed by WinMDExp (Short form: /t:winmdobj)
/doc:<file> XML Documentation file to generate
/refout:<file> Reference assembly output to generate
/platform:<string> Limit which platforms this code can run on: x86,
Itanium, x64, arm, arm64, anycpu32bitpreferred, or
anycpu. The default is anycpu.
- INPUT FILES -
/recurse:<wildcard> Include all files in the current directory and
subdirectories according to the wildcard
specifications
/reference:<alias>=<file> Reference metadata from the specified assembly
file using the given alias (Short form: /r)
/reference:<file list> Reference metadata from the specified assembly
files (Short form: /r)
/addmodule:<file list> Link the specified modules into this assembly
/link:<file list> Embed metadata from the specified interop
assembly files (Short form: /l)
/analyzer:<file list> Run the analyzers from this assembly
(Short form: /a)
/additionalfile:<file list> Additional files that don't directly affect code
generation but may be used by analyzers for producing
errors or warnings.
/embed Embed all source files in the PDB.
/embed:<file list> Embed specific files in the PDB
- RESOURCES -
/win32res:<file> Specify a Win32 resource file (.res)
/win32icon:<file> Use this icon for the output
/win32manifest:<file> Specify a Win32 manifest file (.xml)
/nowin32manifest Do not include the default Win32 manifest
/resource:<resinfo> Embed the specified resource (Short form: /res)
/linkresource:<resinfo> Link the specified resource to this assembly
(Short form: /linkres) Where the resinfo format
is <file>[,<string name>[,public|private]]
- CODE GENERATION -
/debug[+|-] Emit debugging information
/debug:{full|pdbonly|portable|embedded}
Specify debugging type ('full' is default,
'portable' is a cross-platform format,
'embedded' is a cross-platform format embedded into
the target .dll or .exe)
/optimize[+|-] Enable optimizations (Short form: /o)
/deterministic Produce a deterministic assembly
(including module version GUID and timestamp)
/refonly Produce a reference assembly in place of the main output
/instrument:TestCoverage Produce an assembly instrumented to collect
coverage information
/sourcelink:<file> Source link info to embed into PDB.
- ERRORS AND WARNINGS -
/warnaserror[+|-] Report all warnings as errors
/warnaserror[+|-]:<warn list> Report specific warnings as errors
/warn:<n> Set warning level (0-4) (Short form: /w)
/nowarn:<warn list> Disable specific warning messages
/ruleset:<file> Specify a ruleset file that disables specific
diagnostics.
/errorlog:<file> Specify a file to log all compiler and analyzer
diagnostics.
/reportanalyzer Report additional analyzer information, such as
execution time.
- LANGUAGE -
/checked[+|-] Generate overflow checks
/unsafe[+|-] Allow 'unsafe' code
/define:<symbol list> Define conditional compilation symbol(s) (Short
form: /d)
/langversion:? Display the allowed values for language version
/langversion:<string> Specify language version such as
`default` (latest major version), or
`latest` (latest version, including minor versions),
or specific versions like `6` or `7.1`
- 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 (default) or SHA256.
/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.
/nostdlib[+|-] Do not reference standard library (mscorlib.dll)
/subsystemversion:<string> Specify subsystem version of this assembly
/lib:<file list> Specify additional directories to search in for
references
/errorreport:<string> Specify how to handle internal compiler errors:
prompt, send, queue, or none. The default is
queue.
/appconfig:<file> Specify an application configuration file
containing assembly binding settings
/moduleassemblyname:<string> Name of the assembly which this module will be
a part of
/modulename:<string> Specify the name of the source module
Visual C# Compiler Options
'{0}': a class with the ComImport attribute cannot specify field initializers.
Local name '{0}' is too long for PDB. Consider shortening or compiling without /debug.
Local name is too long for PDB
Anonymous function converted to a void returning delegate cannot return a value
Async lambda expression converted to a 'Task' returning delegate cannot return a value. Did you intend to return 'Task<T>'?
An instance of analyzer {0} cannot be created from {1} : {2}.
An analyzer instance cannot be created
The assembly {0} does not contain any analyzers.
Assembly does not contain any analyzers
Unable to load Analyzer assembly {0} : {1}
Unable to load Analyzer assembly
Skipping some types in analyzer assembly {0} due to a ReflectionTypeLoadException : {1}.
Error reading ruleset file {0} - {1}
Error reading debug information for '{0}'
Operation caused a stack overflow.
Expected identifier or numeric literal.
Expected identifier or numeric literal
Only auto-implemented properties can have initializers.
Auto-implemented properties must have get accessors.
Auto-implemented properties must override all accessors of the overridden property.
Auto-implemented properties inside interfaces cannot have initializers.
Structs without explicit constructors cannot contain members with initializers.
Cannot emit debug information for a source text without encoding.
Block bodies and expression bodies cannot both be provided.
Control cannot fall out of switch from final case label ('{0}')
Type arguments are not allowed in the nameof operator.
An expression tree lambda may not contain a null propagating operator.
An expression tree lambda may not contain a dictionary initializer.
An extension Add method is not supported for a collection initializer in an expression lambda.
nameof operator
dictionary initializer
Missing close delimiter '}' for interpolated expression started with '{'.
A single-line comment may not be used in an interpolated string.
An expression is too long or complex to compile
Expression does not have a name.
Sub-expression cannot be used in an argument to nameof.
An alias-qualified name is not an expression.
Type parameters are not allowed on a method group as an argument to 'nameof'.
SearchCriteria is expected.
Assembly culture strings may not contain embedded NUL characters.
using static
interpolated strings
await in catch blocks and finally blocks
binary literals
digit separators
local functions
A '{0}' character must be escaped (by doubling) in an interpolated string.
A '{0}' character may only be escaped by doubling '{0}{0}' in an interpolated string.
A format specifier may not contain trailing whitespace.
Empty format specifier.
There is an error in a referenced assembly '{0}'.
Expression or declaration statement expected.
Extension method groups are not allowed as an argument to 'nameof'.
Alignment value {0} has a magnitude greater than {1} and may result in a large formatted string.
Unused extern alias
Unnecessary using directive
Skip loading types in analyzer assembly that fail due to a ReflectionTypeLoadException
Alignment value has a magnitude that may result in a large formatted string
Length of String constant exceeds current memory limit. Try splitting the string into multiple constants.
Tuple must contain at least two elements.
Debug entry point must be a definition of a method declared in the current compilation.
#load is only allowed in scripts
Cannot use #load after first token in file
Could not find file.
File path referenced in source (#load) could not be resolved.
SyntaxTree '{0}' resulted from a #load directive and cannot be removed or replaced directly.
Source file references are not supported.
The pathmap option was incorrectly formatted.
Invalid real literal.
Auto-implemented properties cannot return by reference
Properties which return by reference must have a get accessor
Properties which return by reference cannot have set accessors
'{0}' must match by reference return of overridden member '{1}'
By-reference returns may only be used in methods that return by reference
By-value returns may only be used in methods that return by value
The return expression must be of type '{0}' because this method returns by reference
'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}' because it does not have matching return by reference.
The body of '{0}' cannot be an iterator block because '{0}' returns by reference
Lambda expressions that return by reference cannot be converted to expression trees
An expression tree lambda may not contain a call to a method, property, or indexer that returns by reference
An expression cannot be used in this context because it may not be passed or returned by reference
Cannot return '{0}' by reference because it was initialized to a value that cannot be returned by reference
Cannot return by reference a member of '{0}' because it was initialized to a value that cannot be returned by reference
Cannot return '{0}' by reference because it is read-only
Cannot return the range variable '{0}' by reference
Cannot return '{0}' by reference because it is a '{1}'
Cannot return fields of '{0}' by reference because it is a '{1}'
A readonly field cannot be returned by writable reference
A static readonly field cannot be returned by writable reference
Members of readonly field '{0}' cannot be returned by writable reference
Fields of static readonly field '{0}' cannot be returned by writable reference
Cannot return a parameter by reference '{0}' because it is not a ref or out parameter
Cannot return by reference a member of parameter '{0}' because it is not a ref or out parameter
Cannot return local '{0}' by reference because it is not a ref local
Cannot return a member of local '{0}' by reference because it is not a ref local
Struct members cannot return 'this' or other instance members by reference
Expression cannot be used in this context because it may indirectly expose variables outside of their declaration scope
Cannot use local '{0}' in this context because it may expose referenced variables outside of their declaration scope
Cannot use a result of '{0}' in this context because it may expose variables referenced by parameter '{1}' outside of their declaration scope
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
This combination of arguments to '{0}' is disallowed because it may expose variables referenced by parameter '{1}' outside of their declaration scope
Branches of a ref ternary operator cannot refer to variables with incompatible declaration scopes
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
Cannot initialize a by-value variable with a reference
Cannot initialize a by-reference variable with a value
The expression must be of type '{0}' because it is being assigned by reference
A declaration of a by-reference variable must have an initializer
Cannot use ref local '{0}' inside an anonymous method, lambda expression, or query expression
Iterators cannot have by reference locals
Async methods cannot have by reference locals
'await' cannot be used in an expression containing a call to '{0}' because it returns by reference
'await' cannot be used in an expression containing a ref conditional operator
Both conditional operator values must be ref values or neither may be a ref value
The expression must be of type '{0}' to match the alternative ref value
An expression tree may not contain a reference to a local function
Cannot pass argument with dynamic type to params parameter '{0}' of local function '{1}'.
Syntax tree should be created from a submission.
Combined length of user strings used by the program exceeds allowed limit. Try to decrease use of string literals.
It is not legal to use nullable type '{0}' in a pattern; use the underlying type '{1}' instead.
Invalid operand for pattern match; value required, but found '{0}'.
An error occurred while writing the output file: {0}.
Tuple element names must be unique.
Tuple element name '{0}' is only allowed at position {1}.
Tuple element name '{0}' is disallowed at any position.
Member '{0}' was not found on type '{1}' from assembly '{2}'.
tuples
No suitable Deconstruct instance or extension method was found for type '{0}', with {1} out parameters and a void return type.
Deconstruct assignment requires an expression with a type on the right-hand-side.
The switch expression must be a value; found '{0}'.
The switch case has already been handled by a previous case.
An expression of type '{0}' cannot be handled by a pattern of type '{1}'.
Attribute '{0}' is ignored when public signing is specified.
Attribute is ignored when public signing is specified.
Option '{0}' must be an absolute path.
Tuple with {0} elements cannot be converted to type '{1}'.
out variable declaration
Reference to an implicitly-typed out variable '{0}' is not permitted in the same argument list.
Cannot infer the type of implicitly-typed out variable '{0}'.
Cannot infer the type of implicitly-typed deconstruction variable '{0}'.
Cannot infer the type of implicitly-typed discard.
Cannot deconstruct a tuple of '{0}' elements into '{1}' variables.
Cannot deconstruct dynamic objects.
Deconstruction must contain at least two variables.
The type must be 'var'.
The tuple element name '{0}' is ignored because a different name or no name is specified by the target type '{1}'.
The tuple element name is ignored because a different name or no name is specified by the assignment target.
Predefined type '{0}' must be a struct.
'new' cannot be used with tuple type. Use a tuple literal expression instead.
Deconstruction 'var (...)' form disallows a specific type for 'var'.
Cannot define a class or member that utilizes tuples because the compiler required type '{0}' cannot be found. Are you missing a reference?
Cannot reference 'System.Runtime.CompilerServices.TupleElementNamesAttribute' explicitly. Use the tuple syntax to define tuple names.
An expression tree may not contain an out argument variable declaration.
An expression tree may not contain a discard.
An expression tree may not contain an 'is' pattern-matching operator.
An expression tree may not contain a tuple literal.
An expression tree may not contain a tuple conversion.
/sourcelink switch is only supported when emitting PDB.
/embed switch is only supported when emitting a PDB.
Invalid instrumentation kind: {0}
Invalid hash algorithm name: '{0}'
The syntax 'var (...)' as an lvalue is reserved.
Out variable and pattern variable declarations are not allowed within constructor initializers, field initializers, or property initializers.
Out variable and pattern variable declarations are not allowed within a query clause.
{ or ; or => expected
A throw expression is not allowed in this context.
A deconstruction cannot mix declarations and expressions on the left-hand-side.
A declaration is not allowed in this context.
A foreach loop must declare its iteration variables.
Tuple element names are not permitted on the left of a deconstruction.
To cast a negative value, you must enclose the value in parentheses.
An expression tree may not contain a throw-expression.
Invalid assembly name: {0}
For type '{0}' to be used as an AsyncMethodBuilder for type '{1}', its Task property should return type '{1}' instead of type '{2}'.
Attributes are not allowed on local function parameters or type parameters
Module '{0}' in assembly '{1}' is forwarding the type '{2}' to multiple assemblies: '{3}' and '{4}'.
It is not legal to use the type 'dynamic' in a pattern.
Cannot use a default literal as an argument to a dynamically dispatched operation.
Provided documentation mode is unsupported or invalid: '{0}'.
Provided source code kind is unsupported or invalid: '{0}'
Provided language version is unsupported or invalid: '{0}'.
Invalid name for a preprocessing symbol; '{0}' is not a valid identifier
Feature '{0}' is not available in C# 7.1. Please use language version {1} or greater.
Feature '{0}' is not available in C# 7.2. Please use language version {1} or greater.
Specified language version '{0}' cannot have leading zeroes
A value of type 'void' may not be assigned.
'{0}' is for evaluation purposes only and is subject to change or removal in future updates.
Type is for evaluation purposes only and is subject to change or removal in future updates.
Compiler version: '{0}'. Language version: {1}.
async main
Tuple element name '{0}' is inferred. Please use language version {1} or greater to access an element by its inferred name.
A default literal 'default' is not valid as a case constant. Use another literal (e.g. '0' or 'null') as appropriate. If you intended to write the default label, use 'default:' without 'case'.
A tuple may not contain a value of type 'void'.
A void or int returning entry point cannot be async
An expression of type '{0}' cannot be handled by a pattern of type '{1}' in C# {2}. Please use language version {3} or greater.
The local function '{0}' is declared but never used
Local function is declared but never used
'{0}' is a local function and must therefore always have a body.
Unable to read debug information of method '{0}' (token 0x{1:X8}) from assembly '{2}'
{0} is not a valid C# conversion expression
Cannot pass argument with dynamic type to generic local function '{0}' with inferred type arguments.
leading digit separator
Do not use '{0}'. This is reserved for compiler usage.
The type name '{0}' is reserved to be used by the compiler.
The first parameter of an 'in' extension method '{0}' must be a value type.
Instance fields of readonly structs must be readonly.
Auto-implemented instance properties in readonly structs must be readonly.
Field-like events are not allowed in readonly structs.
ref extension methods
Conversion of a stackalloc expression of type '{0}' to type '{1}' is not possible.
stackalloc {0}[{1}]
The first parameter of a 'ref' extension method '{0}' must be a value type or a generic type constrained to struct.
An in parameter cannot have the Out attribute.
{0} is not a valid C# compound assignment operation
Filter expression is a constant 'false', consider removing the catch clause
Filter expression is a constant 'false'
Filter expression is a constant 'false', consider removing the try-catch block
Filter expression is a constant 'false'.
A conditional expression cannot be used directly in a string interpolation because the ':' ends the interpolation. Parenthesize the conditional expression.
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 'var _'.
Arguments with 'in' modifier cannot be used in dynamically dispatched expessions.