List of All C# Compiler Errors in Visual Studio


This content was proof-read by Grammarly. You can Try Grammary for FREE

In this post, you’ll see the list of all the C# compiler errors. When you compile your C# application and receive an error or warning in Visual Studio, thesemight be one of the below from the list of C# error.

CodeSeverityMessage
CS0006ErrorMetadata file ‘{0}’ could not be found
CS0009FatalMetadata file ‘{0}’ could not be opened — {1}
CS0012ErrorThe type ‘{0}’ is defined in an assembly that is not referenced. You must add a reference to assembly ‘{1}’.
CS0016ErrorCould not write to output file ‘{0}’ — ‘{1}’
CS0017ErrorProgram has more than one entry point defined. Compile with /main to specify the type that contains the entry point.
CS0019ErrorOperator ‘{0}’ cannot be applied to operands of type ‘{1}’ and ‘{2}’
CS0020ErrorDivision by constant zero
CS0021ErrorCannot apply indexing with [] to an expression of type ‘{0}’
CS0022ErrorWrong number of indices inside []; expected {0}
CS0023ErrorOperator ‘{0}’ cannot be applied to operand of type ‘{1}’
CS0026ErrorKeyword ‘this’ is not valid in a static property, static method, or static field initializer
CS0027ErrorKeyword ‘this’ is not available in the current context
CS0028Warning‘{0}’ has the wrong signature to be an entry point
CS0029ErrorCannot implicitly convert type ‘{0}’ to ‘{1}’
CS0030ErrorCannot convert type ‘{0}’ to ‘{1}’
CS0031ErrorConstant value ‘{0}’ cannot be converted to a ‘{1}’
CS0034ErrorOperator ‘{0}’ is ambiguous on operands of type ‘{1}’ and ‘{2}’
CS0035ErrorOperator ‘{0}’ is ambiguous on an operand of type ‘{1}’
CS0036ErrorAn out parameter cannot have the In attribute
CS0037ErrorCannot convert null to ‘{0}’ because it is a non-nullable value type
CS0039ErrorCannot convert type ‘{0}’ to ‘{1}’ via a reference conversion, boxing conversion, unboxing conversion, wrapping conversion, or null type conversion
CS0041FatalUnexpected error writing debug information — ‘{0}’
CS0050ErrorInconsistent accessibility: return type ‘{1}’ is less accessible than method ‘{0}’
CS0051ErrorInconsistent accessibility: parameter type ‘{1}’ is less accessible than method ‘{0}’
CS0052ErrorInconsistent accessibility: field type ‘{1}’ is less accessible than field ‘{0}’
CS0053ErrorInconsistent accessibility: property type ‘{1}’ is less accessible than property ‘{0}’
CS0054ErrorInconsistent accessibility: indexer return type ‘{1}’ is less accessible than indexer ‘{0}’
CS0055ErrorInconsistent accessibility: parameter type ‘{1}’ is less accessible than indexer ‘{0}’
CS0056ErrorInconsistent accessibility: return type ‘{1}’ is less accessible than operator ‘{0}’
CS0057ErrorInconsistent accessibility: parameter type ‘{1}’ is less accessible than operator ‘{0}’
CS0058ErrorInconsistent accessibility: return type ‘{1}’ is less accessible than delegate ‘{0}’
CS0059ErrorInconsistent accessibility: parameter type ‘{1}’ is less accessible than delegate ‘{0}’
CS0060ErrorInconsistent accessibility: base class ‘{1}’ is less accessible than class ‘{0}’
CS0061ErrorInconsistent accessibility: base interface ‘{1}’ is less accessible than interface ‘{0}’
CS0065Error‘{0}’: event property must have both add and remove accessors
CS0066Error‘{0}’: event must be of a delegate type
CS0067WarningThe event ‘{0}’ is never used
CS0068Error‘{0}’: instance event in interface cannot have initializer
CS0070ErrorThe event ‘{0}’ can only appear on the left hand side of += or -= (except when used from within the type ‘{1}’)
CS0071ErrorAn explicit interface implementation of an event must use event accessor syntax
CS0072Error‘{0}’: cannot override; ‘{1}’ is not an event
CS0073ErrorAn add or remove accessor must have a body
CS0074Error‘{0}’: abstract event cannot have initializer
CS0075ErrorTo cast a negative value, you must enclose the value in parentheses.
CS0076ErrorThe enumerator name ‘{0}’ is reserved and cannot be used
CS0077ErrorThe as operator must be used with a reference type or nullable type (‘{0}’ is a non-nullable value type)
CS0078WarningThe ‘l’ suffix is easily confused with the digit ‘1’ — use ‘L’ for clarity
CS0079ErrorThe event ‘{0}’ can only appear on the left hand side of += or -=
CS0080ErrorConstraints are not allowed on non-generic declarations
CS0081ErrorType parameter declaration must be an identifier not a type
CS0082ErrorType ‘{1}’ already reserves a member called ‘{0}’ with the same parameter types
CS0100ErrorThe parameter name ‘{0}’ is a duplicate
CS0101ErrorThe namespace ‘{1}’ already contains a definition for ‘{0}’
CS0102ErrorThe type ‘{0}’ already contains a definition for ‘{1}’
CS0103ErrorThe name ‘{0}’ does not exist in the current context
CS0104Error‘{0}’ is an ambiguous reference between ‘{1}’ and ‘{2}’
CS0105WarningThe using directive for ‘{0}’ appeared previously in this namespace
CS0106ErrorThe modifier ‘{0}’ is not valid for this item
CS0107ErrorMore than one protection modifier
CS0108Warning‘{0}’ hides inherited member ‘{1}’. Use the new keyword if hiding was intended.
CS0109WarningThe member ‘{0}’ does not hide an accessible member. The new keyword is not required.
CS0110ErrorThe evaluation of the constant value for ‘{0}’ involves a circular definition
CS0111ErrorType ‘{1}’ already defines a member called ‘{0}’ with the same parameter types
CS0112ErrorA static member cannot be marked as ‘{0}’
CS0113ErrorA member ‘{0}’ marked as override cannot be marked as new or virtual
CS0114Warning‘{0}’ hides inherited member ‘{1}’. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.
CS0115Error‘{0}’: no suitable method found to override
CS0116ErrorA namespace cannot directly contain members such as fields or methods
CS0117Error‘{0}’ does not contain a definition for ‘{1}’
CS0118Error‘{0}’ is a {1} but is used like a {2}
CS0119Error‘{0}’ is a {1}, which is not valid in the given context
CS0120ErrorAn object reference is required for the non-static field, method, or property ‘{0}’
CS0121ErrorThe call is ambiguous between the following methods or properties: ‘{0}’ and ‘{1}’
CS0122Error‘{0}’ is inaccessible due to its protection level
CS0123ErrorNo overload for ‘{0}’ matches delegate ‘{1}’
CS0126ErrorAn object of a type convertible to ‘{0}’ is required
CS0127ErrorSince ‘{0}’ returns void, a return keyword must not be followed by an object expression
CS0128ErrorA local variable or function named ‘{0}’ is already defined in this scope
CS0131ErrorThe left-hand side of an assignment must be a variable, property or indexer
CS0132Error‘{0}’: a static constructor must be parameterless
CS0133ErrorThe expression being assigned to ‘{0}’ must be constant
CS0134Error‘{0}’ is of type ‘{1}’. A const field of a reference type other than string can only be initialized with null.
CS0136ErrorA 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
CS0138ErrorA ‘using namespace’ directive can only be applied to namespaces; ‘{0}’ is a type not a namespace. Consider a ‘using static’ directive instead
CS0139ErrorNo enclosing loop out of which to break or continue
CS0140ErrorThe label ‘{0}’ is a duplicate
CS0143ErrorThe type ‘{0}’ has no constructors defined
CS0144ErrorCannot create an instance of the abstract type or interface ‘{0}’
CS0145ErrorA const field requires a value to be provided
CS0146ErrorCircular base type dependency involving ‘{0}’ and ‘{1}’
CS0148ErrorThe delegate ‘{0}’ does not have a valid constructor
CS0149ErrorMethod name expected
CS0150ErrorA constant value is expected
CS0151ErrorA switch expression or case label must be a bool, char, string, integral, enum, or corresponding nullable type in C# 6 and earlier.
CS0152ErrorThe switch statement contains multiple cases with the label value ‘{0}’
CS0153ErrorA goto case is only valid inside a switch statement
CS0154ErrorThe property or indexer ‘{0}’ cannot be used in this context because it lacks the get accessor
CS0155ErrorThe type caught or thrown must be derived from System.Exception
CS0156ErrorA throw statement with no arguments is not allowed outside of a catch clause
CS0157ErrorControl cannot leave the body of a finally clause
CS0158ErrorThe label ‘{0}’ shadows another label by the same name in a contained scope
CS0159ErrorNo such label ‘{0}’ within the scope of the goto statement
CS0160ErrorA previous catch clause already catches all exceptions of this or of a super type (‘{0}’)
CS0161Error‘{0}’: not all code paths return a value
CS0162WarningUnreachable code detected
CS0163ErrorControl cannot fall through from one case label (‘{0}’) to another
CS0164WarningThis label has not been referenced
CS0165ErrorUse of unassigned local variable ‘{0}’
CS0168WarningThe variable ‘{0}’ is declared but never used
CS0169WarningThe field ‘{0}’ is never used
CS0170ErrorUse of possibly unassigned field ‘{0}’
CS0171ErrorField ‘{0}’ must be fully assigned before control is returned to the caller
CS0172ErrorType of conditional expression cannot be determined because ‘{0}’ and ‘{1}’ implicitly convert to one another
CS0173ErrorType of conditional expression cannot be determined because there is no implicit conversion between ‘{0}’ and ‘{1}’
CS0174ErrorA base class is required for a ‘base’ reference
CS0175ErrorUse of keyword ‘base’ is not valid in this context
CS0176ErrorMember ‘{0}’ cannot be accessed with an instance reference; qualify it with a type name instead
CS0177ErrorThe out parameter ‘{0}’ must be assigned to before control leaves the current method
CS0178ErrorInvalid rank specifier: expected ‘,’ or ‘]’
CS0179Error‘{0}’ cannot be extern and declare a body
CS0180Error‘{0}’ cannot be both extern and abstract
CS0181ErrorAttribute constructor parameter ‘{0}’ has type ‘{1}’, which is not a valid attribute parameter type
CS0182ErrorAn attribute argument must be a constant expression, typeof expression or array creation expression of an attribute parameter type
CS0183WarningThe given expression is always of the provided (‘{0}’) type
CS0184WarningThe given expression is never of the provided (‘{0}’) type
CS0185Error‘{0}’ is not a reference type as required by the lock statement
CS0186ErrorUse of null is not valid in this context
CS0188ErrorThe ‘this’ object cannot be used before all of its fields have been assigned
CS0190ErrorThe __arglist construct is valid only within a variable argument method
CS0191ErrorA readonly field cannot be assigned to (except in a constructor or init-only setter of the type in which the field is defined or a variable initializer)
CS0192ErrorA readonly field cannot be used as a ref or out value (except in a constructor)
CS0193ErrorThe * or -> operator must be applied to a pointer
CS0196ErrorA pointer must be indexed by only one value
CS0197WarningUsing ‘{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
CS0198ErrorA static readonly field cannot be assigned to (except in a static constructor or a variable initializer)
CS0199ErrorA static readonly field cannot be used as a ref or out value (except in a static constructor)
CS0200ErrorProperty or indexer ‘{0}’ cannot be assigned to — it is read only
CS0201ErrorOnly assignment, call, increment, decrement, await, and new object expressions can be used as a statement
CS0202Errorforeach requires that the return type ‘{0}’ of ‘{1}’ must have a suitable public ‘MoveNext’ method and public ‘Current’ property
CS0204ErrorOnly 65534 locals, including those generated by the compiler, are allowed
CS0205ErrorCannot call an abstract base member: ‘{0}’
CS0206ErrorA property or indexer may not be passed as an out or ref parameter
CS0208ErrorCannot take the address of, get the size of, or declare a pointer to a managed type (‘{0}’)
CS0209ErrorThe type of a local declared in a fixed statement must be a pointer type
CS0210ErrorYou must provide an initializer in a fixed or using statement declaration
CS0211ErrorCannot take the address of the given expression
CS0212ErrorYou can only take the address of an unfixed expression inside of a fixed statement initializer
CS0213ErrorYou cannot use the fixed statement to take the address of an already fixed expression
CS0214ErrorPointers and fixed size buffers may only be used in an unsafe context
CS0215ErrorThe return type of operator True or False must be bool
CS0216ErrorThe operator ‘{0}’ requires a matching operator ‘{1}’ to also be defined
CS0217ErrorIn order to be applicable as a short circuit operator a user-defined logical operator (‘{0}’) must have the same return type and parameter types
CS0218ErrorIn order for ‘{0}’ to be applicable as a short circuit operator, its declaring type ‘{1}’ must define operator true and operator false
CS0219WarningThe variable ‘{0}’ is assigned but its value is never used
CS0220ErrorThe operation overflows at compile time in checked mode
CS0221ErrorConstant value ‘{0}’ cannot be converted to a ‘{1}’ (use ‘unchecked’ syntax to override)
CS0224ErrorA method with vararg cannot be generic, be in a generic type, or have a params parameter
CS0225ErrorThe params parameter must be a single dimensional array
CS0226ErrorAn __arglist expression may only appear inside of a call or new expression
CS0227ErrorUnsafe code may only appear if compiling with /unsafe
CS0229ErrorAmbiguity between ‘{0}’ and ‘{1}’
CS0230ErrorType and identifier are both required in a foreach statement
CS0231ErrorA params parameter must be the last parameter in a formal parameter list
CS0233Error‘{0}’ does not have a predefined size, therefore sizeof can only be used in an unsafe context
CS0234ErrorThe type or namespace name ‘{0}’ does not exist in the namespace ‘{1}’ (are you missing an assembly reference?)
CS0236ErrorA field initializer cannot reference the non-static field, method, or property ‘{0}’
CS0238Error‘{0}’ cannot be sealed because it is not an override
CS0239Error‘{0}’: cannot override inherited member ‘{1}’ because it is sealed
CS0242ErrorThe operation in question is undefined on void pointers
CS0243ErrorThe Conditional attribute is not valid on ‘{0}’ because it is an override method
CS0244ErrorNeither ‘is’ nor ‘as’ is valid on pointer types
CS0245ErrorDestructors and object.Finalize cannot be called directly. Consider calling IDisposable.Dispose if available.
CS0246ErrorThe type or namespace name ‘{0}’ could not be found (are you missing a using directive or an assembly reference?)
CS0247ErrorCannot use a negative size with stackalloc
CS0248ErrorCannot create an array with a negative size
CS0249ErrorDo not override object.Finalize. Instead, provide a destructor.
CS0250ErrorDo not directly call your base type Finalize method. It is called automatically from your destructor.
CS0251WarningIndexing an array with a negative index (array indices always start at zero)
CS0252WarningPossible unintended reference comparison; to get a value comparison, cast the left hand side to type ‘{0}’
CS0253WarningPossible unintended reference comparison; to get a value comparison, cast the right hand side to type ‘{0}’
CS0254ErrorThe right hand side of a fixed statement assignment may not be a cast expression
CS0255Errorstackalloc may not be used in a catch or finally block
CS0257ErrorAn __arglist parameter must be the last parameter in a formal parameter list
CS0260ErrorMissing partial modifier on declaration of type ‘{0}’; another partial declaration of this type exists
CS0261ErrorPartial declarations of ‘{0}’ must be all classes, all record classes, all structs, all record structs, or all interfaces
CS0262ErrorPartial declarations of ‘{0}’ have conflicting accessibility modifiers
CS0263ErrorPartial declarations of ‘{0}’ must not specify different base classes
CS0264ErrorPartial declarations of ‘{0}’ must have the same type parameter names in the same order
CS0265ErrorPartial declarations of ‘{0}’ have inconsistent constraints for type parameter ‘{1}’
CS0266ErrorCannot implicitly convert type ‘{0}’ to ‘{1}’. An explicit conversion exists (are you missing a cast?)
CS0267ErrorThe ‘partial’ modifier can only appear immediately before ‘class’, ‘record’, ‘struct’, ‘interface’, or a method return type.
CS0268ErrorImported type ‘{0}’ is invalid. It contains a circular base type dependency.
CS0269ErrorUse of unassigned out parameter ‘{0}’
CS0270ErrorArray size cannot be specified in a variable declaration (try initializing with a ‘new’ expression)
CS0271ErrorThe property or indexer ‘{0}’ cannot be used in this context because the get accessor is inaccessible
CS0272ErrorThe property or indexer ‘{0}’ cannot be used in this context because the set accessor is inaccessible
CS0273ErrorThe accessibility modifier of the ‘{0}’ accessor must be more restrictive than the property or indexer ‘{1}’
CS0274ErrorCannot specify accessibility modifiers for both accessors of the property or indexer ‘{0}’
CS0276Error‘{0}’: accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor
CS0277Error‘{0}’ does not implement interface member ‘{1}’. ‘{2}’ is not public.
CS0278Warning‘{0}’ does not implement the ‘{1}’ pattern. ‘{2}’ is ambiguous with ‘{3}’.
CS0279Warning‘{0}’ does not implement the ‘{1}’ pattern. ‘{2}’ is not a public instance or extension method.
CS0280Warning‘{0}’ does not implement the ‘{1}’ pattern. ‘{2}’ has the wrong signature.
CS0281ErrorFriend access was granted by ‘{0}’, but the public key of the output assembly (‘{1}’) does not match that specified by the InternalsVisibleTo attribute in the granting assembly.
CS0282WarningThere 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.
CS0283ErrorThe type ‘{0}’ cannot be declared const
CS0304ErrorCannot create an instance of the variable type ‘{0}’ because it does not have the new() constraint
CS0305ErrorUsing the generic {1} ‘{0}’ requires {2} type arguments
CS0306ErrorThe type ‘{0}’ may not be used as a type argument
CS0307ErrorThe {1} ‘{0}’ cannot be used with type arguments
CS0308ErrorThe non-generic {1} ‘{0}’ cannot be used with type arguments
CS0310Error‘{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}’
CS0311ErrorThe 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}’.
CS0312ErrorThe 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}’.
CS0313ErrorThe 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.
CS0314ErrorThe 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}’.
CS0315ErrorThe 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}’.
CS0316ErrorThe parameter name ‘{0}’ conflicts with an automatically-generated parameter name
CS0400ErrorThe type or namespace name ‘{0}’ could not be found in the global namespace (are you missing an assembly reference?)
CS0401ErrorThe new() constraint must be the last constraint specified
CS0402Warning‘{0}’: an entry point cannot be generic or in a generic type
CS0403ErrorCannot convert null to type parameter ‘{0}’ because it could be a non-nullable value type. Consider using ‘default({0})’ instead.
CS0404ErrorCannot apply attribute class ‘{0}’ because it is generic
CS0405ErrorDuplicate constraint ‘{0}’ for type parameter ‘{1}’
CS0406ErrorThe class type constraint ‘{0}’ must come before any other constraints
CS0407Error‘{1} {0}’ has the wrong return type
CS0409ErrorA 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.
CS0411ErrorThe type arguments for method ‘{0}’ cannot be inferred from the usage. Try specifying the type arguments explicitly.
CS0412Error‘{0}’: a parameter, local variable, or local function cannot have the same name as a method type parameter
CS0413ErrorThe type parameter ‘{0}’ cannot be used with the ‘as’ operator because it does not have a class type constraint nor a ‘class’ constraint
CS0414WarningThe field ‘{0}’ is assigned but its value is never used
CS0415ErrorThe ‘{0}’ attribute is valid only on an indexer that is not an explicit interface member declaration
CS0416Error‘{0}’: an attribute argument cannot use type parameters
CS0417Error‘{0}’: cannot provide arguments when creating an instance of a variable type
CS0418Error‘{0}’: an abstract type cannot be sealed or static
CS0419WarningAmbiguous reference in cref attribute: ‘{0}’. Assuming ‘{1}’, but could have also matched other overloads including ‘{2}’.
CS0420Warning‘{0}’: a reference to a volatile field will not be treated as volatile
CS0423ErrorSince ‘{1}’ has the ComImport attribute, ‘{0}’ must be extern or abstract
CS0424Error‘{0}’: a class with the ComImport attribute cannot specify a base class
CS0425ErrorThe 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.
CS0426ErrorThe type name ‘{0}’ does not exist in the type ‘{1}’
CS0428ErrorCannot convert method group ‘{0}’ to non-delegate type ‘{1}’. Did you intend to invoke the method?
CS0430ErrorThe extern alias ‘{0}’ was not specified in a /reference option
CS0431ErrorCannot use alias ‘{0}’ with ‘::’ since the alias references a type. Use ‘.’ instead.
CS0432ErrorAlias ‘{0}’ not found
CS0433ErrorThe type ‘{1}’ exists in both ‘{0}’ and ‘{2}’
CS0434ErrorThe namespace ‘{1}’ in ‘{0}’ conflicts with the type ‘{3}’ in ‘{2}’
CS0435WarningThe namespace ‘{1}’ in ‘{0}’ conflicts with the imported type ‘{3}’ in ‘{2}’. Using the namespace defined in ‘{0}’.
CS0436WarningThe type ‘{1}’ in ‘{0}’ conflicts with the imported type ‘{3}’ in ‘{2}’. Using the type defined in ‘{0}’.
CS0437WarningThe type ‘{1}’ in ‘{0}’ conflicts with the imported namespace ‘{3}’ in ‘{2}’. Using the type defined in ‘{0}’.
CS0438ErrorThe type ‘{1}’ in ‘{0}’ conflicts with the namespace ‘{3}’ in ‘{2}’
CS0439ErrorAn extern alias declaration must precede all other elements defined in the namespace
CS0440WarningDefining an alias named ‘global’ is ill-advised since ‘global::’ always references the global namespace and not an alias
CS0441Error‘{0}’: a type cannot be both static and sealed
CS0442Error‘{0}’: abstract properties cannot have private accessors
CS0443ErrorSyntax error; value expected
CS0445ErrorCannot modify the result of an unboxing conversion
CS0446ErrorForeach cannot operate on a ‘{0}’. Did you intend to invoke the ‘{0}’?
CS0448ErrorThe return type for ++ or — operator must match the parameter type or be derived from the parameter type
CS0449ErrorThe ‘class’, ‘struct’, ‘unmanaged’, ‘notnull’, and ‘default’ constraints cannot be combined or duplicated, and must be specified first in the constraints list.
CS0450Error‘{0}’: cannot specify both a constraint class and the ‘class’ or ‘struct’ constraint
CS0451ErrorThe ‘new()’ constraint cannot be used with the ‘struct’ constraint
CS0452ErrorThe type ‘{2}’ must be a reference type in order to use it as parameter ‘{1}’ in the generic type or method ‘{0}’
CS0453ErrorThe type ‘{2}’ must be a non-nullable value type in order to use it as parameter ‘{1}’ in the generic type or method ‘{0}’
CS0454ErrorCircular constraint dependency involving ‘{0}’ and ‘{1}’
CS0455ErrorType parameter ‘{0}’ inherits conflicting constraints ‘{1}’ and ‘{2}’
CS0456ErrorType parameter ‘{1}’ has the ‘struct’ constraint so ‘{1}’ cannot be used as a constraint for ‘{0}’
CS0457ErrorAmbiguous user defined conversions ‘{0}’ and ‘{1}’ when converting from ‘{2}’ to ‘{3}’
CS0458WarningThe result of the expression is always ‘null’ of type ‘{0}’
CS0460ErrorConstraints for override and explicit interface implementation methods are inherited from the base method, so they cannot be specified directly, except for either a ‘class’, or a ‘struct’ constraint.
CS0462ErrorThe inherited members ‘{0}’ and ‘{1}’ have the same signature in type ‘{2}’, so they cannot be overridden
CS0463ErrorEvaluation of the decimal constant expression failed
CS0464WarningComparing with null of type ‘{0}’ always produces ‘false’
CS0465WarningIntroducing a ‘Finalize’ method can interfere with destructor invocation. Did you intend to declare a destructor?
CS0466Error‘{0}’ should not have a params parameter since ‘{1}’ does not
CS0469WarningThe ‘goto case’ value is not implicitly convertible to type ‘{0}’
CS0470ErrorMethod ‘{0}’ cannot implement interface accessor ‘{1}’ for type ‘{2}’. Use an explicit interface implementation.
CS0472WarningThe result of the expression is always ‘{0}’ since a value of type ‘{1}’ is never equal to ‘null’ of type ‘{2}’
CS0473WarningExplicit 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.
CS0500Error‘{0}’ cannot declare a body because it is marked abstract
CS0501Error‘{0}’ must declare a body because it is not marked abstract, extern, or partial
CS0502Error‘{0}’ cannot be both abstract and sealed
CS0503ErrorThe abstract {0} ‘{1}’ cannot be marked virtual
CS0504ErrorThe constant ‘{0}’ cannot be marked static
CS0505Error‘{0}’: cannot override because ‘{1}’ is not a function
CS0506Error‘{0}’: cannot override inherited member ‘{1}’ because it is not marked virtual, abstract, or override
CS0507Error‘{0}’: cannot change access modifiers when overriding ‘{1}’ inherited member ‘{2}’
CS0508Error‘{0}’: return type must be ‘{2}’ to match overridden member ‘{1}’
CS0509Error‘{0}’: cannot derive from sealed type ‘{1}’
CS0513Error‘{0}’ is abstract but it is contained in non-abstract type ‘{1}’
CS0514Error‘{0}’: static constructor cannot have an explicit ‘this’ or ‘base’ constructor call
CS0515Error‘{0}’: access modifiers are not allowed on static constructors
CS0516ErrorConstructor ‘{0}’ cannot call itself
CS0517Error‘{0}’ has no base class and cannot call a base constructor
CS0518ErrorPredefined type ‘{0}’ is not defined or imported
CS0522Error‘{0}’: structs cannot call base class constructors
CS0523ErrorStruct member ‘{0}’ of type ‘{1}’ causes a cycle in the struct layout
CS0525ErrorInterfaces cannot contain instance fields
CS0526ErrorInterfaces cannot contain instance constructors
CS0527ErrorType ‘{0}’ in interface list is not an interface
CS0528Error‘{0}’ is already listed in interface list
CS0529ErrorInherited interface ‘{1}’ causes a cycle in the interface hierarchy of ‘{0}’
CS0533Error‘{0}’ hides inherited abstract member ‘{1}’
CS0534Error‘{0}’ does not implement inherited abstract member ‘{1}’
CS0535Error‘{0}’ does not implement interface member ‘{1}’
CS0537ErrorThe class System.Object cannot have a base class or implement an interface
CS0538Error‘{0}’ in explicit interface declaration is not an interface
CS0539Error‘{0}’ in explicit interface declaration is not found among members of the interface that can be implemented
CS0540Error‘{0}’: containing type does not implement interface ‘{1}’
CS0541Error‘{0}’: explicit interface declaration can only be declared in a class, record, struct or interface
CS0542Error‘{0}’: member names cannot be the same as their enclosing type
CS0543Error‘{0}’: the enumerator value is too large to fit in its type
CS0544Error‘{0}’: cannot override because ‘{1}’ is not a property
CS0545Error‘{0}’: cannot override because ‘{1}’ does not have an overridable get accessor
CS0546Error‘{0}’: cannot override because ‘{1}’ does not have an overridable set accessor
CS0547Error‘{0}’: property or indexer cannot have void type
CS0548Error‘{0}’: property or indexer must have at least one accessor
CS0549Error‘{0}’ is a new virtual member in sealed type ‘{1}’
CS0550Error‘{0}’ adds an accessor not found in interface member ‘{1}’
CS0551ErrorExplicit interface implementation ‘{0}’ is missing accessor ‘{1}’
CS0552Error‘{0}’: user-defined conversions to or from an interface are not allowed
CS0553Error‘{0}’: user-defined conversions to or from a base type are not allowed
CS0554Error‘{0}’: user-defined conversions to or from a derived type are not allowed
CS0555ErrorUser-defined operator cannot convert a type to itself
CS0556ErrorUser-defined conversion must convert to or from the enclosing type
CS0557ErrorDuplicate user-defined conversion in type ‘{0}’
CS0558ErrorUser-defined operator ‘{0}’ must be declared static and public
CS0559ErrorThe parameter type for ++ or — operator must be the containing type
CS0562ErrorThe parameter of a unary operator must be the containing type
CS0563ErrorOne of the parameters of a binary operator must be the containing type
CS0564ErrorThe 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
CS0567ErrorConversion, equality, or inequality operators declared in interfaces must be abstract
CS0568ErrorStructs cannot contain explicit parameterless constructors
CS0569Error‘{0}’: cannot override ‘{1}’ because it is not supported by the language
CS0570Error‘{0}’ is not supported by the language
CS0571Error‘{0}’: cannot explicitly call operator or accessor
CS0572Error‘{0}’: cannot reference a type through an expression; try ‘{1}’ instead
CS0573Error‘{0}’: cannot have instance property or field initializers in structs
CS0574ErrorName of destructor must match name of type
CS0575ErrorOnly class types can contain destructors
CS0576ErrorNamespace ‘{1}’ contains a definition conflicting with alias ‘{0}’
CS0577ErrorThe Conditional attribute is not valid on ‘{0}’ because it is a constructor, destructor, operator, lambda expression, or explicit interface implementation
CS0578ErrorThe Conditional attribute is not valid on ‘{0}’ because its return type is not void
CS0579ErrorDuplicate ‘{0}’ attribute
CS0582ErrorThe Conditional attribute is not valid on interface members
CS0590ErrorUser-defined operators cannot return void
CS0591ErrorInvalid value for argument to ‘{0}’ attribute
CS0592ErrorAttribute ‘{0}’ is not valid on this declaration type. It is only valid on ‘{1}’ declarations.
CS0594ErrorFloating-point constant is outside the range of type ‘{0}’
CS0595ErrorInvalid real literal.
CS0596ErrorThe Guid attribute must be specified with the ComImport attribute
CS0599ErrorInvalid value for named attribute argument ‘{0}’
CS0601ErrorThe DllImport attribute must be specified on a method marked ‘static’ and ‘extern’
CS0610ErrorField or property cannot be of type ‘{0}’
CS0611ErrorArray elements cannot be of type ‘{0}’
CS0612Warning‘{0}’ is obsolete
CS0616Error‘{0}’ is not an attribute class
CS0617Error‘{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.
CS0618Warning‘{0}’ is obsolete: ‘{1}’
CS0619Error‘{0}’ is obsolete: ‘{1}’
CS0620ErrorIndexers cannot have void type
CS0621Error‘{0}’: virtual or abstract members cannot be private
CS0622ErrorCan only use array initializer expressions to assign to array types. Try using a new expression instead.
CS0623ErrorArray initializers can only be used in a variable or field initializer. Try using a new expression instead.
CS0625Error‘{0}’: instance field in types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute
CS0626WarningMethod, operator, or accessor ‘{0}’ is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation.
CS0628Warning‘{0}’: new protected member declared in sealed type
CS0629ErrorConditional member ‘{0}’ cannot implement interface member ‘{1}’ in type ‘{2}’
CS0630Error‘{0}’ cannot implement interface member ‘{1}’ in type ‘{2}’ because it has an __arglist parameter
CS0631Errorref and out are not valid in this context
CS0633ErrorThe argument to the ‘{0}’ attribute must be a valid identifier
CS0636ErrorThe FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit)
CS0637ErrorThe FieldOffset attribute is not allowed on static or const fields
CS0641ErrorAttribute ‘{0}’ is only valid on classes derived from System.Attribute
CS0642WarningPossible mistaken empty statement
CS0643Error‘{0}’ duplicate named attribute argument
CS0644Error‘{0}’ cannot derive from special class ‘{1}’
CS0646ErrorCannot specify the DefaultMember attribute on a type containing an indexer
CS0648Error‘{0}’ is a type not supported by the language
CS0649WarningField ‘{0}’ is never assigned to, and will always have its default value {1}
CS0650ErrorBad 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.
CS0652WarningComparison to integral constant is useless; the constant is outside the range of type ‘{0}’
CS0653ErrorCannot apply attribute class ‘{0}’ because it is abstract
CS0655Error‘{0}’ is not a valid named attribute argument because it is not a valid attribute parameter type
CS0656ErrorMissing compiler required member ‘{0}.{1}’
CS0657Warning‘{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.
CS0658Warning‘{0}’ is not a recognized attribute location. Valid attribute locations for this declaration are ‘{1}’. All attributes in this block will be ignored.
CS0659Warning‘{0}’ overrides Object.Equals(object o) but does not override Object.GetHashCode()
CS0660Warning‘{0}’ defines operator == or operator != but does not override Object.Equals(object o)
CS0661Warning‘{0}’ defines operator == or operator != but does not override Object.GetHashCode()
CS0662ErrorCannot specify the Out attribute on a ref parameter without also specifying the In attribute.
CS0663Error‘{0}’ cannot define an overloaded {1} that differs only on parameter modifiers ‘{2}’ and ‘{3}’
CS0664ErrorLiteral of type double cannot be implicitly converted to type ‘{1}’; use an ‘{0}’ suffix to create a literal of this type
CS0665WarningAssignment in conditional expression is always constant; did you mean to use == instead of = ?
CS0666Error‘{0}’: new protected member declared in struct
CS0668ErrorTwo indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type
CS0669ErrorA class with the ComImport attribute cannot have a user-defined constructor
CS0670ErrorField cannot have void type
CS0672WarningMember ‘{0}’ overrides obsolete member ‘{1}’. Add the Obsolete attribute to ‘{0}’.
CS0673ErrorSystem.Void cannot be used from C# — use typeof(void) to get the void type object
CS0674ErrorDo not use ‘System.ParamArrayAttribute’. Use the ‘params’ keyword instead.
CS0675WarningBitwise-or operator used on a sign-extended operand; consider casting to a smaller unsigned type first
CS0677Error‘{0}’: a volatile field cannot be of the type ‘{1}’
CS0678Error‘{0}’: a field cannot be both volatile and readonly
CS0681ErrorThe modifier ‘abstract’ is not valid on fields. Try using a property instead.
CS0682Error‘{0}’ cannot implement ‘{1}’ because it is not supported by the language
CS0683Error‘{0}’ explicit method implementation cannot implement ‘{1}’ because it is an accessor
CS0684Warning‘{0}’ interface marked with ‘CoClassAttribute’ not marked with ‘ComImportAttribute’
CS0685ErrorConditional member ‘{0}’ cannot have an out parameter
CS0686ErrorAccessor ‘{0}’ cannot implement interface member ‘{1}’ for type ‘{2}’. Use an explicit interface implementation.
CS0687ErrorThe namespace alias qualifier ‘::’ always resolves to a type or namespace so is illegal here. Consider using ‘.’ instead.
CS0689ErrorCannot derive from ‘{0}’ because it is a type parameter
CS0692ErrorDuplicate type parameter ‘{0}’
CS0693WarningType parameter ‘{0}’ has the same name as the type parameter from outer type ‘{1}’
CS0694ErrorType parameter ‘{0}’ has the same name as the containing type, or method
CS0695Error‘{0}’ cannot implement both ‘{1}’ and ‘{2}’ because they may unify for some type parameter substitutions
CS0698ErrorA generic type cannot derive from ‘{0}’ because it is an attribute class
CS0699Error‘{1}’ does not define type parameter ‘{0}’
CS0701Error‘{0}’ is not a valid constraint. A type used as a constraint must be an interface, a non-sealed class or a type parameter.
CS0702ErrorConstraint cannot be special class ‘{0}’
CS0703ErrorInconsistent accessibility: constraint type ‘{1}’ is less accessible than ‘{0}’
CS0704ErrorCannot do member lookup in ‘{0}’ because it is a type parameter
CS0706ErrorInvalid constraint type. A type used as a constraint must be an interface, a non-sealed class or a type parameter.
CS0708Error‘{0}’: cannot declare instance members in a static class
CS0709Error‘{1}’: cannot derive from static class ‘{0}’
CS0710ErrorStatic classes cannot have instance constructors
CS0711ErrorStatic classes cannot contain destructors
CS0712ErrorCannot create an instance of the static class ‘{0}’
CS0713ErrorStatic class ‘{0}’ cannot derive from type ‘{1}’. Static classes must derive from object.
CS0714Error‘{0}’: static classes cannot implement interfaces
CS0715Error‘{0}’: static classes cannot contain user-defined operators
CS0716ErrorCannot convert to static type ‘{0}’
CS0717Error‘{0}’: static classes cannot be used as constraints
CS0718Error‘{0}’: static types cannot be used as type arguments
CS0719Error‘{0}’: array elements cannot be of static type
CS0720Error‘{0}’: cannot declare indexers in a static class
CS0721Error‘{0}’: static types cannot be used as parameters
CS0722Error‘{0}’: static types cannot be used as return types
CS0723ErrorCannot declare a variable of static type ‘{0}’
CS0724ErrorA throw statement with no arguments is not allowed in a finally clause that is nested inside the nearest enclosing catch clause
CS0726Error‘{0}’ is not a valid format specifier
CS0728WarningPossibly 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.
CS0729ErrorType ‘{0}’ is defined in this assembly, but a type forwarder is specified for it
CS0730ErrorCannot forward type ‘{0}’ because it is a nested type of ‘{1}’
CS0731ErrorThe type forwarder for type ‘{0}’ in assembly ‘{1}’ causes a cycle
CS0734ErrorThe /moduleassemblyname option may only be specified when building a target type of ‘module’
CS0735ErrorInvalid type specified as an argument for TypeForwardedTo attribute
CS0736Error‘{0}’ does not implement instance interface member ‘{1}’. ‘{2}’ cannot implement the interface member because it is static.
CS0737Error‘{0}’ does not implement interface member ‘{1}’. ‘{2}’ cannot implement an interface member because it is not public.
CS0738Error‘{0}’ does not implement interface member ‘{1}’. ‘{2}’ cannot implement ‘{1}’ because it does not have the matching return type of ‘{3}’.
CS0739Error‘{0}’ duplicate TypeForwardedToAttribute
CS0742ErrorA query body must end with a select clause or a group clause
CS0743ErrorExpected contextual keyword ‘on’
CS0744ErrorExpected contextual keyword ‘equals’
CS0745ErrorExpected contextual keyword ‘by’
CS0746ErrorInvalid anonymous type member declarator. Anonymous type members must be declared with a member assignment, simple name or member access.
CS0747ErrorInvalid initializer member declarator
CS0748ErrorInconsistent lambda parameter usage; parameter types must be all explicit or all implicit
CS0750ErrorA partial method cannot have the ‘abstract’ modifier
CS0751ErrorA partial method must be declared within a partial type
CS0754ErrorA partial method may not explicitly implement an interface method
CS0755ErrorBoth partial method declarations must be extension methods or neither may be an extension method
CS0756ErrorA partial method may not have multiple defining declarations
CS0757ErrorA partial method may not have multiple implementing declarations
CS0758ErrorBoth partial method declarations must use a params parameter or neither may use a params parameter
CS0759ErrorNo defining declaration found for implementing declaration of partial method ‘{0}’
CS0761ErrorPartial method declarations of ‘{0}’ have inconsistent constraints for type parameter ‘{1}’
CS0762ErrorCannot create delegate from method ‘{0}’ because it is a partial method without an implementing declaration
CS0763ErrorBoth partial method declarations must be static or neither may be static
CS0764ErrorBoth partial method declarations must be unsafe or neither may be unsafe
CS0765ErrorPartial methods with only a defining declaration or removed conditional methods cannot be used in expression trees
CS0767ErrorCannot inherit interface ‘{0}’ with the specified type parameters because it causes method ‘{1}’ to contain overloads which differ only on ref and out
CS0768ErrorConstructor ‘{0}’ cannot call itself through another constructor
CS0809WarningObsolete member ‘{0}’ overrides non-obsolete member ‘{1}’
CS0811WarningThe fully qualified name for ‘{0}’ is too long for debug information. Compile without ‘/debug’ option.
CS0815ErrorCannot assign {0} to an implicitly-typed variable
CS0818ErrorImplicitly-typed variables must be initialized
CS0819ErrorImplicitly-typed variables cannot have multiple declarators
CS0820ErrorCannot initialize an implicitly-typed variable with an array initializer
CS0821ErrorImplicitly-typed local variables cannot be fixed
CS0822ErrorImplicitly-typed variables cannot be constant
CS0824WarningConstructor ‘{0}’ is marked external
CS0825ErrorThe contextual keyword ‘var’ may only appear within a local variable declaration or in script code
CS0826ErrorNo best type found for implicitly-typed array
CS0828ErrorCannot assign ‘{0}’ to anonymous type property
CS0831ErrorAn expression tree may not contain a base access
CS0832ErrorAn expression tree may not contain an assignment operator
CS0833ErrorAn anonymous type cannot have multiple properties with the same name
CS0834ErrorA lambda expression with a statement body cannot be converted to an expression tree
CS0835ErrorCannot convert lambda to an expression tree whose type argument ‘{0}’ is not a delegate type
CS0836ErrorCannot use anonymous type in a constant expression
CS0837ErrorThe first operand of an ‘is’ or ‘as’ operator may not be a lambda expression, anonymous method, or method group.
CS0838ErrorAn expression tree may not contain a multidimensional array initializer
CS0839ErrorArgument missing
CS0841ErrorCannot use local variable ‘{0}’ before it is declared
CS0843ErrorAuto-implemented property ‘{0}’ must be fully assigned before control is returned to the caller.
CS0844ErrorCannot use local variable ‘{0}’ before it is declared. The declaration of the local variable hides the field ‘{1}’.
CS0845ErrorAn expression tree lambda may not contain a coalescing operator with a null or default literal left-hand side
CS0846ErrorA nested array initializer is expected
CS0847ErrorAn array initializer of length ‘{0}’ is expected
CS0853ErrorAn expression tree may not contain a named argument specification
CS0854ErrorAn expression tree may not contain a call or invocation that uses optional arguments
CS0855ErrorAn expression tree may not contain an indexed property
CS0856ErrorIndexed property ‘{0}’ has non-optional arguments which must be provided
CS0857ErrorIndexed property ‘{0}’ must have all arguments optional
CS1001ErrorIdentifier expected
CS1002Error; expected
CS1003ErrorSyntax error, ‘{0}’ expected
CS1004ErrorDuplicate ‘{0}’ modifier
CS1007ErrorProperty accessor already defined
CS1008ErrorType byte, sbyte, short, ushort, int, uint, long, or ulong expected
CS1009ErrorUnrecognized escape sequence
CS1010ErrorNewline in constant
CS1011ErrorEmpty character literal
CS1012ErrorToo many characters in character literal
CS1013ErrorInvalid number
CS1014ErrorA get or set accessor expected
CS1015ErrorAn object, string, or class type expected
CS1016ErrorNamed attribute argument expected
CS1017ErrorCatch clauses cannot follow the general catch clause of a try statement
CS1018ErrorKeyword ‘this’ or ‘base’ expected
CS1019ErrorOverloadable unary operator expected
CS1020ErrorOverloadable binary operator expected
CS1021ErrorIntegral constant is too large
CS1022ErrorType or namespace definition, or end-of-file expected
CS1023ErrorEmbedded statement cannot be a declaration or labeled statement
CS1024ErrorPreprocessor directive expected
CS1025ErrorSingle-line comment or end-of-line expected
CS1026Error) expected
CS1027Error#endif directive expected
CS1028ErrorUnexpected preprocessor directive
CS1029Error#error: ‘{0}’
CS1030Warning#warning: ‘{0}’
CS1031ErrorType expected
CS1032ErrorCannot define/undefine preprocessor symbols after first token in file
CS1035ErrorEnd-of-file found, ‘*/’ expected
CS1037ErrorOverloadable operator expected
CS1038Error#endregion directive expected
CS1039ErrorUnterminated string literal
CS1040ErrorPreprocessor directives must appear as the first non-whitespace character on a line
CS1041ErrorIdentifier expected; ‘{1}’ is a keyword
CS1043Error{ or ; expected
CS1044ErrorCannot use more than one type in a for, using, fixed, or declaration statement
CS1055ErrorAn add or remove accessor expected
CS1056ErrorUnexpected character ‘{0}’
CS1057Error‘{0}’: static classes cannot contain protected members
CS1058WarningA previous catch clause already catches all exceptions. All non-exceptions thrown will be wrapped in a System.Runtime.CompilerServices.RuntimeWrappedException.
CS1059ErrorThe operand of an increment or decrement operator must be a variable, property or indexer
CS1061Error‘{0}’ does not contain a definition for ‘{1}’ and no accessible extension method ‘{1}’ accepting a first argument of type ‘{0}’ could be found (are you missing a using directive or an assembly reference?)
CS1062WarningThe best overloaded Add method ‘{0}’ for the collection initializer element is obsolete. {1}
CS1063ErrorThe best overloaded Add method ‘{0}’ for the collection initializer element is obsolete. {1}
CS1064WarningThe best overloaded Add method ‘{0}’ for the collection initializer element is obsolete.
CS1065ErrorDefault values are not valid in this context.
CS1066WarningThe 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
CS1067ErrorPartial declarations of ‘{0}’ must have the same type parameter names and variance modifiers in the same order
CS1068ErrorThe 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.
CS1069ErrorThe 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.
CS1070ErrorThe type name ‘{0}’ could not be found. This type has been forwarded to assembly ‘{1}’. Consider adding a reference to that assembly.
CS1072WarningExpected identifier or numeric literal.
CS1073ErrorUnexpected token ‘{0}’
CS1100ErrorMethod ‘{0}’ has a parameter modifier ‘this’ which is not on the first parameter
CS1103ErrorThe first parameter of an extension method cannot be of type ‘{0}’
CS1104ErrorA parameter array cannot be used with ‘this’ modifier on an extension method
CS1105ErrorExtension method must be static
CS1106ErrorExtension method must be defined in a non-generic static class
CS1107ErrorA parameter can only have one ‘{0}’ modifier
CS1109ErrorExtension methods must be defined in a top level static class; {0} is a nested class
CS1110ErrorCannot define a new extension method because the compiler required type ‘{0}’ cannot be found. Are you missing a reference to System.Core.dll?
CS1112ErrorDo not use ‘System.Runtime.CompilerServices.ExtensionAttribute’. Use the ‘this’ keyword instead.
CS1113ErrorExtension method ‘{0}’ defined on value type ‘{1}’ cannot be used to create delegates
CS1501ErrorNo overload for method ‘{0}’ takes {1} arguments
CS1503ErrorArgument {0}: cannot convert from ‘{1}’ to ‘{2}’
CS1504ErrorSource file ‘{0}’ could not be opened — {1}
CS1507ErrorCannot link resource files when building a module
CS1508ErrorResource identifier ‘{0}’ has already been used in this assembly
CS1509ErrorThe referenced file ‘{0}’ is not an assembly
CS1510ErrorA ref or out value must be an assignable variable
CS1511ErrorKeyword ‘base’ is not available in a static method
CS1512ErrorKeyword ‘base’ is not available in the current context
CS1513Error} expected
CS1514Error{ expected
CS1515Error‘in’ expected
CS1517ErrorInvalid preprocessor expression
CS1519ErrorInvalid token ‘{0}’ in class, record, struct, or interface member declaration
CS1520ErrorMethod must have a return type
CS1521ErrorInvalid base type
CS1522WarningEmpty switch block
CS1524ErrorExpected catch or finally
CS1525ErrorInvalid expression term ‘{0}’
CS1526ErrorA new expression requires an argument list or (), [], or {} after type
CS1527ErrorElements defined in a namespace cannot be explicitly declared as private, protected, protected internal, or private protected
CS1528ErrorExpected ; or = (cannot specify constructor arguments in declaration)
CS1529ErrorA using clause must precede all other elements defined in the namespace except extern alias declarations
CS1534ErrorOverloaded binary operator ‘{0}’ takes two parameters
CS1535ErrorOverloaded unary operator ‘{0}’ takes one parameter
CS1536ErrorInvalid parameter type ‘void’
CS1537ErrorThe using alias ‘{0}’ appeared previously in this namespace
CS1540ErrorCannot access protected member ‘{0}’ via a qualifier of type ‘{1}’; the qualifier must be of type ‘{2}’ (or derived from it)
CS1542Error‘{0}’ cannot be added to this assembly because it already is an assembly
CS1545ErrorProperty, indexer, or event ‘{0}’ is not supported by the language; try directly calling accessor methods ‘{1}’ or ‘{2}’
CS1546ErrorProperty, indexer, or event ‘{0}’ is not supported by the language; try directly calling accessor method ‘{1}’
CS1547ErrorKeyword ‘void’ cannot be used in this context
CS1551ErrorIndexers must have at least one parameter
CS1552ErrorArray type specifier, [], must appear before parameter name
CS1553ErrorDeclaration is not valid; use ‘{0} operator (…’ instead
CS1555ErrorCould not find ‘{0}’ specified for Main method
CS1556Error‘{0}’ specified for Main method must be a non-generic class, record, struct, or interface
CS1558Error‘{0}’ does not have a suitable static ‘Main’ method
CS1562ErrorOutputs without source must have the /out option specified
CS1564ErrorConflicting options specified: Win32 resource file; Win32 manifest
CS1565ErrorConflicting options specified: Win32 resource file; Win32 icon
CS1566ErrorError reading resource ‘{0}’ — ‘{1}’
CS1569ErrorError writing to XML documentation file: {0}
CS1570WarningXML comment has badly formed XML — ‘{0}’
CS1571WarningXML comment has a duplicate param tag for ‘{0}’
CS1572WarningXML comment has a param tag for ‘{0}’, but there is no parameter by that name
CS1573WarningParameter ‘{0}’ has no matching param tag in the XML comment for ‘{1}’ (but other parameters do)
CS1574WarningXML comment has cref attribute ‘{0}’ that could not be resolved
CS1575ErrorA stackalloc expression requires [] after type
CS1576ErrorThe line number specified for #line directive is missing or invalid
CS1578ErrorQuoted file name, single-line comment or end-of-line expected
CS1579Errorforeach statement cannot operate on variables of type ‘{0}’ because ‘{0}’ does not contain a public instance or extension definition for ‘{1}’
CS1580WarningInvalid type for parameter {0} in XML comment cref attribute: ‘{1}’
CS1581WarningInvalid return type in XML comment cref attribute
CS1583ErrorError reading Win32 resources — {0}
CS1584WarningXML comment has syntactically incorrect cref attribute ‘{0}’
CS1585ErrorMember modifier ‘{0}’ must precede the member type and name
CS1586ErrorArray creation must have array size or array initializer
CS1587WarningXML comment is not placed on a valid language element
CS1589WarningUnable to include XML fragment ‘{1}’ of file ‘{0}’ — {2}
CS1590WarningInvalid XML include element — {0}
CS1591WarningMissing XML comment for publicly visible type or member ‘{0}’
CS1592WarningBadly formed XML in included comments file — ‘{0}’
CS1593ErrorDelegate ‘{0}’ does not take {1} arguments
CS1597ErrorSemicolon after method or accessor block is not valid
CS1599ErrorThe return type of a method, delegate, or function pointer cannot be ‘{0}’
CS1600ErrorCompilation cancelled by user
CS1601ErrorCannot make reference to variable of type ‘{0}’
CS1604ErrorCannot assign to ‘{0}’ because it is read-only
CS1605ErrorCannot use ‘{0}’ as a ref or out value because it is read-only
CS1607Warning
CS1608ErrorThe RequiredAttribute attribute is not permitted on C# types
CS1609ErrorModifiers cannot be placed on event accessor declarations
CS1611ErrorThe params parameter cannot be declared as {0}
CS1612ErrorCannot modify the return value of ‘{0}’ because it is not a variable
CS1613ErrorThe managed coclass wrapper class ‘{0}’ for interface ‘{1}’ cannot be found (are you missing an assembly reference?)
CS1614Error‘{0}’ is ambiguous between ‘{1}’ and ‘{2}’; use either ‘@{0}’ or ‘{0}Attribute’
CS1615ErrorArgument {0} may not be passed with the ‘{1}’ keyword
CS1616WarningOption ‘{0}’ overrides attribute ‘{1}’ given in a source file or added module
CS1617ErrorInvalid option ‘{0}’ for /langversion. Use ‘/langversion:?’ to list supported values.
CS1618ErrorCannot create delegate with ‘{0}’ because it or a method it overrides has a Conditional attribute
CS1619ErrorCannot create temporary file — {0}
CS1620ErrorArgument {0} must be passed with the ‘{1}’ keyword
CS1621ErrorThe yield statement cannot be used inside an anonymous method or lambda expression
CS1622ErrorCannot return a value from an iterator. Use the yield return statement to return a value, or yield break to end the iteration.
CS1623ErrorIterators cannot have ref, in or out parameters
CS1624ErrorThe body of ‘{0}’ cannot be an iterator block because ‘{1}’ is not an iterator interface type
CS1625ErrorCannot yield in the body of a finally clause
CS1626ErrorCannot yield a value in the body of a try block with a catch clause
CS1627ErrorExpression expected after yield return
CS1628ErrorCannot use ref, out, or in parameter ‘{0}’ inside an anonymous method, lambda expression, query expression, or local function
CS1629ErrorUnsafe code may not appear in iterators
CS1631ErrorCannot yield a value in the body of a catch clause
CS1632ErrorControl cannot leave the body of an anonymous method or lambda expression
CS1633WarningUnrecognized #pragma directive
CS1634WarningExpected ‘disable’ or ‘restore’
CS1635WarningCannot restore warning ‘CS{0}’ because it was disabled globally
CS1636Error__arglist is not allowed in the parameter list of iterators
CS1637ErrorIterators cannot have unsafe parameters or yield types
CS1639ErrorThe managed coclass wrapper class signature ‘{0}’ for interface ‘{1}’ is not a valid class name signature
CS1640Errorforeach statement cannot operate on variables of type ‘{0}’ because it implements multiple instantiations of ‘{1}’; try casting to a specific interface instantiation
CS1641ErrorA fixed size buffer field must have the array size specifier after the field name
CS1642ErrorFixed size buffer fields may only be members of structs
CS1643ErrorNot all code paths return a value in {0} of type ‘{1}’
CS1645WarningFeature ‘{0}’ is not part of the standardized ISO C# language specification, and may not be accepted by other compilers
CS1646ErrorKeyword, identifier, or string expected after verbatim specifier: @
CS1648ErrorMembers of readonly field ‘{0}’ cannot be modified (except in a constructor or a variable initializer)
CS1649ErrorMembers of readonly field ‘{0}’ cannot be used as a ref or out value (except in a constructor)
CS1650ErrorFields of static readonly field ‘{0}’ cannot be assigned to (except in a static constructor or a variable initializer)
CS1651ErrorFields of static readonly field ‘{0}’ cannot be used as a ref or out value (except in a static constructor)
CS1654ErrorCannot modify members of ‘{0}’ because it is a ‘{1}’
CS1655ErrorCannot use fields of ‘{0}’ as a ref or out value because it is a ‘{1}’
CS1656ErrorCannot assign to ‘{0}’ because it is a ‘{1}’
CS1657ErrorCannot use ‘{0}’ as a ref or out value because it is a ‘{1}’
CS1658Warning{0}. See also error CS{1}.
CS1660ErrorCannot convert {0} to type ‘{1}’ because it is not a delegate type
CS1661ErrorCannot convert {0} to type ‘{1}’ because the parameter types do not match the delegate parameter types
CS1662ErrorCannot convert {0} to intended delegate type because some of the return types in the block are not implicitly convertible to the delegate return type
CS1663ErrorFixed size buffer type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double
CS1664ErrorFixed size buffer of length {0} and type ‘{1}’ is too big
CS1665ErrorFixed size buffers must have a length greater than zero
CS1666ErrorYou cannot use fixed size buffers contained in unfixed expressions. Try using the fixed statement.
CS1667ErrorAttribute ‘{0}’ is not valid on property or event accessors. It is only valid on ‘{1}’ declarations.
CS1668WarningInvalid search path ‘{0}’ specified in ‘{1}’ — ‘{2}’
CS1669Error__arglist is not valid in this context
CS1670Errorparams is not valid in this context
CS1671ErrorA namespace declaration cannot have modifiers or attributes
CS1672ErrorInvalid option ‘{0}’ for /platform; must be anycpu, x86, Itanium, arm, arm64 or x64
CS1673ErrorAnonymous methods, lambda expressions, query expressions, and local functions inside structs cannot access instance members of ‘this’. Consider copying ‘this’ to a local variable outside the anonymous method, lambda expression, query expression, or local function and using the local instead.
CS1674Error‘{0}’: type used in a using statement must be implicitly convertible to ‘System.IDisposable’.
CS1676ErrorParameter {0} must be declared with the ‘{1}’ keyword
CS1677ErrorParameter {0} should not be declared with the ‘{1}’ keyword
CS1678ErrorParameter {0} is declared as type ‘{1}{2}’ but should be ‘{3}{4}’
CS1679ErrorInvalid extern alias for ‘/reference’; ‘{0}’ is not a valid identifier
CS1680ErrorInvalid reference alias option: ‘{0}=’ — missing filename
CS1681ErrorYou cannot redefine the global extern alias
CS1685WarningThe predefined type ‘{0}’ is defined in multiple assemblies in the global alias; using definition from ‘{1}’
CS1686ErrorLocal ‘{0}’ or its members cannot have their address taken and be used inside an anonymous method or lambda expression
CS1687WarningSource file has exceeded the limit of 16,707,565 lines representable in the PDB; debug information will be incorrect
CS1688ErrorCannot convert anonymous method block without a parameter list to delegate type ‘{0}’ because it has one or more out parameters
CS1689ErrorAttribute ‘{0}’ is only valid on methods or attribute classes
CS1690WarningAccessing a member on ‘{0}’ may cause a runtime exception because it is a field of a marshal-by-reference class
CS1692WarningInvalid number
CS1695WarningInvalid #pragma checksum syntax; should be #pragma checksum “filename” “{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}” “XXXX…”
CS1696WarningSingle-line comment or end-of-line expected
CS1697WarningDifferent checksum values given for ‘{0}’
CS1700WarningAssembly reference ‘{0}’ is invalid and cannot be resolved
CS1701WarningAssuming assembly reference ‘{0}’ used by ‘{1}’ matches identity ‘{2}’ of ‘{3}’, you may need to supply runtime policy
CS1702WarningAssuming assembly reference ‘{0}’ used by ‘{1}’ matches identity ‘{2}’ of ‘{3}’, you may need to supply runtime policy
CS1703ErrorMultiple assemblies with equivalent identity have been imported: ‘{0}’ and ‘{1}’. Remove one of the duplicate references.
CS1704ErrorAn 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.
CS1705ErrorAssembly ‘{0}’ with identity ‘{1}’ uses ‘{2}’ which has a higher version than referenced assembly ‘{3}’ with identity ‘{4}’
CS1708ErrorFixed size buffers can only be accessed through locals or fields
CS1710WarningXML comment has a duplicate typeparam tag for ‘{0}’
CS1711WarningXML comment has a typeparam tag for ‘{0}’, but there is no type parameter by that name
CS1712WarningType parameter ‘{0}’ has no matching typeparam tag in the XML comment on ‘{1}’ (but other type parameters do)
CS1715Error‘{0}’: type must be ‘{2}’ to match overridden member ‘{1}’
CS1716ErrorDo not use ‘System.Runtime.CompilerServices.FixedBuffer’ attribute. Use the ‘fixed’ field modifier instead.
CS1717WarningAssignment made to same variable; did you mean to assign something else?
CS1718WarningComparison made to same variable; did you mean to compare something else?
CS1719ErrorError opening Win32 resource file ‘{0}’ — ‘{1}’
CS1720WarningExpression will always cause a System.NullReferenceException because the default value of ‘{0}’ is null
CS1721ErrorClass ‘{0}’ cannot have multiple base classes: ‘{1}’ and ‘{2}’
CS1722ErrorBase class ‘{0}’ must come before any interfaces
CS1723WarningXML comment has cref attribute ‘{0}’ that refers to a type parameter
CS1725ErrorFriend assembly reference ‘{0}’ is invalid. InternalsVisibleTo declarations cannot have a version, culture, public key token, or processor architecture specified.
CS1726ErrorFriend assembly reference ‘{0}’ is invalid. Strong-name signed assemblies must specify a public key in their InternalsVisibleTo declarations.
CS1728ErrorCannot bind delegate to ‘{0}’ because it is a member of ‘System.Nullable’
CS1729Error‘{0}’ does not contain a constructor that takes {1} arguments
CS1730ErrorAssembly and module attributes must precede all other elements defined in a file except using clauses and extern alias declarations
CS1733ErrorExpected expression
CS1734WarningXML comment on ‘{1}’ has a paramref tag for ‘{0}’, but there is no parameter by that name
CS1735WarningXML comment on ‘{1}’ has a typeparamref tag for ‘{0}’, but there is no type parameter by that name
CS1736ErrorDefault parameter value for ‘{0}’ must be a compile-time constant
CS1737ErrorOptional parameters must appear after all required parameters
CS1738ErrorNamed argument specifications must appear after all fixed arguments have been specified. Please use language version {0} or greater to allow non-trailing named arguments.
CS1739ErrorThe best overload for ‘{0}’ does not have a parameter named ‘{1}’
CS1740ErrorNamed argument ‘{0}’ cannot be specified multiple times
CS1741ErrorA ref or out parameter cannot have a default value
CS1742ErrorAn array access may not have a named argument specifier
CS1743ErrorCannot specify a default value for the ‘this’ parameter
CS1744ErrorNamed argument ‘{0}’ specifies a parameter for which a positional argument has already been given
CS1745ErrorCannot specify default parameter value in conjunction with DefaultParameterAttribute or OptionalAttribute
CS1746ErrorThe delegate ‘{0}’ does not have a parameter named ‘{1}’
CS1747ErrorCannot embed interop types from assembly ‘{0}’ because it is missing the ‘{1}’ attribute.
CS1748ErrorCannot find the interop type that matches the embedded interop type ‘{0}’. Are you missing an assembly reference?
CS1750ErrorA value of type ‘{0}’ cannot be used as a default parameter because there are no standard conversions to type ‘{1}’
CS1751ErrorCannot specify a default value for a parameter array
CS1752ErrorInterop type ‘{0}’ cannot be embedded. Use the applicable interface instead.
CS1754ErrorType ‘{0}’ cannot be embedded because it is a nested type. Consider setting the ‘Embed Interop Types’ property to false.
CS1756ErrorInterop type ‘{0}’ cannot be embedded because it is missing the required ‘{1}’ attribute.
CS1757ErrorEmbedded interop struct ‘{0}’ can contain only public instance fields.
CS1758ErrorCannot embed interop type ‘{0}’ found in both assembly ‘{1}’ and ‘{2}’. Consider setting the ‘Embed Interop Types’ property to false.
CS1759ErrorCannot embed interop types from assembly ‘{0}’ because it is missing either the ‘{1}’ attribute or the ‘{2}’ attribute.
CS1760ErrorAssemblies ‘{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.
CS1761ErrorEmbedding the interop type ‘{0}’ from assembly ‘{1}’ causes a name clash in the current assembly. Consider setting the ‘Embed Interop Types’ property to false.
CS1762WarningA 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.
CS1763Error‘{0}’ is of type ‘{1}’. A default parameter value of a reference type other than string can only be initialized with null
CS1764ErrorCannot use fixed local ‘{0}’ inside an anonymous method, lambda expression, or query expression
CS1766ErrorSource interface ‘{0}’ is missing method ‘{1}’ which is required to embed event ‘{2}’.
CS1767ErrorInterface ‘{0}’ has an invalid source interface which is required to embed event ‘{1}’.
CS1768ErrorType ‘{0}’ cannot be embedded because it has a generic argument. Consider setting the ‘Embed Interop Types’ property to false.
CS1769ErrorType ‘{0}’ from assembly ‘{1}’ cannot be used across assembly boundaries because it has a generic type argument that is an embedded interop type.
CS1770ErrorA value of type ‘{0}’ cannot be used as default parameter for nullable parameter ‘{1}’ because ‘{0}’ is not a simple type
CS1773ErrorInvalid version {0} for /subsystemversion. The version must be 6.02 or greater for ARM or AppContainerExe, and 4.00 or greater otherwise
CS1774ErrorEmbedded interop method ‘{0}’ contains a body.
CS1900ErrorWarning level must be zero or greater
CS1902ErrorInvalid option ‘{0}’ for /debug; must be ‘portable’, ’embedded’, ‘full’ or ‘pdbonly’
CS1906ErrorInvalid option ‘{0}’; Resource visibility must be either ‘public’ or ‘private’
CS1908ErrorThe type of the argument to the DefaultParameterValue attribute must match the parameter type
CS1910ErrorArgument of type ‘{0}’ is not applicable for the DefaultParameterValue attribute
CS1912ErrorDuplicate initialization of member ‘{0}’
CS1913ErrorMember ‘{0}’ cannot be initialized. It is not a field or property.
CS1914ErrorStatic field or property ‘{0}’ cannot be assigned in an object initializer
CS1917ErrorMembers of readonly field ‘{0}’ of type ‘{1}’ cannot be assigned with an object initializer because it is of a value type
CS1918ErrorMembers of property ‘{0}’ of type ‘{1}’ cannot be assigned with an object initializer because it is of a value type
CS1919ErrorUnsafe type ‘{0}’ cannot be used in object creation
CS1920ErrorElement initializer cannot be empty
CS1921ErrorThe best overloaded method match for ‘{0}’ has wrong signature for the initializer element. The initializable Add must be an accessible instance method.
CS1922ErrorCannot initialize type ‘{0}’ with a collection initializer because it does not implement ‘System.Collections.IEnumerable’
CS1926ErrorError opening Win32 manifest file {0} — {1}
CS1927WarningIgnoring /win32manifest for module because it only applies to assemblies
CS1929Error‘{0}’ does not contain a definition for ‘{1}’ and the best extension method overload ‘{2}’ requires a receiver of type ‘{3}’
CS1930ErrorThe range variable ‘{0}’ has already been declared
CS1931ErrorThe range variable ‘{0}’ conflicts with a previous declaration of ‘{0}’
CS1932ErrorCannot assign {0} to a range variable
CS1934ErrorCould 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}’.
CS1935ErrorCould not find an implementation of the query pattern for source type ‘{0}’. ‘{1}’ not found. Are you missing required assembly references or a using directive for ‘System.Linq’?
CS1936ErrorCould not find an implementation of the query pattern for source type ‘{0}’. ‘{1}’ not found.
CS1937ErrorThe name ‘{0}’ is not in scope on the left side of ‘equals’. Consider swapping the expressions on either side of ‘equals’.
CS1938ErrorThe name ‘{0}’ is not in scope on the right side of ‘equals’. Consider swapping the expressions on either side of ‘equals’.
CS1939ErrorCannot pass the range variable ‘{0}’ as an out or ref parameter
CS1940ErrorMultiple implementations of the query pattern were found for source type ‘{0}’. Ambiguous call to ‘{1}’.
CS1941ErrorThe type of one of the expressions in the {0} clause is incorrect. Type inference failed in the call to ‘{1}’.
CS1942ErrorThe type of the expression in the {0} clause is incorrect. Type inference failed in the call to ‘{1}’.
CS1943ErrorAn 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}’.
CS1944ErrorAn expression tree may not contain an unsafe pointer operation
CS1945ErrorAn expression tree may not contain an anonymous method expression
CS1946ErrorAn anonymous method expression cannot be converted to an expression tree
CS1947ErrorRange variable ‘{0}’ cannot be assigned to — it is read only
CS1948ErrorThe range variable ‘{0}’ cannot have the same name as a method type parameter
CS1949ErrorThe contextual keyword ‘var’ cannot be used in a range variable declaration
CS1950ErrorThe best overloaded Add method ‘{0}’ for the collection initializer has some invalid arguments
CS1951ErrorAn expression tree lambda may not contain a ref, in or out parameter
CS1952ErrorAn expression tree lambda may not contain a method with variable arguments
CS1954ErrorThe best overloaded method match ‘{0}’ for the collection initializer element cannot be used. Collection initializer ‘Add’ methods cannot have ref or out parameters.
CS1955ErrorNon-invocable member ‘{0}’ cannot be used like a method.
CS1956WarningMember ‘{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.
CS1957WarningMember ‘{1}’ overrides ‘{0}’. There are multiple override candidates at run-time. It is implementation dependent which method will be called. Please use a newer runtime.
CS1958ErrorObject and collection initializer expressions may not be applied to a delegate creation expression
CS1959Error‘{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.
CS1960ErrorInvalid variance modifier. Only interface and delegate type parameters can be specified as variant.
CS1961ErrorInvalid variance: The type parameter ‘{1}’ must be {3} valid on ‘{0}’. ‘{1}’ is {2}.
CS1962ErrorThe typeof operator cannot be used on the dynamic type
CS1963ErrorAn expression tree may not contain a dynamic operation
CS1964Error‘{0}’: user-defined conversions to or from the dynamic type are not allowed
CS1965Error‘{0}’: cannot derive from the dynamic type
CS1966Error‘{0}’: cannot implement a dynamic interface ‘{1}’
CS1967ErrorConstraint cannot be the dynamic type
CS1968ErrorConstraint cannot be a dynamic type ‘{0}’
CS1969ErrorOne or more types required to compile a dynamic expression cannot be found. Are you missing a reference?
CS1970ErrorDo not use ‘System.Runtime.CompilerServices.DynamicAttribute’. Use the ‘dynamic’ keyword instead.
CS1971ErrorThe 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.
CS1972ErrorThe 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.
CS1973Error‘{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.
CS1974WarningThe dynamically dispatched call to method ‘{0}’ may fail at runtime because one or more applicable overloads are conditional methods.
CS1975ErrorThe constructor call needs to be dynamically dispatched, but cannot be because it is part of a constructor initializer. Consider casting the dynamic arguments.
CS1976ErrorCannot use a method group as an argument to a dynamically dispatched operation. Did you intend to invoke the method?
CS1977ErrorCannot use a lambda expression as an argument to a dynamically dispatched operation without first casting it to a delegate or expression tree type.
CS1978ErrorCannot use an expression of type ‘{0}’ as an argument to a dynamically dispatched operation.
CS1979ErrorQuery expressions over source type ‘dynamic’ or with a join sequence of type ‘dynamic’ are not allowed
CS1980ErrorCannot define a class or member that utilizes ‘dynamic’ because the compiler required type ‘{0}’ cannot be found. Are you missing a reference?
CS1981WarningUsing ‘{0}’ to test compatibility with ‘{1}’ is essentially identical to testing compatibility with ‘{2}’ and will succeed for all non-null values
CS1983ErrorThe return type of an async method must be void, Task, Task, a task-like type, IAsyncEnumerable, or IAsyncEnumerator
CS1984ErrorCannot await in the body of a finally clause
CS1985ErrorCannot await in a catch clause
CS1986Error‘await’ requires that the type {0} have a suitable ‘GetAwaiter’ method
CS1988ErrorAsync methods cannot have ref, in or out parameters
CS1989ErrorAsync lambda expressions cannot be converted to expression trees
CS1991Error‘{0}’ cannot implement ‘{1}’ because ‘{2}’ is a Windows Runtime event and ‘{3}’ is a regular .NET event.
CS1992ErrorThe ‘await’ operator can only be used when contained within a method or lambda expression marked with the ‘async’ modifier
CS1994ErrorThe ‘async’ modifier can only be used in methods that have a body.
CS1995ErrorThe ‘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
CS1996ErrorCannot await in the body of a lock statement
CS1997ErrorSince ‘{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’?
CS1998WarningThis 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.
CS2001ErrorSource file ‘{0}’ could not be found.
CS2002WarningSource file ‘{0}’ specified multiple times
CS2005ErrorMissing file specification for ‘{0}’ option
CS2006ErrorCommand-line syntax error: Missing ‘{0}’ for ‘{1}’ option
CS2007ErrorUnrecognized option: ‘{0}’
CS2008WarningNo source files specified.
CS2011ErrorError opening response file ‘{0}’
CS2012ErrorCannot open ‘{0}’ for writing — ‘{1}’
CS2013ErrorInvalid image base number ‘{0}’
CS2015Error‘{0}’ is a binary file instead of a text file
CS2016FatalCode page ‘{0}’ is invalid or not installed
CS2017ErrorCannot specify /main if building a module or library
CS2019FatalInvalid target type for /target: must specify ‘exe’, ‘winexe’, ‘library’, or ‘module’
CS2021FatalFile name ‘{0}’ is empty, contains invalid characters, has a drive specification without an absolute path, or is too long
CS2023WarningIgnoring /noconfig option because it was specified in a response file
CS2024ErrorInvalid file section alignment ‘{0}’
CS2029WarningInvalid name for a preprocessing symbol; ‘{0}’ is not a valid identifier
CS2033FatalCannot create short filename ‘{0}’ when a long filename with the same short filename already exists
CS2034ErrorA /reference option that declares an extern alias can only have one filename. To specify multiple aliases or filenames, use multiple /reference options.
CS2035ErrorCommand-line syntax error: Missing ‘:’ for ‘{0}’ option
CS2036ErrorThe /pdb option requires that the /debug option also be used
CS2037ErrorAn expression tree lambda may not contain a COM call with ref omitted on arguments
CS2038WarningThe language name ‘{0}’ is invalid.
CS2039ErrorCommand-line syntax error: Invalid Guid format ‘{0}’ for option ‘{1}’
CS2040ErrorCommand-line syntax error: Missing Guid for option ‘{1}’
CS2041ErrorInvalid output name: {0}
CS2042ErrorInvalid debug information format: {0}
CS2043Error‘id#’ syntax is no longer supported. Use ‘$id’ instead.
CS2044Error/sourcelink switch is only supported when emitting PDB.
CS2045Error/embed switch is only supported when emitting a PDB.
CS2046ErrorCommand-line syntax error: ‘{0}’ is not a valid value for the ‘{1}’ option. The value must be of the form ‘{2}’.
CS3000WarningMethods with variable arguments are not CLS-compliant
CS3001WarningArgument type ‘{0}’ is not CLS-compliant
CS3002WarningReturn type of ‘{0}’ is not CLS-compliant
CS3003WarningType of ‘{0}’ is not CLS-compliant
CS3005WarningIdentifier ‘{0}’ differing only in case is not CLS-compliant
CS3006WarningOverloaded method ‘{0}’ differing only in ref or out, or in array rank, is not CLS-compliant
CS3007WarningOverloaded method ‘{0}’ differing only by unnamed array types is not CLS-compliant
CS3008WarningIdentifier ‘{0}’ is not CLS-compliant
CS3009Warning‘{0}’: base type ‘{1}’ is not CLS-compliant
CS3010Warning‘{0}’: CLS-compliant interfaces must have only CLS-compliant members
CS3011Warning‘{0}’: only CLS-compliant members can be abstract
CS3012WarningYou must specify the CLSCompliant attribute on the assembly, not the module, to enable CLS compliance checking
CS3013WarningAdded modules must be marked with the CLSCompliant attribute to match the assembly
CS3014Warning‘{0}’ cannot be marked as CLS-compliant because the assembly does not have a CLSCompliant attribute
CS3015Warning‘{0}’ has no accessible constructors which use only CLS-compliant types
CS3016WarningArrays as attribute arguments is not CLS-compliant
CS3017WarningYou cannot specify the CLSCompliant attribute on a module that differs from the CLSCompliant attribute on the assembly
CS3018Warning‘{0}’ cannot be marked as CLS-compliant because it is a member of non-CLS-compliant type ‘{1}’
CS3019WarningCLS compliance checking will not be performed on ‘{0}’ because it is not visible from outside this assembly
CS3021Warning‘{0}’ does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute
CS3022WarningCLSCompliant attribute has no meaning when applied to parameters. Try putting it on the method instead.
CS3023WarningCLSCompliant attribute has no meaning when applied to return types. Try putting it on the method instead.
CS3024WarningConstraint type ‘{0}’ is not CLS-compliant
CS3026WarningCLS-compliant field ‘{0}’ cannot be volatile
CS3027Warning‘{0}’ is not CLS-compliant because base interface ‘{1}’ is not CLS-compliant
CS3028FatalAlgorithm ‘{0}’ is not supported
CS4001ErrorCannot await ‘{0}’
CS4003Error‘await’ cannot be used as an identifier within an async method or lambda expression
CS4004ErrorCannot await in an unsafe context
CS4005ErrorAsync methods cannot have unsafe parameters or return types
CS4006Error__arglist is not allowed in the parameter list of async methods
CS4007Error‘await’ cannot be used in an expression containing the type ‘{0}’
CS4008ErrorCannot await ‘void’
CS4009ErrorA void or int returning entry point cannot be async
CS4010ErrorCannot convert async {0} to delegate type ‘{1}’. An async {0} may return void, Task or Task, none of which are convertible to ‘{1}’.
CS4011Error‘await’ requires that the return type ‘{0}’ of ‘{1}.GetAwaiter()’ have suitable ‘IsCompleted’, ‘OnCompleted’, and ‘GetResult’ members, and implement ‘INotifyCompletion’ or ‘ICriticalNotifyCompletion’
CS4012ErrorParameters or locals of type ‘{0}’ cannot be declared in async methods or async lambda expressions.
CS4013ErrorInstance of type ‘{0}’ cannot be used inside a nested function, query expression, iterator block or async method
CS4014WarningBecause 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.
CS4015Error‘MethodImplOptions.Synchronized’ cannot be applied to an async method
CS4016ErrorSince this is an async method, the return expression must be of type ‘{0}’ rather than ‘Task<{0}>’
CS4017ErrorCallerLineNumberAttribute cannot be applied because there are no standard conversions from type ‘{0}’ to type ‘{1}’
CS4018ErrorCallerFilePathAttribute cannot be applied because there are no standard conversions from type ‘{0}’ to type ‘{1}’
CS4019ErrorCallerMemberNameAttribute cannot be applied because there are no standard conversions from type ‘{0}’ to type ‘{1}’
CS4020ErrorThe CallerLineNumberAttribute may only be applied to parameters with default values
CS4021ErrorThe CallerFilePathAttribute may only be applied to parameters with default values
CS4022ErrorThe CallerMemberNameAttribute may only be applied to parameters with default values
CS4023Error/platform:anycpu32bitpreferred can only be used with /t:exe, /t:winexe and /t:appcontainerexe
CS4024WarningThe 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
CS4025WarningThe 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
CS4026WarningThe 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
CS4027Error‘{0}’ does not implement ‘{1}’
CS4028Error‘await’ requires that the type ‘{0}’ have a suitable ‘GetAwaiter’ method. Are you missing a using directive for ‘System’?
CS4029ErrorCannot return an expression of type ‘void’
CS4030ErrorSecurity attribute ‘{0}’ cannot be applied to an Async method.
CS4031ErrorAsync methods are not allowed in an Interface, Class, or Structure which has the ‘SecurityCritical’ or ‘SecuritySafeCritical’ attribute.
CS4032ErrorThe ‘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}>’.
CS4033ErrorThe ‘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’.
CS4034ErrorThe ‘await’ operator can only be used within an async {0}. Consider marking this {0} with the ‘async’ modifier.
CS4036Error‘{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}’?)
CS5001ErrorProgram does not contain a static ‘Main’ method suitable for an entry point
CS7000ErrorUnexpected use of an aliased name
CS7002ErrorUnexpected use of a generic name
CS7003ErrorUnexpected use of an unbound generic name
CS7006ErrorExpressions and statements can only occur in a method body
CS7007ErrorA ‘using static’ directive can only be applied to types; ‘{0}’ is a namespace not a type. Consider a ‘using namespace’ directive instead
CS7008ErrorThe assembly name ‘{0}’ is reserved and cannot be used as a reference in an interactive session
CS7009ErrorCannot use #r after first token in file
CS7010ErrorQuoted file name expected
CS7011Error#r is only allowed in scripts
CS7012ErrorThe name ‘{0}’ does not exist in the current context (are you missing a reference to assembly ‘{1}’?)
CS7013ErrorName ‘{0}’ exceeds the maximum length allowed in metadata.
CS7014ErrorAttributes are not valid in this context.
CS7015Error‘extern alias’ is not valid in this context
CS7016ErrorAlias ‘{0}’ conflicts with {1} definition
CS7017ErrorMember definition, statement, or end-of-file expected
CS7018ErrorExpected a script (.csx file) but none specified
CS7019ErrorType of ‘{0}’ cannot be inferred since its initializer directly or indirectly refers to the definition.
CS7020ErrorCannot use ‘yield’ in top-level script code
CS7021ErrorCannot declare namespace in script code
CS7022WarningThe entry point of the program is global code; ignoring ‘{0}’ entry point.
CS7023WarningThe second operand of an ‘is’ or ‘as’ operator may not be static type ‘{0}’
CS7024ErrorDelegate ‘{0}’ has no invoke method or an invoke method with a return type or parameter types that are not supported.
CS7025ErrorInconsistent accessibility: event type ‘{1}’ is less accessible than event ‘{0}’
CS7026ErrorAssembly and module attributes are not allowed in this context
CS7027ErrorError signing output with public key from file ‘{0}’ — {1}
CS7028ErrorError signing output with public key from container ‘{0}’ — {1}
CS7029ErrorFriend access was granted by ‘{0}’, but the strong name signing state of the output assembly does not match that of the granting assembly.
CS7030ErrorCannot pass null for friend assembly name
CS7032ErrorKey file ‘{0}’ is missing the private key needed for signing
CS7033WarningDelay signing was specified and requires a public key, but no public key was specified
CS7034ErrorThe specified version string does not conform to the required format – major[.minor[.build[.revision]]]
CS7035WarningThe specified version string does not conform to the recommended format – major.minor.build.revision
CS7036ErrorThere is no argument given that corresponds to the required formal parameter ‘{0}’ of ‘{1}’
CS7038ErrorFailed to emit module ‘{0}’: {1}
CS7041ErrorEach linked resource and module must have a unique filename. Filename ‘{0}’ is specified more than once in this assembly
CS7042ErrorThe DllImport attribute cannot be applied to a method that is generic or contained in a generic method or type.
CS7043ErrorCannot update ‘{0}’; attribute ‘{1}’ is missing.
CS7045ErrorParameter not valid for the specified unmanaged type.
CS7046ErrorAttribute parameter ‘{0}’ must be specified.
CS7047ErrorAttribute parameter ‘{0}’ or ‘{1}’ must be specified.
CS7048ErrorFirst argument to a security attribute must be a valid SecurityAction
CS7049ErrorSecurity attribute ‘{0}’ has an invalid SecurityAction value ‘{1}’
CS7050ErrorSecurityAction value ‘{0}’ is invalid for security attributes applied to an assembly
CS7051ErrorSecurityAction value ‘{0}’ is invalid for security attributes applied to a type or a method
CS7052ErrorSecurityAction value ‘{0}’ is invalid for PrincipalPermission attribute
CS7053ErrorAn expression tree may not contain ‘{0}’
CS7054ErrorUnmanaged type ‘{0}’ not valid for fields.
CS7055ErrorUnmanaged type ‘{0}’ is only valid for fields.
CS7056ErrorUnable to resolve file path ‘{0}’ specified for the named argument ‘{1}’ for PermissionSet attribute
CS7057ErrorError reading file ‘{0}’ specified for the named argument ‘{1}’ for PermissionSet attribute: ‘{2}’
CS7058ErrorThe specified version string does not conform to the required format – major.minor.build.revision (without wildcards)
CS7059ErrorExecutables cannot be satellite assemblies; culture should always be empty
CS7061ErrorDuplicate ‘{0}’ attribute in ‘{1}’
CS7064ErrorError opening icon file {0} — {1}
CS7065ErrorError building Win32 resources — {0}
CS7066ErrorYield statements may not appear at the top level in interactive code.
CS7067ErrorAttribute constructor parameter ‘{0}’ is optional, but no default parameter value was specified.
CS7068ErrorReference to type ‘{0}’ claims it is defined in this assembly, but it is not defined in source or any added modules
CS7069ErrorReference to type ‘{0}’ claims it is defined in ‘{1}’, but it could not be found
CS7070ErrorSecurity attribute ‘{0}’ is not valid on this declaration type. Security attributes are only valid on assembly, type and method declarations.
CS7071ErrorAssembly reference ‘{0}’ is invalid and cannot be resolved
CS7079ErrorThe type ‘{0}’ is defined in a module that has not been added. You must add the module ‘{1}’.
CS7080WarningThe CallerMemberNameAttribute applied to parameter ‘{0}’ will have no effect. It is overridden by the CallerFilePathAttribute.
CS7081WarningThe CallerMemberNameAttribute applied to parameter ‘{0}’ will have no effect. It is overridden by the CallerLineNumberAttribute.
CS7082WarningThe CallerFilePathAttribute applied to parameter ‘{0}’ will have no effect. It is overridden by the CallerLineNumberAttribute.
CS7083ErrorExpression must be implicitly convertible to Boolean or its type ‘{0}’ must define operator ‘{1}’.
CS7084ErrorA Windows Runtime event may not be passed as an out or ref parameter.
CS7086ErrorModule name ‘{0}’ stored in ‘{1}’ must match its filename.
CS7087ErrorInvalid module name: {0}
CS7088ErrorInvalid ‘{0}’ value: ‘{1}’.
CS7089ErrorAppConfigPath must be absolute.
CS7090WarningAttribute ‘{0}’ from module ‘{1}’ will be ignored in favor of the instance appearing in source
CS7091ErrorAttribute ‘{0}’ given in a source file conflicts with option ‘{1}’.
CS7092ErrorA fixed buffer may only have one dimension.
CS7093ErrorCannot read config file ‘{0}’ — ‘{1}’
CS7094ErrorCannot await in the filter expression of a catch clause
CS7095WarningFilter expression is a constant ‘true’, consider removing the filter
CS7096ErrorCannot continue since the edit includes a reference to an embedded type: ‘{0}’.
CS7098ErrorLinked netmodule metadata must provide a full PE image: ‘{0}’.
CS7099ErrorMetadata references are not supported.
CS7100ErrorAssembly culture strings may not contain embedded NUL characters.
CS7101ErrorMember ‘{0}’ added during the current debug session can only be accessed from within its declaring assembly ‘{1}’.
CS7102ErrorCompilation options ‘{0}’ and ‘{1}’ can’t both be specified at the same time.
CS7103ErrorUnable to read debug information of method ‘{0}’ (token 0x{1:X8}) from assembly ‘{2}’
CS8001WarningThe command line switch ‘{0}’ is not yet implemented and was ignored.
CS8002WarningReferenced assembly ‘{0}’ does not have a strong name.
CS8003ErrorInvalid signature public key specified in AssemblySignatureKeyAttribute.
CS8004ErrorType ‘{0}’ exported from module ‘{1}’ conflicts with type declared in primary module of this assembly.
CS8005ErrorType ‘{0}’ exported from module ‘{1}’ conflicts with type ‘{2}’ exported from module ‘{3}’.
CS8006ErrorForwarded type ‘{0}’ conflicts with type declared in primary module of this assembly.
CS8007ErrorType ‘{0}’ forwarded to assembly ‘{1}’ conflicts with type ‘{2}’ forwarded to assembly ‘{3}’.
CS8008ErrorType ‘{0}’ forwarded to assembly ‘{1}’ conflicts with type ‘{2}’ exported from module ‘{3}’.
CS8009WarningReferenced assembly ‘{0}’ has different culture setting of ‘{1}’.
CS8010ErrorAgnostic assembly cannot have a processor specific module ‘{0}’.
CS8011ErrorAssembly and module ‘{0}’ cannot target different processors.
CS8012WarningReferenced assembly ‘{0}’ targets a different processor.
CS8013ErrorCryptographic failure while creating hashes.
CS8014ErrorReference to ‘{0}’ netmodule missing.
CS8015ErrorModule ‘{0}’ is already defined in this assembly. Each module must have a unique filename.
CS8016ErrorTransparent identifier member access failed for field ‘{0}’ of ‘{1}’. Does the data being queried implement the query pattern?
CS8017ErrorThe parameter has multiple distinct default values.
CS8018WarningWithin cref attributes, nested types of generic types should be qualified.
CS8019HiddenUnnecessary using directive.
CS8020HiddenUnused extern alias.
CS8021WarningNo value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options.
CS8022ErrorFeature ‘{0}’ is not available in C# 1. Please use language version {1} or greater.
CS8023ErrorFeature ‘{0}’ is not available in C# 2. Please use language version {1} or greater.
CS8024ErrorFeature ‘{0}’ is not available in C# 3. Please use language version {1} or greater.
CS8025ErrorFeature ‘{0}’ is not available in C# 4. Please use language version {1} or greater.
CS8026ErrorFeature ‘{0}’ is not available in C# 5. Please use language version {1} or greater.
CS8027ErrorThe field has multiple distinct constant values.
CS8028Error‘{0}’: a class with the ComImport attribute cannot specify field initializers.
CS8029WarningLocal name ‘{0}’ is too long for PDB. Consider shortening or compiling without /debug.
CS8030ErrorAnonymous function converted to a void returning delegate cannot return a value
CS8031ErrorAsync lambda expression converted to a ‘Task’ returning delegate cannot return a value. Did you intend to return ‘Task’?
CS8032WarningAn instance of analyzer {0} cannot be created from {1} : {2}.
CS8033WarningThe assembly {0} does not contain any analyzers.
CS8034WarningUnable to load Analyzer assembly {0} : {1}
CS8035ErrorError reading ruleset file {0} – {1}
CS8036ErrorError reading debug information for ‘{0}’
CS8040InfoSkipping some types in analyzer assembly {0} due to a ReflectionTypeLoadException : {1}.
CS8050ErrorOnly auto-implemented properties can have initializers.
CS8051ErrorAuto-implemented properties must have get accessors.
CS8053ErrorInstance properties in interfaces cannot have initializers.
CS8054ErrorEnums cannot contain explicit parameterless constructors
CS8055ErrorCannot emit debug information for a source text without encoding.
CS8057ErrorBlock bodies and expression bodies cannot both be provided.
CS8058ErrorFeature ‘{0}’ is experimental and unsupported; use ‘/features:{1}’ to enable.
CS8059ErrorFeature ‘{0}’ is not available in C# 6. Please use language version {1} or greater.
CS8070ErrorControl cannot fall out of switch from final case label (‘{0}’)
CS8072ErrorAn expression tree lambda may not contain a null propagating operator.
CS8073WarningThe result of the expression is always ‘{0}’ since a value of type ‘{1}’ is never equal to ‘null’ of type ‘{2}’
CS8074ErrorAn expression tree lambda may not contain a dictionary initializer.
CS8075ErrorAn extension Add method is not supported for a collection initializer in an expression lambda.
CS8076ErrorMissing close delimiter ‘}’ for interpolated expression started with ‘{‘.
CS8077ErrorA single-line comment may not be used in an interpolated string.
CS8078ErrorAn expression is too long or complex to compile
CS8079ErrorUse of possibly unassigned auto-implemented property ‘{0}’
CS8080ErrorAuto-implemented properties must override all accessors of the overridden property.
CS8081ErrorExpression does not have a name.
CS8082ErrorSub-expression cannot be used in an argument to nameof.
CS8083ErrorAn alias-qualified name is not an expression.
CS8084ErrorType parameters are not allowed on a method group as an argument to ‘nameof’.
CS8085ErrorA ‘using static’ directive cannot be used to declare an alias
CS8086ErrorA ‘{0}’ character must be escaped (by doubling) in an interpolated string.
CS8087ErrorA ‘{0}’ character may only be escaped by doubling ‘{0}{0}’ in an interpolated string.
CS8088ErrorA format specifier may not contain trailing whitespace.
CS8089ErrorEmpty format specifier.
CS8090ErrorThere is an error in a referenced assembly ‘{0}’.
CS8091Error‘{0}’ cannot be extern and have a constructor initializer
CS8092ErrorExpression or declaration statement expected.
CS8093ErrorExtension method groups are not allowed as an argument to ‘nameof’.
CS8094WarningAlignment value {0} has a magnitude greater than {1} and may result in a large formatted string.
CS8095ErrorLength of String constant resulting from concatenation exceeds System.Int32.MaxValue. Try splitting the string into multiple constants.
CS8096ErrorDebug entry point must be a definition of a method declared in the current compilation.
CS8097Error#load is only allowed in scripts
CS8098ErrorCannot use #load after first token in file
CS8099ErrorSource file references are not supported.
CS8100ErrorThe ‘await’ operator cannot be used in a static script variable initializer.
CS8101ErrorThe pathmap option was incorrectly formatted.
CS8102ErrorPublic signing was specified and requires a public key, but no public key was specified.
CS8103ErrorCombined length of user strings used by the program exceeds allowed limit. Try to decrease use of string literals.
CS8104ErrorAn error occurred while writing the output file: {0}.
CS8105WarningAttribute ‘{0}’ is ignored when public signing is specified.
CS8106ErrorOption ‘{0}’ must be an absolute path.
CS8107ErrorFeature ‘{0}’ is not available in C# 7.0. Please use language version {1} or greater.
CS8108ErrorCannot pass argument with dynamic type to params parameter ‘{0}’ of local function ‘{1}’.
CS8110ErrorAn expression tree may not contain a reference to a local function
CS8111ErrorInvalid instrumentation kind: {0}
CS8112ErrorLocal function ‘{0}’ must declare a body because it is not marked ‘static extern’.
CS8113ErrorInvalid hash algorithm name: ‘{0}’
CS8115ErrorA throw expression is not allowed in this context.
CS8116ErrorIt is not legal to use nullable type ‘{0}?’ in a pattern; use the underlying type ‘{0}’ instead.
CS8117ErrorInvalid operand for pattern match; value required, but found ‘{0}’.
CS8119ErrorThe switch expression must be a value; found ‘{0}’.
CS8120ErrorThe switch case is unreachable. It has already been handled by a previous case or it is impossible to match.
CS8121ErrorAn expression of type ‘{0}’ cannot be handled by a pattern of type ‘{1}’.
CS8122ErrorAn expression tree may not contain an ‘is’ pattern-matching operator.
CS8123WarningThe tuple element name ‘{0}’ is ignored because a different name or no name is specified by the target type ‘{1}’.
CS8124ErrorTuple must contain at least two elements.
CS8125ErrorTuple element name ‘{0}’ is only allowed at position {1}.
CS8126ErrorTuple element name ‘{0}’ is disallowed at any position.
CS8127ErrorTuple element names must be unique.
CS8128ErrorMember ‘{0}’ was not found on type ‘{1}’ from assembly ‘{2}’.
CS8129ErrorNo suitable ‘Deconstruct’ instance or extension method was found for type ‘{0}’, with {1} out parameters and a void return type.
CS8130ErrorCannot infer the type of implicitly-typed deconstruction variable ‘{0}’.
CS8131ErrorDeconstruct assignment requires an expression with a type on the right-hand-side.
CS8132ErrorCannot deconstruct a tuple of ‘{0}’ elements into ‘{1}’ variables.
CS8133ErrorCannot deconstruct dynamic objects.
CS8134ErrorDeconstruction must contain at least two variables.
CS8135ErrorTuple with {0} elements cannot be converted to type ‘{1}’.
CS8136ErrorDeconstruction ‘var (…)’ form disallows a specific type for ‘var’.
CS8137ErrorCannot define a class or member that utilizes tuples because the compiler required type ‘{0}’ cannot be found. Are you missing a reference?
CS8138ErrorCannot reference ‘System.Runtime.CompilerServices.TupleElementNamesAttribute’ explicitly. Use the tuple syntax to define tuple names.
CS8139Error‘{0}’: cannot change tuple element names when overriding inherited member ‘{1}’
CS8140Error‘{0}’ is already listed in the interface list on type ‘{2}’ with different tuple element names, as ‘{1}’.
CS8141ErrorThe tuple element names in the signature of method ‘{0}’ must match the tuple element names of interface method ‘{1}’ (including on the return type).
CS8142ErrorBoth partial method declarations, ‘{0}’ and ‘{1}’, must use the same tuple element names.
CS8143ErrorAn expression tree may not contain a tuple literal.
CS8144ErrorAn expression tree may not contain a tuple conversion.
CS8145ErrorAuto-implemented properties cannot return by reference
CS8146ErrorProperties which return by reference must have a get accessor
CS8147ErrorProperties which return by reference cannot have set accessors
CS8148Error‘{0}’ must match by reference return of overridden member ‘{1}’
CS8149ErrorBy-reference returns may only be used in methods that return by reference
CS8150ErrorBy-value returns may only be used in methods that return by value
CS8151ErrorThe return expression must be of type ‘{0}’ because this method returns by reference
CS8152Error‘{0}’ does not implement interface member ‘{1}’. ‘{2}’ cannot implement ‘{1}’ because it does not have matching return by reference.
CS8153ErrorAn expression tree lambda may not contain a call to a method, property, or indexer that returns by reference
CS8154ErrorThe body of ‘{0}’ cannot be an iterator block because ‘{0}’ returns by reference
CS8155ErrorLambda expressions that return by reference cannot be converted to expression trees
CS8156ErrorAn expression cannot be used in this context because it may not be passed or returned by reference
CS8157ErrorCannot return ‘{0}’ by reference because it was initialized to a value that cannot be returned by reference
CS8158ErrorCannot return by reference a member of ‘{0}’ because it was initialized to a value that cannot be returned by reference
CS8159ErrorCannot return the range variable ‘{0}’ by reference
CS8160ErrorA readonly field cannot be returned by writable reference
CS8161ErrorA static readonly field cannot be returned by writable reference
CS8162ErrorMembers of readonly field ‘{0}’ cannot be returned by writable reference
CS8163ErrorFields of static readonly field ‘{0}’ cannot be returned by writable reference
CS8166ErrorCannot return a parameter by reference ‘{0}’ because it is not a ref or out parameter
CS8167ErrorCannot return by reference a member of parameter ‘{0}’ because it is not a ref or out parameter
CS8168ErrorCannot return local ‘{0}’ by reference because it is not a ref local
CS8169ErrorCannot return a member of local ‘{0}’ by reference because it is not a ref local
CS8170ErrorStruct members cannot return ‘this’ or other instance members by reference
CS8171ErrorCannot initialize a by-value variable with a reference
CS8172ErrorCannot initialize a by-reference variable with a value
CS8173ErrorThe expression must be of type ‘{0}’ because it is being assigned by reference
CS8174ErrorA declaration of a by-reference variable must have an initializer
CS8175ErrorCannot use ref local ‘{0}’ inside an anonymous method, lambda expression, or query expression
CS8176ErrorIterators cannot have by-reference locals
CS8177ErrorAsync methods cannot have by-reference locals
CS8178Error‘await’ cannot be used in an expression containing a call to ‘{0}’ because it returns by reference
CS8179ErrorPredefined type ‘{0}’ is not defined or imported
CS8180Error{ or ; or => expected
CS8181Error‘new’ cannot be used with tuple type. Use a tuple literal expression instead.
CS8182ErrorPredefined type ‘{0}’ must be a struct.
CS8183ErrorCannot infer the type of implicitly-typed discard.
CS8185ErrorA declaration is not allowed in this context.
CS8186ErrorA foreach loop must declare its iteration variables.
CS8187ErrorTuple element names are not permitted on the left of a deconstruction.
CS8188ErrorAn expression tree may not contain a throw-expression.
CS8189ErrorRef mismatch between ‘{0}’ and delegate ‘{1}’
CS8190ErrorProvided source code kind is unsupported or invalid: ‘{0}’
CS8191ErrorProvided documentation mode is unsupported or invalid: ‘{0}’.
CS8192ErrorProvided language version is unsupported or invalid: ‘{0}’.
CS8196ErrorReference to an implicitly-typed out variable ‘{0}’ is not permitted in the same argument list.
CS8197ErrorCannot infer the type of implicitly-typed out variable ‘{0}’.
CS8198ErrorAn expression tree may not contain an out argument variable declaration.
CS8199ErrorThe syntax ‘var (…)’ as an lvalue is reserved.
CS8202ErrorPublic signing is not supported for netmodules.
CS8203ErrorInvalid assembly name: {0}
CS8204ErrorFor type ‘{0}’ to be used as an AsyncMethodBuilder for type ‘{1}’, its Task property should return type ‘{1}’ instead of type ‘{2}’.
CS8205ErrorAttributes are not allowed on local function parameters or type parameters
CS8206ErrorModule ‘{0}’ in assembly ‘{1}’ is forwarding the type ‘{2}’ to multiple assemblies: ‘{3}’ and ‘{4}’.
CS8207ErrorAn expression tree may not contain a discard.
CS8208ErrorIt is not legal to use the type ‘dynamic’ in a pattern.
CS8209ErrorA value of type ‘void’ may not be assigned.
CS8210ErrorA tuple may not contain a value of type ‘void’.
CS8300ErrorMerge conflict marker encountered
CS8301ErrorInvalid name for a preprocessing symbol; ‘{0}’ is not a valid identifier
CS8302ErrorFeature ‘{0}’ is not available in C# 7.1. Please use language version {1} or greater.
CS8303ErrorSpecified language version ‘{0}’ cannot have leading zeroes
CS8304ErrorCompiler version: ‘{0}’. Language version: {1}.
CS8305Warning‘{0}’ is for evaluation purposes only and is subject to change or removal in future updates.
CS8306ErrorTuple element name ‘{0}’ is inferred. Please use language version {1} or greater to access an element by its inferred name.
CS8307ErrorThe first operand of an ‘as’ operator may not be a tuple literal without a natural type.
CS8308ErrorDo not use refout when using refonly.
CS8309ErrorCannot compile net modules when using /refout or /refonly.
CS8310ErrorOperator ‘{0}’ cannot be applied to operand ‘{1}’
CS8312ErrorUse of default literal is not valid in this context
CS8314ErrorAn expression of type ‘{0}’ cannot be handled by a pattern of type ‘{1}’ in C# {2}. Please use language version {3} or greater.
CS8315ErrorOperator ‘{0}’ is ambiguous on operands ‘{1}’ and ‘{2}’
CS8320ErrorFeature ‘{0}’ is not available in C# 7.2. Please use language version {1} or greater.
CS8321WarningThe local function ‘{0}’ is declared but never used
CS8322ErrorCannot pass argument with dynamic type to generic local function ‘{0}’ with inferred type arguments.
CS8323ErrorNamed argument ‘{0}’ is used out-of-position but is followed by an unnamed argument
CS8324ErrorNamed argument specifications must appear after all fixed arguments have been specified in a dynamic invocation.
CS8325Error‘await’ cannot be used in an expression containing a ref conditional operator
CS8326ErrorBoth conditional operator values must be ref values or neither may be a ref value
CS8327ErrorThe expression must be of type ‘{0}’ to match the alternative ref value
CS8328ErrorThe parameter modifier ‘{0}’ cannot be used with ‘{1}’
CS8329ErrorCannot use {0} ‘{1}’ as a ref or out value because it is a readonly variable
CS8330ErrorMembers of {0} ‘{1}’ cannot be used as a ref or out value because it is a readonly variable
CS8331ErrorCannot assign to {0} ‘{1}’ because it is a readonly variable
CS8332ErrorCannot assign to a member of {0} ‘{1}’ because it is a readonly variable
CS8333ErrorCannot return {0} ‘{1}’ by writable reference because it is a readonly variable
CS8334ErrorMembers of {0} ‘{1}’ cannot be returned by writable reference because it is a readonly variable
CS8335ErrorDo not use ‘{0}’. This is reserved for compiler usage.
CS8336ErrorThe type name ‘{0}’ is reserved to be used by the compiler.
CS8337ErrorThe first parameter of a ‘ref’ extension method ‘{0}’ must be a value type or a generic type constrained to struct.
CS8338ErrorThe first parameter of the ‘in’ extension method ‘{0}’ must be a concrete (non-generic) value type.
CS8340ErrorInstance fields of readonly structs must be readonly.
CS8341ErrorAuto-implemented instance properties in readonly structs must be readonly.
CS8342ErrorField-like events are not allowed in readonly structs.
CS8343Error‘{0}’: ref structs cannot implement interfaces
CS8344Errorforeach statement cannot operate on enumerators of type ‘{0}’ in async or iterator methods because ‘{0}’ is a ref struct.
CS8345ErrorField or auto-implemented property cannot be of type ‘{0}’ unless it is an instance member of a ref struct.
CS8346ErrorConversion of a stackalloc expression of type ‘{0}’ to type ‘{1}’ is not possible.
CS8347ErrorCannot use a result of ‘{0}’ in this context because it may expose variables referenced by parameter ‘{1}’ outside of their declaration scope
CS8348ErrorCannot use a member of result of ‘{0}’ in this context because it may expose variables referenced by parameter ‘{1}’ outside of their declaration scope
CS8349ErrorExpression cannot be used in this context because it may indirectly expose variables outside of their declaration scope
CS8350ErrorThis combination of arguments to ‘{0}’ is disallowed because it may expose variables referenced by parameter ‘{1}’ outside of their declaration scope
CS8351ErrorBranches of a ref conditional operator cannot refer to variables with incompatible declaration scopes
CS8352ErrorCannot use local ‘{0}’ in this context because it may expose referenced variables outside of their declaration scope
CS8353ErrorA result of a stackalloc expression of type ‘{0}’ cannot be used in this context because it may be exposed outside of the containing method
CS8354ErrorCannot return ‘this’ by reference.
CS8355ErrorAn in parameter cannot have the Out attribute.
CS8356ErrorPredefined type ‘{0}’ is declared in multiple referenced assemblies: ‘{1}’ and ‘{2}’
CS8357ErrorThe specified version string contains wildcards, which are not compatible with determinism. Either remove wildcards from the version string, or disable determinism for this compilation
CS8358ErrorCannot use attribute constructor ‘{0}’ because it has ‘in’ parameters.
CS8359WarningFilter expression is a constant ‘false’, consider removing the catch clause
CS8360WarningFilter expression is a constant ‘false’, consider removing the try-catch block
CS8361ErrorA conditional expression cannot be used directly in a string interpolation because the ‘:’ ends the interpolation. Parenthesize the conditional expression.
CS8362Error__arglist cannot have an argument of void type
CS8364ErrorArguments with ‘in’ modifier cannot be used in dynamically dispatched expressions.
CS8370ErrorFeature ‘{0}’ is not available in C# 7.3. Please use language version {1} or greater.
CS8371WarningField-targeted attributes on auto-properties are not supported in language version {0}. Please use language version {1} or greater.
CS8372ErrorDo not use ‘System.Runtime.CompilerServices.FixedBuffer’ attribute on a property
CS8373ErrorThe left-hand side of a ref assignment must be a ref local or parameter.
CS8374ErrorCannot ref-assign ‘{1}’ to ‘{0}’ because ‘{1}’ has a narrower escape scope than ‘{0}’.
CS8375ErrorThe ‘new()’ constraint cannot be used with the ‘unmanaged’ constraint
CS8377ErrorThe type ‘{2}’ must be a non-nullable value type, along with all fields at any level of nesting, in order to use it as parameter ‘{1}’ in the generic type or method ‘{0}’
CS8378Error__arglist cannot have an argument passed by ‘in’ or ‘out’
CS8379ErrorType parameter ‘{1}’ has the ‘unmanaged’ constraint so ‘{1}’ cannot be used as a constraint for ‘{0}’
CS8380Error‘{0}’: cannot specify both a constraint class and the ‘unmanaged’ constraint
CS8381Error“Invalid rank specifier: expected ‘]’
CS8382ErrorAn expression tree may not contain a tuple == or != operator
CS8383WarningThe tuple element name ‘{0}’ is ignored because a different name or no name is specified on the other side of the tuple == or != operator.
CS8384ErrorTuple types used as operands of an == or != operator must have matching cardinalities. But this operator has tuple types of cardinality {0} on the left and {1} on the right.
CS8385ErrorThe given expression cannot be used in a fixed statement
CS8386ErrorInvalid object creation
CS8387WarningType parameter ‘{0}’ has the same name as the type parameter from outer method ‘{1}’
CS8388ErrorAn out variable cannot be declared as a ref local
CS8389ErrorOmitting the type argument is not allowed in the current context
CS8400ErrorFeature ‘{0}’ is not available in C# 8.0. Please use language version {1} or greater.
CS8401ErrorTo use ‘@$’ instead of ‘[email protected]’ for an interpolated verbatim string, please use language version ‘{0}’ or greater.
CS8403ErrorMethod ‘{0}’ with an iterator block must be ‘async’ to return ‘{1}’
CS8410Error‘{0}’: type used in an asynchronous using statement must be implicitly convertible to ‘System.IAsyncDisposable’ or implement a suitable ‘DisposeAsync’ method.
CS8411ErrorAsynchronous foreach statement cannot operate on variables of type ‘{0}’ because ‘{0}’ does not contain a suitable public instance or extension definition for ‘{1}’
CS8412ErrorAsynchronous foreach requires that the return type ‘{0}’ of ‘{1}’ must have a suitable public ‘MoveNextAsync’ method and public ‘Current’ property
CS8413ErrorAsynchronous foreach statement cannot operate on variables of type ‘{0}’ because it implements multiple instantiations of ‘{1}’; try casting to a specific interface instantiation
CS8414Errorforeach statement cannot operate on variables of type ‘{0}’ because ‘{0}’ does not contain a public instance or extension definition for ‘{1}’. Did you mean ‘await foreach’ rather than ‘foreach’?
CS8415ErrorAsynchronous foreach statement cannot operate on variables of type ‘{0}’ because ‘{0}’ does not contain a public instance or extension definition for ‘{1}’. Did you mean ‘foreach’ rather than ‘await foreach’?
CS8416ErrorCannot use a collection of dynamic type in an asynchronous foreach
CS8417Error‘{0}’: type used in an asynchronous using statement must be implicitly convertible to ‘System.IAsyncDisposable’ or implement a suitable ‘DisposeAsync’ method. Did you mean ‘using’ rather than ‘await using’?
CS8418Error‘{0}’: type used in a using statement must be implicitly convertible to ‘System.IDisposable’. Did you mean ‘await using’ rather than ‘using’?
CS8419ErrorThe body of an async-iterator method must contain a ‘yield’ statement.
CS8420ErrorThe body of an async-iterator method must contain a ‘yield’ statement. Consider removing ‘async’ from the method declaration or adding a ‘yield’ statement.
CS8421ErrorA static local function cannot contain a reference to ‘{0}’.
CS8422ErrorA static local function cannot contain a reference to ‘this’ or ‘base’.
CS8423ErrorAttribute ‘{0}’ is not valid on event accessors. It is only valid on ‘{1}’ declarations.
CS8424WarningThe EnumeratorCancellationAttribute applied to parameter ‘{0}’ will have no effect. The attribute is only effective on a parameter of type CancellationToken in an async-iterator method returning IAsyncEnumerable
CS8425WarningAsync-iterator ‘{0}’ has one or more parameters of type ‘CancellationToken’ but none of them is decorated with the ‘EnumeratorCancellation’ attribute, so the cancellation token parameter from the generated ‘IAsyncEnumerable<>.GetAsyncEnumerator’ will be unconsumed
CS8426ErrorThe attribute [EnumeratorCancellation] cannot be used on multiple parameters
CS8427ErrorEnums, classes, and structures cannot be declared in an interface that has an ‘in’ or ‘out’ type parameter.
CS8428ErrorInvocation of implicit Index Indexer cannot name the argument.
CS8429ErrorInvocation of implicit Range Indexer cannot name the argument.
CS8502ErrorMatching the tuple type ‘{0}’ requires ‘{1}’ subpatterns, but ‘{2}’ subpatterns are present.
CS8503ErrorA property subpattern requires a reference to the property or field to be matched, e.g. ‘{{ Name: {0} }}’
CS8504ErrorPattern missing
CS8505ErrorA 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 ‘_’.
CS8506ErrorNo best type was found for the switch expression.
CS8508ErrorThe syntax ‘var’ for a pattern is not permitted to refer to a type, but ‘{0}’ is in scope here.
CS8509WarningThe switch expression does not handle all possible values of its input type (it is not exhaustive). For example, the pattern ‘{0}’ is not covered.
CS8510ErrorThe pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.
CS8511ErrorAn expression of type ‘{0}’ cannot be handled by a pattern of type ‘{1}’. Please use language version ‘{2}’ or greater to match an open type with a constant pattern.
CS8512WarningThe name ‘‘ refers to the constant, not the discard pattern. Use ‘var ‘ to discard the value, or ‘@_’ to refer to a constant by that name.
CS8513WarningThe name ‘‘ refers to the type ‘{0}’, not the discard pattern. Use ‘@‘ for the type, or ‘var _’ to discard.
CS8514ErrorAn expression tree may not contain a switch expression.
CS8515ErrorParentheses are required around the switch governing expression.
CS8516ErrorThe name ‘{0}’ does not identify tuple element ‘{1}’.
CS8517ErrorThe name ‘{0}’ does not match the corresponding ‘Deconstruct’ parameter ‘{1}’.
CS8518ErrorAn expression of type ‘{0}’ can never match the provided pattern.
CS8519WarningThe given expression never matches the provided pattern.
CS8520WarningThe given expression always matches the provided constant.
CS8521ErrorPattern-matching is not permitted for pointer types.
CS8522ErrorElement names are not permitted when pattern-matching via ‘System.Runtime.CompilerServices.ITuple’.
CS8523ErrorThe discard pattern is not permitted as a case label in a switch statement. Use ‘case var :’ for a discard pattern, or ‘case @:’ for a constant named ‘_’.
CS8524WarningThe switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value. For example, the pattern ‘{0}’ is not covered.
CS8597WarningThrown value may be null.
CS8598ErrorThe suppression operator is not allowed in this context
CS8600WarningConverting null literal or possible null value to non-nullable type.
CS8601WarningPossible null reference assignment.
CS8602WarningDereference of a possibly null reference.
CS8603WarningPossible null reference return.
CS8604WarningPossible null reference argument for parameter ‘{0}’ in ‘{1}’.
CS8605WarningUnboxing a possibly null value.
CS8607WarningA possible null value may not be used for a type marked with [NotNull] or [DisallowNull]
CS8608WarningNullability of reference types in type doesn’t match overridden member.
CS8609WarningNullability of reference types in return type doesn’t match overridden member.
CS8610WarningNullability of reference types in type of parameter ‘{0}’ doesn’t match overridden member.
CS8611WarningNullability of reference types in type of parameter ‘{0}’ doesn’t match partial method declaration.
CS8612WarningNullability of reference types in type of ‘{0}’ doesn’t match implicitly implemented member ‘{1}’.
CS8613WarningNullability of reference types in return type of ‘{0}’ doesn’t match implicitly implemented member ‘{1}’.
CS8614WarningNullability of reference types in type of parameter ‘{0}’ of ‘{1}’ doesn’t match implicitly implemented member ‘{2}’.
CS8615WarningNullability of reference types in type doesn’t match implemented member ‘{0}’.
CS8616WarningNullability of reference types in return type doesn’t match implemented member ‘{0}’.
CS8617WarningNullability of reference types in type of parameter ‘{0}’ doesn’t match implemented member ‘{1}’.
CS8618WarningNon-nullable {0} ‘{1}’ must contain a non-null value when exiting constructor. Consider declaring the {0} as nullable.
CS8619WarningNullability of reference types in value of type ‘{0}’ doesn’t match target type ‘{1}’.
CS8620WarningArgument of type ‘{0}’ cannot be used for parameter ‘{2}’ of type ‘{1}’ in ‘{3}’ due to differences in the nullability of reference types.
CS8621WarningNullability of reference types in return type of ‘{0}’ doesn’t match the target delegate ‘{1}’ (possibly because of nullability attributes).
CS8622WarningNullability of reference types in type of parameter ‘{0}’ of ‘{1}’ doesn’t match the target delegate ‘{2}’ (possibly because of nullability attributes).
CS8623ErrorExplicit application of ‘System.Runtime.CompilerServices.NullableAttribute’ is not allowed.
CS8624WarningArgument of type ‘{0}’ cannot be used as an output of type ‘{1}’ for parameter ‘{2}’ in ‘{3}’ due to differences in the nullability of reference types.
CS8625WarningCannot convert null literal to non-nullable reference type.
CS8627ErrorA nullable type parameter must be known to be a value type or non-nullable reference type unless language version ‘{0}’ or greater is used. Consider changing the language version or adding a ‘class’, ‘struct’, or type constraint.
CS8628ErrorCannot use a nullable reference type in object creation.
CS8629WarningNullable value type may be null.
CS8630ErrorInvalid ‘{0}’ value: ‘{1}’ for C# {2}. Please use language version ‘{3}’ or greater.
CS8631WarningThe type ‘{3}’ cannot be used as type parameter ‘{2}’ in the generic type or method ‘{0}’. Nullability of type argument ‘{3}’ doesn’t match constraint type ‘{1}’.
CS8632WarningThe annotation for nullable reference types should only be used in code within a ‘#nullable’ annotations context.
CS8633WarningNullability in constraints for type parameter ‘{0}’ of method ‘{1}’ doesn’t match the constraints for type parameter ‘{2}’ of interface method ‘{3}’. Consider using an explicit interface implementation instead.
CS8634WarningThe type ‘{2}’ cannot be used as type parameter ‘{1}’ in the generic type or method ‘{0}’. Nullability of type argument ‘{2}’ doesn’t match ‘class’ constraint.
CS8635ErrorUnexpected character sequence ‘…’
CS8636ErrorInvalid option ‘{0}’ for /nullable; must be ‘disable’, ‘enable’, ‘warnings’ or ‘annotations’
CS8637ErrorExpected ‘enable’, ‘disable’, or ‘restore’
CS8639ErrorThe typeof operator cannot be used on a nullable reference type
CS8640ErrorExpression tree cannot contain value of ref struct or restricted type ‘{0}’.
CS8641Error‘else’ cannot start a statement.
CS8642ErrorAn expression tree may not contain a null coalescing assignment
CS8643WarningNullability of reference types in explicit interface specifier doesn’t match interface implemented by the type.
CS8644Warning‘{0}’ does not implement interface member ‘{1}’. Nullability of reference types in interface implemented by the base type doesn’t match.
CS8645Warning‘{0}’ is already listed in the interface list on type ‘{1}’ with different nullability of reference types.
CS8646Error‘{0}’ is explicitly implemented more than once.
CS8647ErrorA using variable cannot be used directly within a switch section (consider using braces).
CS8648ErrorA goto cannot jump to a location after a using declaration.
CS8649ErrorA goto cannot jump to a location before a using declaration within the same block.
CS8650ErrorIt is not legal to use nullable reference type ‘{0}?’ in an is-type expression; use the underlying type ‘{0}’ instead.
CS8651ErrorIt is not legal to use nullable reference type ‘{0}?’ in an as expression; use the underlying type ‘{0}’ instead.
CS8652ErrorThe feature ‘{0}’ is currently in Preview and unsupported. To use Preview features, use the ‘preview’ language version.
CS8655WarningThe switch expression does not handle some null inputs (it is not exhaustive). For example, the pattern ‘{0}’ is not covered.
CS8656WarningCall to non-readonly member ‘{0}’ from a ‘readonly’ member results in an implicit copy of ‘{1}’.
CS8657ErrorStatic member ‘{0}’ cannot be marked ‘readonly’.
CS8658ErrorAuto-implemented ‘set’ accessor ‘{0}’ cannot be marked ‘readonly’.
CS8659ErrorAuto-implemented property ‘{0}’ cannot be marked ‘readonly’ because it has a ‘set’ accessor.
CS8660ErrorCannot specify ‘readonly’ modifiers on both property or indexer ‘{0}’ and its accessor. Remove one of them.
CS8661ErrorCannot specify ‘readonly’ modifiers on both accessors of property or indexer ‘{0}’. Instead, put a ‘readonly’ modifier on the property itself.
CS8662ErrorField-like event ‘{0}’ cannot be ‘readonly’.
CS8663ErrorBoth partial method declarations must be readonly or neither may be readonly
CS8664Error‘{0}’: ‘readonly’ can only be used on accessors if the property or indexer has both a get and a set accessor
CS8665ErrorMethod ‘{0}’ specifies a ‘class’ constraint for type parameter ‘{1}’, but corresponding type parameter ‘{2}’ of overridden or explicitly implemented method ‘{3}’ is not a reference type.
CS8666ErrorMethod ‘{0}’ specifies a ‘struct’ constraint for type parameter ‘{1}’, but corresponding type parameter ‘{2}’ of overridden or explicitly implemented method ‘{3}’ is not a non-nullable value type.
CS8667WarningPartial method declarations of ‘{0}’ have inconsistent nullability in constraints for type parameter ‘{1}’
CS8668ErrorExpected ‘warnings’, ‘annotations’, or end of directive
CS8669WarningThe annotation for nullable reference types should only be used in code within a ‘#nullable’ annotations context. Auto-generated code requires an explicit ‘#nullable’ directive in source.
CS8670WarningObject or collection initializer implicitly dereferences possibly null member ‘{0}’.
CS8700ErrorMultiple analyzer config files cannot be in the same directory (‘{0}’).
CS8701ErrorTarget runtime doesn’t support default interface implementation.
CS8702Error‘{0}’ cannot implement interface member ‘{1}’ in type ‘{2}’ because the target runtime doesn’t support default interface implementation.
CS8703ErrorThe modifier ‘{0}’ is not valid for this item in C# {1}. Please use language version ‘{2}’ or greater.
CS8704Error‘{0}’ does not implement interface member ‘{1}’. ‘{2}’ cannot implicitly implement a non-public member in C# {3}. Please use language version ‘{4}’ or greater.
CS8705ErrorInterface member ‘{0}’ does not have a most specific implementation. Neither ‘{1}’, nor ‘{2}’ are most specific.
CS8706Error‘{0}’ cannot implement interface member ‘{1}’ in type ‘{2}’ because feature ‘{3}’ is not available in C# {4}. Please use language version ‘{5}’ or greater.
CS8707ErrorTarget runtime doesn’t support ‘protected’, ‘protected internal’, or ‘private protected’ accessibility for a member of an interface.
CS8711ErrorType ‘{0}’ cannot be embedded because it has a non-abstract member. Consider setting the ‘Embed Interop Types’ property to false.
CS8712Error‘{0}’: abstract event cannot use event accessor syntax
CS8714WarningThe type ‘{2}’ cannot be used as type parameter ‘{1}’ in the generic type or method ‘{0}’. Nullability of type argument ‘{2}’ doesn’t match ‘notnull’ constraint.
CS8715ErrorDuplicate null suppression operator (‘!’)
CS8716ErrorThere is no target type for the default literal.
CS8750ErrorType ‘{0}’ cannot be embedded because it has a re-abstraction of a member from base interface. Consider setting the ‘Embed Interop Types’ property to false.
CS8751ErrorInternal error in the C# compiler.
CS8752ErrorThe type ‘{0}’ may not be used as the target type of new()
CS8753ErrorUse of new() is not valid in this context
CS8754ErrorThere is no target type for ‘{0}’
CS8755Error‘{0}’ cannot be used as a modifier on a function pointer parameter.
CS8756ErrorFunction pointer ‘{0}’ does not take {1} arguments
CS8757ErrorNo overload for ‘{0}’ matches function pointer ‘{1}’
CS8758ErrorRef mismatch between ‘{0}’ and function pointer ‘{1}’
CS8759ErrorCannot create a function pointer for ‘{0}’ because it is not a static method
CS8760Error‘{0}’: extern event cannot have initializer
CS8761ErrorOperator ‘{0}’ cannot be applied to ‘default’ and operand of type ‘{1}’ because it is a type parameter that is not known to be a reference type
CS8762WarningParameter ‘{0}’ must have a non-null value when exiting with ‘{1}’.
CS8763WarningA method marked [DoesNotReturn] should not return.
CS8764WarningNullability of return type doesn’t match overridden member (possibly because of nullability attributes).
CS8765WarningNullability of type of parameter ‘{0}’ doesn’t match overridden member (possibly because of nullability attributes).
CS8766WarningNullability of reference types in return type of ‘{0}’ doesn’t match implicitly implemented member ‘{1}’ (possibly because of nullability attributes).
CS8767WarningNullability of reference types in type of parameter ‘{0}’ of ‘{1}’ doesn’t match implicitly implemented member ‘{2}’ (possibly because of nullability attributes).
CS8768WarningNullability of reference types in return type doesn’t match implemented member ‘{0}’ (possibly because of nullability attributes).
CS8769WarningNullability of reference types in type of parameter ‘{0}’ doesn’t match implemented member ‘{1}’ (possibly because of nullability attributes).
CS8770WarningMethod ‘{0}’ lacks [DoesNotReturn] annotation to match implemented or overridden member.
CS8771ErrorOutput directory could not be determined
CS8772Errorstdin argument ‘-‘ is specified, but input has not been redirected from the standard input stream.
CS8773ErrorFeature ‘{0}’ is not available in C# 9.0. Please use language version {1} or greater.
CS8774WarningMember ‘{0}’ must have a non-null value when exiting.
CS8775WarningMember ‘{0}’ must have a non-null value when exiting with ‘{1}’.
CS8776WarningMember ‘{0}’ cannot be used in this attribute.
CS8777WarningParameter ‘{0}’ must have a non-null value when exiting.
CS8778WarningConstant value ‘{0}’ may overflow ‘{1}’ at runtime (use ‘unchecked’ syntax to override)
CS8779Error‘{0}’ is already listed in the interface list on type ‘{2}’ as ‘{1}’.
CS8780ErrorA variable may not be declared within a ‘not’ or ‘or’ pattern.
CS8781ErrorRelational patterns may not be used for a value of type ‘{0}’.
CS8782ErrorRelational patterns may not be used for a floating-point NaN.
CS8783ErrorLocal function ‘{0}’ must be ‘static’ in order to use the Conditional attribute
CS8784WarningGenerator ‘{0}’ failed to initialize. It will not contribute to the output and compilation errors may occur as a result. Exception was of type ‘{1}’ with message ‘{2}’
CS8785WarningGenerator ‘{0}’ failed to generate source. It will not contribute to the output and compilation errors may occur as a result. Exception was of type ‘{1}’ with message ‘{2}’
CS8786ErrorCalling convention of ‘{0}’ is not compatible with ‘{1}’.
CS8787ErrorCannot convert method group to function pointer (Are you missing a ‘&’?)
CS8788ErrorCannot use an extension method with a receiver as the target of a ‘&’ operator.
CS8789ErrorThe type of a local declared in a fixed statement cannot be a function pointer type.
CS8790ErrorAn expression tree may not contain a pattern System.Index or System.Range indexer access
CS8791ErrorAn expression tree may not contain a from-end index (‘^’) expression.
CS8792ErrorAn expression tree may not contain a range (‘..’) expression.
CS8793WarningThe given expression always matches the provided pattern.
CS8794WarningAn expression of type ‘{0}’ always matches the provided pattern.
CS8795ErrorPartial method ‘{0}’ must have an implementation part because it has accessibility modifiers.
CS8796ErrorPartial method ‘{0}’ must have accessibility modifiers because it has a non-void return type.
CS8797ErrorPartial method ‘{0}’ must have accessibility modifiers because it has ‘out’ parameters.
CS8798ErrorPartial method ‘{0}’ must have accessibility modifiers because it has a ‘virtual’, ‘override’, ‘sealed’, ‘new’, or ‘extern’ modifier.
CS8799ErrorBoth partial method declarations must have identical accessibility modifiers.
CS8800ErrorBoth partial method declarations must have identical combinations of ‘virtual’, ‘override’, ‘sealed’, and ‘new’ modifiers.
CS8801ErrorCannot use local variable or local function ‘{0}’ declared in a top-level statement in this context.
CS8802ErrorOnly one compilation unit can have top-level statements.
CS8803ErrorTop-level statements must precede namespace and type declarations.
CS8804ErrorCannot specify /main if there is a compilation unit with top-level statements.
CS8805ErrorProgram using top-level statements must be an executable.
CS8806ErrorThe calling convention of ‘{0}’ is not supported by the language.
CS8807Error‘{0}’ is not a valid calling convention specifier for a function pointer.
CS8808Error‘{0}’ is not a valid function pointer return type modifier. Valid modifiers are ‘ref’ and ‘ref readonly’.
CS8809ErrorA return type can only have one ‘{0}’ modifier.
CS8810Error‘&’ on method groups cannot be used in expression trees
CS8811ErrorCannot convert &method group ‘{0}’ to delegate type ‘{0}’.
CS8812ErrorCannot convert &method group ‘{0}’ to non-function pointer type ‘{1}’.
CS8813ErrorA module initializer must be an ordinary member method
CS8814ErrorModule initializer method ‘{0}’ must be accessible at the module level
CS8815ErrorModule initializer method ‘{0}’ must be static, must have no parameters, and must return ‘void’
CS8816ErrorModule initializer method ‘{0}’ must not be generic and must not be contained in a generic type
CS8817ErrorBoth partial method declarations must have the same return type.
CS8818ErrorPartial method declarations must have matching ref return values.
CS8819WarningNullability of reference types in return type doesn’t match partial method declaration.
CS8820ErrorA static anonymous function cannot contain a reference to ‘{0}’.
CS8821ErrorA static anonymous function cannot contain a reference to ‘this’ or ‘base’.
CS8822ErrorMethod ‘{0}’ specifies a ‘default’ constraint for type parameter ‘{1}’, but corresponding type parameter ‘{2}’ of overridden or explicitly implemented method ‘{3}’ is constrained to a reference type or a value type.
CS8823ErrorThe ‘default’ constraint is valid on override and explicit interface implementation methods only.
CS8824WarningParameter ‘{0}’ must have a non-null value when exiting because parameter ‘{1}’ is non-null.
CS8825WarningReturn value must be non-null because parameter ‘{0}’ is non-null.
CS8826WarningPartial method declarations ‘{0}’ and ‘{1}’ have signature differences.
CS8830Error‘{0}’: Target runtime doesn’t support covariant return types in overrides. Return type must be ‘{2}’ to match overridden member ‘{1}’
CS8831Error‘{0}’: Target runtime doesn’t support covariant types in overrides. Type must be ‘{2}’ to match overridden member ‘{1}’
CS8846WarningThe switch expression does not handle all possible values of its input type (it is not exhaustive). For example, the pattern ‘{0}’ is not covered. However, a pattern with a ‘when’ clause might successfully match this value.
CS8847WarningThe switch expression does not handle some null inputs (it is not exhaustive). For example, the pattern ‘{0}’ is not covered. However, a pattern with a ‘when’ clause might successfully match this value.
CS8848WarningOperator ‘{0}’ cannot be used here due to precedence. Use parentheses to disambiguate.
CS8849ErrorAn expression tree may not contain a with-expression.
CS8850WarningThe assembly ‘{0}’ containing type ‘{1}’ references .NET Framework, which is not supported.
CS8851Warning‘{0}’ defines ‘Equals’ but not ‘GetHashCode’
CS8852ErrorInit-only property or indexer ‘{0}’ can only be assigned in an object initializer, or on ‘this’ or ‘base’ in an instance constructor or an ‘init’ accessor.
CS8853Error‘{0}’ must match by init-only of overridden member ‘{1}’
CS8854Error‘{0}’ does not implement interface member ‘{1}’. ‘{2}’ cannot implement ‘{1}’.
CS8855ErrorAccessors ‘{0}’ and ‘{1}’ should both be init-only or neither
CS8856ErrorThe ‘init’ accessor is not valid on static members
CS8857ErrorThe receiver of a with expression must have a non-void type.
CS8858ErrorThe receiver type ‘{0}’ is not a valid record type and is not a struct type.
CS8859ErrorMembers named ‘Clone’ are disallowed in records.
CS8860WarningTypes and aliases should not be named ‘record’.
CS8861ErrorUnexpected argument list.
CS8862ErrorA constructor declared in a record with parameter list must have ‘this’ constructor initializer.
CS8863ErrorOnly a single record partial declaration may have a parameter list
CS8864ErrorRecords may only inherit from object or another record
CS8865ErrorOnly records may inherit from records.
CS8866ErrorRecord member ‘{0}’ must be a readable instance property or field of type ‘{1}’ to match positional parameter ‘{2}’.
CS8867ErrorNo accessible copy constructor found in base type ‘{0}’.
CS8868ErrorA copy constructor in a record must call a copy constructor of the base, or a parameterless object constructor if the record inherits from object.
CS8869Error‘{0}’ does not override expected method from ‘object’.
CS8870Error‘{0}’ cannot be sealed because containing record is not sealed.
CS8871Error‘{0}’ does not override expected method from ‘{1}’.
CS8872Error‘{0}’ must allow overriding because the containing record is not sealed.
CS8873ErrorRecord member ‘{0}’ must be public.
CS8874ErrorRecord member ‘{0}’ must return ‘{1}’.
CS8875ErrorRecord member ‘{0}’ must be protected.
CS8876Error‘{0}’ does not override expected property from ‘{1}’.
CS8877ErrorRecord member ‘{0}’ may not be static.
CS8878ErrorA copy constructor ‘{0}’ must be public or protected because the record is not sealed.
CS8879ErrorRecord member ‘{0}’ must be private.
CS8880WarningAuto-implemented property ‘{0}’ must be fully assigned before control is returned to the caller.
CS8881WarningField ‘{0}’ must be fully assigned before control is returned to the caller
CS8882WarningThe out parameter ‘{0}’ must be assigned to before control leaves the current method
CS8883WarningUse of possibly unassigned auto-implemented property ‘{0}’
CS8884WarningUse of possibly unassigned field ‘{0}’
CS8885WarningThe ‘this’ object cannot be used before all of its fields have been assigned
CS8886WarningUse of unassigned out parameter ‘{0}’
CS8887WarningUse of unassigned local variable ‘{0}’
CS8888Error‘managed’ calling convention cannot be combined with unmanaged calling convention specifiers.
CS8889ErrorThe target runtime doesn’t support extensible or runtime-environment default calling conventions.
CS8890ErrorType ‘{0}’ is not defined.
CS8891ErrorType ‘{0}’ must be public to be used as a calling convention.
CS8892WarningMethod ‘{0}’ will not be used as an entry point because a synchronous entry point ‘{1}’ was found.
CS8893Error‘{0}’ is not a valid calling convention type for ‘UnmanagedCallersOnly’.
CS8894ErrorCannot use ‘{0}’ as a {1} type on a method attributed with ‘UnmanagedCallersOnly’.
CS8895ErrorMethods attributed with ‘UnmanagedCallersOnly’ cannot have generic type parameters and cannot be declared in a generic type.
CS8896Error‘UnmanagedCallersOnly’ can only be applied to ordinary static non-abstract methods or static local functions.
CS8897Warning‘{0}’: static types cannot be used as parameters
CS8898Warning‘{0}’: static types cannot be used as return types
CS8899ErrorApplication entry points cannot be attributed with ‘UnmanagedCallersOnly’.
CS8900ErrorModule initializer cannot be attributed with ‘UnmanagedCallersOnly’.
CS8901Error‘{0}’ is attributed with ‘UnmanagedCallersOnly’ and cannot be called directly. Obtain a function pointer to this method.
CS8902Error‘{0}’ is attributed with ‘UnmanagedCallersOnly’ and cannot be converted to a delegate type. Obtain a function pointer to this method.
CS8903Error‘init’ accessors cannot be marked ‘readonly’. Mark ‘{0}’ readonly instead.
CS8904ErrorInvalid variance: The type parameter ‘{1}’ must be {3} valid on ‘{0}’ unless language version ‘{4}’ or greater is used. ‘{1}’ is {2}.
CS8905ErrorA function pointer cannot be called with named arguments.
CS8906ErrorRecord equality contract property ‘{0}’ must have a get accessor.
CS8907WarningParameter ‘{0}’ is unread. Did you forget to use it to initialize the property with that name?
CS8908ErrorThe type ‘{0}’ may not be used for a field of a record.
CS8909WarningComparison of function pointers might yield an unexpected result, since pointers to the same function may be distinct.
CS8910ErrorThe primary constructor conflicts with the synthesized copy constructor.
CS8911ErrorUsing a function pointer type in a ‘typeof’ in an attribute is not supported.
CS8912ErrorInheriting from a record with a sealed ‘Object.ToString’ is not supported in C# {0}. Please use language version ‘{1}’ or greater.
CS8913ErrorThe positional member ‘{0}’ found corresponding to this parameter is hidden.
CS8914ErrorA global using directive cannot be used in a namespace declaration.
CS8915ErrorA global using directive must precede all non-global using directives.
CS8916ErrorAttributes on lambda expressions require a parenthesized parameter list.
CS8917ErrorThe delegate type could not be inferred.
CS8918ErrorIdentifier or a simple member access expected.
CS8919ErrorTarget runtime doesn’t support static abstract members in interfaces.
CS8920ErrorThe interface ‘{3}’ cannot be used as type parameter ‘{2}’ in the generic type or method ‘{0}’. The constraint interface ‘{1}’ or its base interface has static abstract members.
CS8921ErrorThe parameter of a unary operator must be the containing type, or its type parameter constrained to it.
CS8922ErrorThe parameter type for ++ or — operator must be the containing type, or its type parameter constrained to it.
CS8923ErrorThe return type for ++ or — operator must either match the parameter type, or be derived from the parameter type, or be the containing type’s type parameter constrained to it unless the parameter type is a different type parameter.
CS8924ErrorOne of the parameters of a binary operator must be the containing type, or its type parameter constrained to it.
CS8925ErrorThe first operand of an overloaded shift operator must have the same type as the containing type or its type parameter constrained to it, and the type of the second operand must be int
CS8926ErrorA static abstract interface member can be accessed only on a type parameter.
CS8927ErrorAn expression tree may not contain an access of static abstract interface member
CS8928Error‘{0}’ does not implement static interface member ‘{1}’. ‘{2}’ cannot implement the interface member because it is not static.
CS8929Error‘{0}’ cannot implement interface member ‘{1}’ in type ‘{2}’ because the target runtime doesn’t support static abstract members in interfaces.
CS8930ErrorExplicit implementation of a user-defined operator ‘{0}’ must be declared static
CS8931ErrorUser-defined conversion in an interface must convert to or from a type parameter on the enclosing type constrained to the enclosing type
CS8932Error‘UnmanagedCallersOnly’ method ‘{0}’ cannot implement interface member ‘{1}’ in type ‘{2}’
CS8933HiddenThe using directive for ‘{0}’ appeared previously as global using
CS8934ErrorCannot convert {0} to type ‘{1}’ because the return type does not match the delegate return type
CS8935ErrorThe AsyncMethodBuilder attribute is disallowed on anonymous methods without an explicit return type.
CS8936ErrorFeature ‘{0}’ is not available in C# 10.0. Please use language version {1} or greater.
CS8937ErrorAt least one top-level statement must be non-empty.
Newsletter Signup

Subscribe to our weekly newsletter below and never miss the latest product or an exclusive offer.

Newsletter Signup

Subscribe to our weekly newsletter below and never miss the latest product or an exclusive offer.

%d bloggers like this: