Browse through various articles and courses for Free at DeveloperPublish.com

    Get Started
    HomeCSharpC# Compiler Error Codes CS0001 to CS0500

    C# Compiler Error Codes CS0001 to CS0500

    admin September 22, 2022 No Comments

    In this post, you’ll learn all the C# compiler error and warnings from the code CS0001 to CS0500.

    C# Compiler Error Codes CS0001 to CS0500

    Error CodeTypeError/Warning Description
    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, methods or statements
    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. Consider updating to language version ‘{1}’ to auto-default the field.
    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. Consider updating to language version ‘{0}’ to auto-default the unassigned fields.
    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 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 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.
    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

    Tag:
    Share:

    Leave a Reply

    You May Also Like

    See more

    C# Program to Display Upper Triangular Matrix

    This C# program calculates and displays an upper triangular matrix based on user input. Problem Statement: The program takes the...
    Read more

    C# Program to Demonstrate Bitwise Operators

    This C# program serves as a demonstration of bitwise operators, which are fundamental operators used for manipulating individual bits in...
    Read more

    C# Program to Interchange the Columns of a Matrix

    This C# program is designed to interchange or swap the columns of a matrix. A matrix is a two-dimensional array...
    Read more