United States (English)

Home Library Learn Samples Downloads Support Community Forums

MSDN Library

Development Tools and Languages

Visual Studio 2008

Visual Studio

Visual Basic

Reference (Visual Basic)

Visual Basic Reference

Compiler Messages

'-' expected

'!' requires its left operand to have a type parameter, class or interface type, but this operand has the type '<type>'

'#Else' must be preceded by a matching '#If' or '#ElseIf'

'#ElseIf' cannot follow '#Else' as part of an '#If' block

'#ElseIf' must be preceded by a matching '#If' or '#ElseIf'

'#ElseIf', '#Else', or '#End If' must be preceded by a matching '#If'

'#End ExternalSource' must be preceded by a matching '#ExternalSource'

'#End Region' must be preceded by a matching '#Region'

'#ExternalSource' directives cannot be nested

'#ExternalSource' statement must end with a matching '#End ExternalSource'

'#If' block must end with a matching '#End If'

'#Region' and '#End Region' statements are not valid within method bodies

'#Region' statement must end with a matching '#End Region'

'(' expected

')' expected

'.' expected

':' is not allowed

'{' expected

'}' expected

'<argumentname>' is not a parameter of '<methoddeclaration>'

'<assemblyname>' is an assembly and cannot be referenced as a module

'<attribute>' cannot be applied because the format of the GUID '<number>' is not correct

'<attributename>' cannot be applied more than once to an assembly

'<baseinterfacename>.<membername>' from 'implements <derivedinterfacename>' is already implemented by the base class '<baseclassname>'. Re-implementation of <type> assumed

'<classname>' is not CLS-compliant because it derives from '<baseclassname>', which is not CLS-compliant

'<classname>' is not CLS-compliant because the interface '<interfacename>' it implements is not CLS-compliant

'<classname1>' cannot inherit from <type> '<classname2>' because '<classname2>' is declared 'NotInheritable'

'<constructor>' in designer-generated type '<type>' should call InitializeComponent method

'<declaration1>' cannot override '<declaration2>' because it is declared 'NotOverridable'

'<declaration1>' cannot override '<declaration2>' because it is declared 'Shared'

'<declaration1>' cannot override '<declaration2>' because they have different access levels

'<derivedtypename>' cannot inherit from <type> '<constructedbasetypename>' because it expands the access of type '<internaltypename>' outside the assembly

'<derivedtypename>' cannot inherit from <type> '<constructedbasetypename>' because it expands the access of type '<internaltypename>' to <region> '<regionname>'

'<elementname>' cannot be declared 'Partial' because partial methods must be Subs

'<elementname>' for the Imports alias to '<qualifiedelementname>' does not refer to a Namespace, Class, Structure, Interface, Enum or Module

'<elementname>' is ambiguous because multiple kinds of members with this name exist in <type> '<typename>'

'<elementname>' is not a method parameter

'<elementname>' is not a parameter of extension method '<methodname>' defined in '<typename>'

'<elementname>' is obsolete (Visual Basic Error)

'<elementname>' is obsolete (Visual Basic Warning)

'<elementname>' is obsolete: '<errormessage>'

'<elementname>' refers to type '<typename>' in project '<projectname>', but type '<typename>' was not found in project '<projectname>'

'<emptyconstant>' is not declared

<error>: '<classname1>' inherits from '<classname2>'

<error>: '<constructorname1>' calls '<constructorname2>'

<error>: '<structurename1>' contains '<structurename2>'

'<eventname>' implicitly defines '<membername>', which conflicts with a member implicitly declated in <type> '<typename>'

'<eventname>' is an event, and cannot be called directly

'<eventname>' is not an event of '<containername>'

'<expression>' cannot be used as a type constraint

'<filename>' cannot be referenced because it is not an assembly

'<function>' is not declared

'<functionname>' is not declared (Smart Device/Visual Basic Compiler Error)

'<functionname>' is not declared (Visual Basic Error)

'<implementsclause>' cannot implement '<typename>' because '<typename>' is a reserved name

'<interfacename>.<membername>' is already implemented by the base class '<baseclassname>'. Re-implementation of <type> assumed

'<interfacename1>' cannot implement '<methodname>' because there is no matching <method> on interface '<interfacename2>'

'<keyword>' accessor of '<propertyname>' is obsolete (Visual Basic Error)

'<keyword>' accessor of '<propertyname>' is obsolete (Visual Basic Warning)

'<keyword>' accessor of '<propertyname>' is obsolete: '<errormessage>' (Visual Basic Error)

'<keyword>' accessor of '<propertyname>' is obsolete: '<errormessage>' (Visual Basic Warning)

'<keyword>' is not valid within a Module

'<keyword>' is not valid within a structure

'<keyword>' is valid only within a class

'<keyword>' is valid only within an instance method

'<lsetstmt>' is not declared

'<mathfunction1>' is not declared

'<member>' conflicts with the reserved member by this name that is implicitly declared in all enums

'<member>' is already declared in this structure

'<member>', implicitly defined for '<eventname>', cannot shadow a 'MustOverride' method in the base <class> '<classname>'

'<membername>' cannot be declared 'Shadows' outside of a class, structure, or interface

'<membername>' cannot expose type '<typename>' outside the project through <containertype> '<containertypename>'

'<membername>' cannot implement '<interfacename>.<interfacemembername>' because they differ by type parameter constraints

'<membername>' exists in multiple base interfaces

'<membername> has the same name as a type parameter

'<membername>' is already declared by '<procedurename>', which was generated for this <containername>

'<membername>' is ambiguous across the inherited interfaces '<interfacename1>' and '<interfacename2>'

'<membername>' is not a member of '<contextname>'; it does not exist in the current context

'<membername>' is not declared

'<membername>' is not declared or the module containing it is not loaded in the debugging session

'<membername>' is obsolete: '<errormessage>'

'<membername1>' and '<membername2>' cannot overload each other because they differ only by the types of optional parameters

'<membername1>' cannot override '<membername2>' because they differ by the types of optional parameters

<message> This error could also be due to mixing a file reference to '<filename1>' in project '<projectname1>' with a file reference to '<filename2>' in project '<projectname2>'

<message> This error could also be due to mixing a file reference with a project reference to assembly '<assemblyname>'

<method> '<methodname1>' must be declared 'Overloads' because another '<methodname2>' is declared 'Overloads'

'<method>' is not accessible in this context because it is '<modifier>'

'<method1>' and '<method2>' cannot overload each other because they differ only by optional parameters

'<method1>' and '<method2>' cannot overload each other because they differ only by parameters declared 'ByRef' or 'ByVal'

'<method1>' and '<method2>' cannot overload each other because they differ only by parameters declared 'ParamArray'

'<method1>' and '<method2>' cannot overload each other because they differ only by return types

'<method1>' and '<method2>' cannot overload each other because they differ only by the default values of optional parameters

'<method1>' cannot override '<method2>' because it expands the access of the base method

'<method1>' cannot override '<method2>' because it is a 'Declare' statement

'<method1>' cannot override '<method2>' because they differ by a parameter that is marked as 'ByRef' versus 'ByVal'

'<method1>' cannot override '<method2>' because they differ by optional parameters

'<method1>' cannot override '<method2>' because they differ by the default values of optional parameters

'<method1>' cannot override '<method2>' because they differ by their return types

<methodname>' and '<methodname>' cannot overload each because they differ by 'ReadOnly' or 'WriteOnly'

'<methodname>' cannot be implemented more than once

'<methodname>' cannot override a method that has been shadowed

'<methodname>' cannot shadow a method declared 'MustOverride'

'<methodname>' has multiple definitions with identical signatures

'<methodname>' is not accessible in this context because the return type is not accessible

'<modifier>' is not valid on a Declare

'<modifier>' is not valid on a Delegate declaration

'<modifier>' is not valid on a local constant declaration

'<modifier>' is not valid on a local variable declaration

'<modifier>' is not valid on a method declaration

'<modifier>' is not valid on an event declaration

'<modifier>' is not valid on an Interface declaration

'<modulename>' is a module and cannot be referenced as an assembly

'<name>' cannot be named as a parameter in an attribute specifier because it is not a field or property

'<name>' cannot expose the underlying delegate type '<delegatetype>' of the event it is implementing outside the project through <specifier> '<type>'

'<name>' cannot expose the underlying delegate type '<delegatetype>' of the event it is implementing to <specifier1> '<type1>' through <specifier2> '<type2>'

'<name>' cannot expose type '<type>' used in the underlying delegate type '<delegatetype>' of the event it is implementing to <specifier1> '<type1>' through <specifier2> '<type2>'

'<name>' cannot expose type <type1> in <specifier> <type2> '<typename>' through <name>

'<name>' cannot expose type '<type1>' used in the underlying delegate type '<delegatetype>' of the event it is implementing outside the project through <specifier> '<type2>'

'<name>' cannot refer to itself through its default instance, use 'Me' instead

'<name>' is already declared as '<declaration>' in this <declarationspace>

'<name>' is already declared as a parameter of this method

'<name>' is ambiguous between declarations in Modules '<modulename1>' and '<modulename2>'

'<name>' is ambiguous in the application objects '<list>'

'<name>' is ambiguous in the namespace '<namespacename>'

'<name>' is declared in project '<projectname1>', which is not referenced by project '<projectname2>'

'<name>' is not a member of '<classname>'

'<name>', necessary for compiling this construct, cannot be found

'<name1>' conflicts with a <type> by the same name defined in '<name2>'

'<name1>' for the Imports '<name2>' does not refer to a Namespace, Class, Structure, Enum or Module

'<name1>' is ambiguous, imported from the namespaces or types '<name2>'

'<namespace>' is not a valid name and cannot be used as the root namespace name

'<namespacename>' is ambiguous

'<nullconstant>' is not declared

'<parametername>' is already declared as a type parameter of this method

'<procedure1>' and '<procedure2>' cannot overload each other because they differ only by parameters declared 'ByRef' or 'ByVal'

'<procedurename>' cannot override '<baseprocedurename>' because they differ by type parameter constraints

'<procedurename>' has a return type that is not supported or parameter types that are not supported

'<procedurename>' has no parameters and its return type cannot be indexed

'<procedurename>' method for event '<eventname>' cannot be marked CLS compliant because its containing type '<typename>' is not CLS compliant

'<procedurename1>' cannot override '<procedurename2>' because it is not accessible in this context

<procedurename1> cannot override <procedurename2> because they differ by parameters declared 'ParamArray'

<proceduresignature1> is not CLS-compliant because it overloads <proceduresignature2> which differs from it only by array of array parameter types or by the rank of the array parameter types

<Property> parameters cannot be declared 'ByRef'

'<property1>' and '<property2>' cannot overload each other because only one is declared 'Default'

'<propertyname>' cannot be exposed to COM as a property 'Let'

'<propertyname>' implicitly defines '<membername>', which conflicts with a member of the same name in <type> '<typename>'

'<propertyname1>' cannot override '<propertyname2>' because they differ by 'ReadOnly' or 'WriteOnly'

'<qualifiedmethod>' is not accessible in this context because it is '<modifier>'

'<rsetstmt>' is not declared

'<specifier>' is not valid on a constant declaration

'<specifier>' is not valid on a member variable declaration

'<specifier>' is not valid on a Structure declaration

'<specifier>' is not valid on a WithEvents declaration

'<specifier>' is not valid on an Enum declaration

'<specifier>' is not valid on an interface event declaration

'<specifier>' is not valid on an interface method declaration

'<specifier>' is not valid on an interface property declaration

<specifier1> <type> cannot inherit from a <specifier2> <type> because it expands the access of the base <type>

'<specifier1>' and '<specifier2>' cannot be combined

'<statementname>' statement requires an array

<type> '<methodname>' conflicts with other members of the same name across the inheritance hierarchy and so should be declared 'Shadows'

<type> '<typename>' shadows an overridable method in the base class

'<type>' cannot be inherited more than once

<type> parameters cannot be declared 'Optional'

<type> parameters cannot be declared 'ParamArray'

<type1> '<membername>' conflicts with <type2> '<membername>' on the base class <type3> '<classname>' and should be declared 'Shadows'

<type1> '<membername>' shadows an overloadable member declared in the base <type2> '<classname>'

<type1> '<propertyname>' conflicts with a member implicitly declared for event '<eventname>' in the base <type2> '<classname>'

<type1> '<typename>' and <type2> '<typename>' conflict in <namespace> '<namespacename>'

<type1> '<typename>' and <type2> '<typename>', declared in '<name>', conflict in <namespace> '<namespacename>'

<type1> '<typename>' cannot be declared 'Overrides' because it does not override a <type1> in a base <type2>

<type1> '<typename1>' conflicts with a member implicitly declared for event '<eventname>' in <type2> '<typename2>'

'<type1>' cannot override <type2> because it is not declared 'Overridable'

<type1>'<typename>' must implement '<membername>' for interface '<interfacename>'

<type1>'<typename>' must implement '<methodname>' for interface '<interfacename>'

<typename> '<membername>' must be declared 'Shadows' because another member with this name is declared 'Shadows'

'<typename>' cannot be used as an attribute because it does not have a 'System.AttributeUsageAttribute' attribute

'<typename>' cannot be used as an attribute because it does not inherit from 'System.Attribute'

'<typename>' cannot be used as an attribute because it has 'MustOverride' methods that have not been overridden

'<typename>' cannot be used as an attribute because it is declared 'MustInherit'

'<typename>' cannot be used as an attribute because it is not a class

'<typename>' cannot inherit from <type> '<basetypename>' because it expands the access of the base <type> outside the assembly

'<typename>' cannot shadow a 'MustOverride' method implicitly declared for property '<propertyname>' in <type> '<typename>'

'<typename>' has the same name as another type exposed in a 'My' group

'<typename>' in assembly '<assemblyname>' has been forwarded to itself and so is an unsupported type

'<typename>' is a class type and cannot be used as an expression

'<typename>' is a delegate type

'<typename>' is a generic type and requires type arguments

'<typename>' is a namespace and cannot be used as an expression

'<typename>' is a structure type and cannot be used as an expression

'<typename>' is a type and cannot be used as an expression

'<typename>' is a type in '<containername>' and cannot be used as an expression

'<typename>' is an Enum type and cannot be used as an expression

'<typename>' is an interface type and cannot be used as an expression

'<typename>' is an unsupported type

'<typename>' must be declared 'MustInherit' because it contains methods declared 'MustOverride'

'<typename>' values cannot be converted to 'Char'

'<typename1>' cannot be converted to '<typename2>'

'<variablename>' is not a local variable or parameter, and so cannot be used as a 'Catch' variable

<Variablename>' will not be inferred because it is a static local variable

'=' expected (Declaration)

'=' expected (Let or Set assignment)

'=' expected (object initializer)

'>' expected

A nullable type cannot be inferred for variable '<variablename>'

Access modifier '<accessmodifier>' is not valid

Access modifier can only be applied to either 'Get' or Set', but not both

Access of shared member through an instance; qualifying expression will not be evaluated

'AddHandler' and 'RemoveHandler' method parameters cannot be declared 'ByRef'

'AddHandler' and 'RemoveHandler' method parameters must have the same delegate type as the containing event

'AddHandler' and 'RemoveHandler' methods must have exactly one parameter

'AddHandler' declaration must end with a matching 'End AddHandler'

'AddHandler' definition missing for event '<eventname>'

'AddHandler' is already declared

'AddHandler' or 'RemoveHandler' statement event operand must be a dot-qualified expression or a simple name

'AddHandler', 'RemoveHandler' and 'RaiseEvent' method parameters cannot be declared '<modifier>'

'AddressOf' cannot be applied to 'methodname' because 'methodname' is a partial method

'AddressOf' expression cannot be converted to '<typename>' because '<typename>' is not a delegate type

'AddressOf' expression cannot be converted to '<typename>' because type '<typename>' is declared 'MustInherit' and cannot be created

'AddressOf' expressions are not valid in debug windows

'AddressOf' expressions are not valid in the first expression of a 'Select Case' statement

'AddressOf' operand must be the name of a method (without parentheses)

Aggregate function name cannot be used with a type character

Alias '<namespacename>' is already declared

All parameters must be explicitly typed if any are

All projects in a Visual Basic solution must target the same platform, but the project you are trying to add targets a platform other than the one specified by your solution

An embedded expression may not be used here

Anonymous type initializers are not valid in debug windows

Anonymous type member name can be inferred only from a simple or qualified name with no arguments

Anonymous type member name must be preceded by a period

Anonymous type member or property '<propertyname>' is already declared

Anonymous type member property '<propertyname>' cannot be used to infer the type of another member property because the type of '<propertyname>' is not yet established

Anonymous type must contain at least one member

Anonymous type property '<propertyname>' cannot be used in the definition of a lambda expression within the same initialization list

Argument matching parameter '<parametername>' narrows from '<type1>' to '<type2>'

Argument matching parameter '<parametername>' narrows to '<typename>'

Argument not specified for parameter '<parametername>'

Argument not specified for parameter '<parametername>' of '<methodname>'

Argument not specified for parameter '<parametername>' of extension method '<methodname>' defined in '<typename>'

Arguments cannot be passed to a 'New' used on a type parameter

Array bounds cannot appear in type specifiers

Array declarations cannot specify lower bounds

Array declared as for loop control variable cannot be declared with an initial size

Array dimensions cannot have a negative size

Array exceeds the limit of 32 dimensions

Array initializer cannot be specified for a non constant dimension; use the empty initializer '{}'

Array initializer has <number> too many elements

Array initializer has too few dimensions

Array initializer has too many dimensions

Array initializer is missing <number> elements

Array initializers are valid only for arrays, but the type of '<variablename>' is '<typename>'

Array lower bounds can be only '0'

Array modifiers cannot be specified on both a variable and its type

Array modifiers cannot be specified on lambda expression parameters name, only on its type

Array subscript expression missing

Arrays cannot be declared with 'New'

Arrays declared as structure members cannot be declared with an initial size

Arrays of type 'System.Void' are not allowed in this expression

Arrays used as attribute arguments are required to explicitly specify values for all elements

'As Any' is not supported in 'Declare' statements

'As' expected

'As', comma or ')' expected

Assembly '<assemblyname>' cannot be created because its path is longer than 259 characters

Assembly '<filepath1>' references assembly '<assemblyidentity>', which is ambiguous between '<filepath2>' (referenced by project '<projectname1>') and '<filepath3>' (referenced by project '<projectname2>')

Assembly '<filepath1>' references assembly '<assemblyidentity>', which is ambiguous between '<filepath2>' and '<filepath3>'

Assembly attribute '<attributename>' is not valid: <error>

Assembly or Module attribute statements must precede any declarations in a file

'Assembly' or 'Module' expected

At least one parameter type of this binary operator must be the containing type '<typename>'

Attribute '<attributename>' cannot be applied multiple times

Attribute '<attributename>' cannot be applied to '<membername>' because the attribute is not valid on this declaration type

Attribute '<attributename>' cannot be applied to a method with optional parameters

Attribute '<attributename>' cannot be applied to a module

Attribute '<attributename>' cannot be applied to an assembly

Attribute '<attributename>' cannot be specified more than once in this project, even with identical parameter values

Attribute '<attributename>' is not valid: <error>

Attribute cannot be used because it does not have a Public constructor

Attribute 'Conditional' is only valid on 'Sub' declarations

Attribute constant '<constantname>' cannot be the target of an assignment

Attribute constructor has a 'ByRef' parameter of type '<typename>'; cannot use constructors with byref parameters to apply the attribute

Attribute constructor has a parameter of type '<type>', which is not an integral, floating-point, or Enum type or one of Char, String, Boolean, System.Type or 1-dimensional array of these types

Attribute member '<membername>' cannot be the target of an assignment because it is not declared 'Public'

Attribute specifier is not a complete statement

Attribute 'System.Runtime.InteropServices.DefaultCharSetAttribute' is not supported in this version

Attribute value is not valid; expecting 'value'

Attribute value is not valid; expecting 'value1' or 'value2'

Attributes cannot be applied to local variables

Attributes cannot be applied to parameters of lambda expressions

Attributes cannot be generics or types nested inside generics

Bad checksum value, non hex digits or odd number of hex digits

Bad GUID format

Badly formed XML. File '<commentfile>' cannot be included

Base class '<baseclassname1>' specified for class '<partialclassname>' cannot be different from the base class '<baseclassname2>' of one of its other partial types

Bounds can be specified only for the top-level array when initializing an array of arrays

Bracketed identifier is missing closing ']'

Branching out of a 'Finally' is not valid

'By' expected

'ByRef' parameter '<parametername>' cannot be used in a lambda expression

'ByRef' parameter <parametername> cannot be used in a query expression

'ByVal' and 'ByRef' cannot be combined

Cannot convert anonymous type to expression tree because it contains a field that is used in the initialization of another field

Cannot convert to '<type>'

Cannot convert 'type1' to 'type2'

Cannot copy the value of 'ByRef' parameter '<parametername>' back to the matching argument because type '<typename1>' cannot be converted to type '<typename2>'

Cannot create an instance of Module '<modulename>'

Cannot find .NET Framework directory: <error>

Cannot implement '<interfacename1>.<membername>' because its implementation could conflict with the implementation for '<interfacename2>.<membername>' for some type arguments

Cannot implement interface '<interfacename1>' because its implementation could conflict with the implementation of another implemented interface '<interfacename2>' for some type arguments

Cannot infer a common type for the first and second operands of the binary 'If' operator

Cannot infer a common type for the second and third operands of the 'If' operator

Cannot infer a data type for '<variablename>' because the array dimensions do not match

Cannot inherit interface '<interfacename1>' because it could be identical to interface '<interfacename2>' for some type arguments

Cannot inherit interface '<interfacename1>' because it could be identical to interface '<interfacename2>' from which the interface '<interfacename3>' inherits for some type arguments

Cannot inherit interface '<interfacename1>' because the interface '<interfacename2>' from which it inherits could be identical to interface '<interfacename3>' for some type arguments

Cannot inherit interface '<interfacename1>' because the interface '<interfacename2>' from which it inherits could be identical to interface '<interfacename3>' from which the interface '<interfacename4>' inherits for some type arguments

Cannot refer to '<name>' because it is a member of the value-typed field '<name>' of class '<classname>' which has 'System.MarshalByRefObject' as a base class

Cannot refer to an instance member of a class from within a shared method or shared member initializer without an explicit instance of the class

cannot send error report automatically

Cannot set the value of a local variable for a method that is not at the top of the stack

Cannot specify both /win32icon and /win32resource

Can't open '<filename>' for writing

'Case' can only appear inside a 'Select Case' statement

'Case' cannot follow a 'Case Else' in the same 'Select' statement

'Case Else' can only appear inside a 'Select Case' statement

'Case' statements are not valid in the Immediate window

Casing of namespace name '<namespacename1>' does not match casing of namespace name '<namespacename2>' in file '<filepath>'

'Catch' block never reached, because '<name1>' inherits from '<name2>'

'Catch' block never reached; <exception> handled above in the same 'Try' statement

'Catch' cannot appear after 'Finally' within a 'Try' statement

'Catch' cannot appear outside a 'Try' statement

'Catch' cannot catch type '<typename>' because it is not 'System.Exception' or a class that inherits from 'System.Exception'

'Catch' must end with a matching 'End Try'

'Catch' statements are not valid in the Immediate window

'Char' values cannot be converted to '<typename>'

Character 'character' (0x<hexadecimal>) is not allowed at the beginning of an XML name

Character 'character' (0x<hexadecimal>) is not allowed in an XML name

Character 'character' (0x<hexadecimal>) is not allowed in XML literal

Character constant must contain exactly one character

Character is not valid

Character sequence '--' is not allowed in an XML comment

Class '<classname>' cannot be found

Class '<classname>' cannot be indexed because it has no default property

Class '<classname>' cannot inherit from itself: <message>

Class '<classname>' could not be created: <error>

Class '<classname>' has no accessible 'Sub New' and cannot be inherited

Class '<classname>' must declare a 'Sub New' because its base class '<classname2>' does not have an accessible 'Sub New' that can be called with no arguments

Class '<classname>' must declare a 'Sub New' because the '<constructorname>' in its base class '<baseclassname>' is marked obsolete

Class '<classname>' must declare a 'Sub New' because the '<constructorname>' in its base class '<baseclassname>' is marked obsolete: '<errormessage>'

Class '<classname>' must either be declared 'MustInherit' or override the following inherited 'MustOverride' member(s): <membername(s)>

Class '<classname>' should declare a 'Sub New' because the '<constructorname>' in its base class '<baseclassname>' is marked obsolete

Class '<classname>' should declare a 'Sub New' because the '<constructorname>' in its base class '<baseclassname>' is marked obsolete: '<errormessage>'

Class '<classname1>' must declare a 'Sub New' because its base class '<classname2>' has more than one accessible 'Sub New' that can be called with no arguments

'Class' constraint and a specific class type constraint cannot be combined

'Class' constraint and 'Structure' constraint cannot be combined

'Class' constraint cannot be specified multiple times for the same type parameter

Class in an interface cannot be declared '<specifier>'

'Class' statement must end with a matching 'End Class'

'Class_Initialize' event is no longer supported

'Class_Terminate' event is no longer supported

Classes can inherit only from other classes

Classes cannot be declared '<specifier>'

Classes that are generic or contained in a generic type cannot inherit from an attribute class

Codepage '<name>' is invalid or not installed

Comma or ')' expected (Procedure Parameter List)

Comma or ')' expected (Type Argument List)

Comma or ')' expected (Type Parameter List)

Comma, ')', or a valid expression continuation expected

Comment statements cannot be evaluated.

'Compare' expected

Compilation failed: <message>

Conflict between the default property and the 'DefaultMemberAttribute' defined on '|1'

Conflicts with '<name1>', which is implicitly created for '<name2>' in <type> '<name3>'

Const declaration cannot have an array initializer

Constant '<constantname>' cannot depend on its own value

Constant cannot be the target of an assignment

Constant expression is required

Constant expression not representable in type '<typename>'

Constants must be of an intrinsic or enumerated type, not a class, structure, type parameter, or array type

Constants must have a value

Constraint '<constraint1>' conflicts with the constraint '<constraint2>' already specified for type parameter '<typeparametername>'

Constraint '<constraint1>' conflicts with the indirect constraint '<constraint2>' obtained from the type parameter constraint '<typeparameter1>'

Constraint type '<typename>' already specified for this type parameter

Constraints for this type parameter do not match the constraints on the corresponding type parameter defined on one of the other partial types of '|1'

Construct makes an indirect reference to assembly '<assemblyname>', which contains '<typename>'

Construct makes an indirect reference to project '<projectname>', which contains '<typename>'

Constructor '<name>' cannot call itself

Constructor call is valid only as the first statement in an instance constructor

Constructor must be declared as a Sub, not as a Function

Constructors cannot implement interface methods

'Continue Do' can only appear inside a 'Do' statement

'Continue For' can only appear inside a 'For' statement

'Continue' must be followed by 'Do', 'For' or 'While'

'Continue' statements are not valid in the Immediate window

'Continue While' can only appear inside a 'While' statement

Conversion from '<type1>' to '<type2>' cannot occur in a constant expression

Conversion from '<type1>' to '<type2>' cannot occur in a constant expression used as an argument to an attribute

Conversion from 'Date' to 'Double' requires calling the 'Date.ToOADate' method

Conversion from 'Double' to 'Date' requires calling the 'Date.FromOADate'

Conversion operators cannot convert from a base type

Conversion operators cannot convert from a derived type

Conversion operators cannot convert from a type to its base type

Conversion operators cannot convert from a type to its derived type

Conversion operators cannot convert from a type to the same type

Conversion operators cannot convert from an interface type

Conversion operators cannot convert from Object

Conversion operators cannot convert to an interface type

Conversion operators cannot convert to Object

Conversion operators must be declared either 'Widening' or 'Narrowing'

Conversions from '<typename1>' to '<typename2>' must be explicit

Copying the value of 'ByRef' parameter '<parametername>' back to the matching argument narrows from type '<typename1>' to type '<typename2>'

Could not find library '<libraryname>'

Could not find standard library: '<filename>'

'Currency' is no longer a supported type; use the 'Decimal' type instead

'Custom Event' must end with a matching 'End Event'

'Custom' modifier can only be used immediately before an 'Event' declaration

'Custom' modifier is not valid on events declared in interfaces

'Custom' modifier is not valid on events declared without explicit delegate types

'D' can no longer be used to indicate an exponent, use 'E' instead

Data type(s) of the type parameter(s) cannot be inferred from these arguments

Data type(s) of the type parameter(s) cannot be inferred from these arguments because more than one type is possible

Data type(s) of the type parameter(s) cannot be inferred from these arguments because they do not convert to the same type

Data type(s) of the type parameter(s) in extension method '<methodname>' defined in '<typename>' cannot be inferred from these arguments

Data type(s) of the type parameter(s) in extension method '<methodname>' defined in '<typename>' cannot be inferred from these arguments because more than one type is possible

Data type(s) of the type parameter(s) in extension method '<methodname>' defined in 'typename' cannot be inferred from these arguments because they do not convert to the same type

Data type(s) of the type parameter(s) in method '<methodname>' cannot be inferred from these arguments

Data type(s) of the type parameter(s) in method '<methodname>' cannot be inferred from these arguments because more than one type is possible

Data type(s) of the type parameter(s) in method '<methodname>' cannot be inferred from these arguments because they do not convert to the same type

Date constant is not valid

Declaration expected

'Declare' statements are not allowed in generic types or types contained in generic types

Declare statements in a Module cannot be declared '<specifier>'

'Declare' statements in a structure cannot be declared '<specifier>'

'Default' can be applied to only one property name in a <type>

'Default' cannot be combined with '<specifier>'

Default member '<membername>' is not a property

Default property '<propertyname1>' conflicts with default property '<propertyname2>' in '<classname>' and so should be declared 'Shadows'

Default property access is ambiguous between the inherited interface members '<defaultpropertyname>' of interface '<interfacename1>' and '<defaultpropertyname>' of interface '<interfacename2>'

Default values cannot be supplied for parameters that are not declared 'Optional'

Definition of method <method> is not accessible in this context

Delegate class '<classname>' has no Invoke method, so an expression of this type cannot be the target of a method call

Delegate constructor for type '<typename>', necessary for the implementation of delegates, cannot be found

Delegate in an interface cannot be declared '<specifier>'

Delegate type '<delegatename>' of event '<eventname>' is not CLS-compliant

Delegates cannot handle events

Delegates cannot implement interface methods

Derived classes cannot raise base class events

Division by zero occurred while evaluating this expression

'Do' must end with a matching 'Loop'

Duplicate XML attribute 'attributeName'

Either the parameter type or the return type of this conversion operator must be the containing type

Element is missing an end tag

Element names cannot use the 'xmlns' prefix

'Else' must be preceded by a matching 'If' or 'ElseIf'

'ElseIf' must be preceded by a matching 'If' or 'ElseIf'

'End AddHandler' must be preceded by a matching 'AddHandler' declaration

'End AddHandler' must be the first statement on a line

'End Class' must be preceded by a matching 'Class'

'End Enum' must be preceded by a matching 'Enum'

'End Event' must be preceded by a matching 'Custom Event'

'End Function' expected

'End Function' must be preceded by a matching 'Function'

'End Function' must be the first statement on a line

'End Get' must be preceded by a matching 'Get'

'End Get' must be the first statement on a line

'End If' must be preceded by a matching 'If'

'End Interface' must be preceded by a matching 'Interface'

'End Module' must be preceded by a matching 'Module'

'End Namespace' must be preceded by a matching 'Namespace'

End of expression expected

End of parameter list expected

End of statement expected

'End Operator' expected

'End Operator' must be preceded by a matching 'Operator'

'End Operator' must be the first statement on a line

'End Property' must be preceded by a matching 'Property'

'End RaiseEvent' must be preceded by a matching 'RaiseEvent' declaration

'End RaiseEvent' must be the first statement on a line

'End RemoveHandler' must be preceded by a matching 'RemoveHandler' declaration

'End RemoveHandler' must be the first statement on a line

'End Select' must be preceded by a matching 'Select Case'

'End Set' must be preceded by a matching 'Set'

'End Set' must be the first statement on a line

'End' statement cannot be used in class library projects

'End' statement not valid

'End' statements are not valid in the Immediate window

'End Structure' must be preceded by a matching 'Structure'

'End Sub' expected

'End Sub' must be preceded by a matching 'Sub'

'End Sub' must be the first statement on a line

'End SyncLock' must be preceded by a matching 'SyncLock'

End tag </tagName> expected

'End Try' must be preceded by a matching 'Try'

'End Using' must be preceded by a matching 'Using'

'End While' must be preceded by a matching 'While'

'End With' must be preceded by a matching 'With'

'EndIf' statements are no longer supported; use 'End If' instead

Enum '<enumname>' must contain at least one member

Enum in an interface cannot be declared '<specifier>'

'Enum' must end with a matching 'End Enum'

Enum types cannot be nullable

Enums must be declared as an integral type

'Equals' cannot compare a value of type <type1> with a value of type <type2>

'Equals' expected

Error creating assembly manifest: <error message>

Error creating Win32 resources: <error message>

Error embedding Win32 manifest: <manifest>

Error embedding Win32 manifest: Manifest File <file> cannot be found

Error embedding Win32 manifest: Option /win32manifest conflicts with /nowin32manifest

Error in project-level import '<qualifiedelementname>' at '<qualifiedcontainername>' : <errormessage>

Error saving temporary Win32 resource file '<filename>': <error message>

Error setting assembly manifest option: <error message>

'Error' statements are not valid in the Immediate window

Errors occurred while compiling the XML schemas in the project

Evaluation of expression or statement stopped

Evaluation of expression or statement timed out

Evaluation of lambda expressions is not valid in the debugger

Event '<eventname>' cannot be found

Event '<eventname>' cannot be handled because it is not accessible from '<name>'

Event '<eventname>' event specified by the 'DefaultEvent' attribute is not a publicly accessible event for this class

Event '<eventname>' implicitly declares '<membername>', which conflicts with a member in the base <type> '<classname>', and so the event should be declared 'Shadows'

Event '<eventname1>' cannot implement event '<eventname2>' because its delegate type does not match the delegate type of another event implemented by '<eventname1>'

Event '<eventname1>' cannot implement event '<eventname2>' on interface '<interface>' because their delegate types '<delegate1>' and '<delegate2>' do not match

Event name length cannot exceed 1011 characters

Events cannot be declared with a delegate type that has a return type

Events cannot have a return type

Events declared with an 'As' clause must have a delegate type

Events in a Module cannot be declared '<specifier>'

Events in interfaces cannot be declared '<implements>'

Events of shared WithEvents variables cannot be handled by non-shared methods

'Exit AddHandler', 'Exit RemoveHandler' and 'Exit RaiseEvent' are not valid

'Exit Do' can only appear inside a 'Do' statement

'Exit For' can only appear inside a 'For' statement

'Exit Function' is not valid in a Sub or Property

'Exit' must be followed by 'Sub', 'Function', 'Property', 'Do', 'For', 'While', 'Select', or 'Try'

'Exit Operator' is not valid. Use 'Return' to exit an Operator

'Exit Property' is not valid in a Function or Sub

'Exit Select' can only appear inside a 'Select' statement

'Exit' statements are not valid in the Immediate window

'Exit Sub' is not valid in a Function or Property

'Exit Try' can only appear inside a 'Try' statement

'Exit While' can only appear inside a 'While' statement

Expected '%=' at start of an embedded expression

Expected '/' for XML end tag

Expected beginning '<' for an XML tag

Expected closing '%>' for embedded expression

Expected closing ';' for XML entity

Expected closing '?>' for XML processor instruction

Expected closing ']]>' for XML CDATA section

Expected closing '-->' for XML comment

Expected closing '>' for XML tag

Expected matching closing double quote for XML attribute value

Expected matching closing single quote for XML attribute value

Expected one of 'Dim', 'Const', 'Public', 'Private', 'Protected', 'Friend', 'Shadows', 'ReadOnly' or 'Shared'

Explicit initialization is not permitted for arrays declared with explicit bounds

Explicit initialization is not permitted with multiple variables declared with a single type specifier

Exponent is not valid

Expression cannot appear inside a quoted attribute value

Expression cannot be converted into an expression tree

Expression cannot be evaluated at this time

Expression does not produce a value

Expression expected

Expression has the type '<typename>' which is a restricted type and cannot be used to access members inherited from 'Object' or 'ValueType'

Expression is a value and therefore cannot be the target of an assignment

Expression is not a method

Expression is not an array or a method, and cannot have an argument list

Expression is of type '<typename>', which is not a collection type

Expression of type <type> is not queryable

Expression of type '<typename>' cannot be converted to 'Object' or 'ValueType'

Expression of type '<typename1>' can never be of type '<typename2>'

Expression or statement is not valid in debug windows

Expression recursively calls containing Operator '<operatorsymbol>'

Expression recursively calls the containing property '<propertyname>'

'Extension' attribute can be applied only to 'Module', 'Sub', or 'Function' declarations

Extension method '<methodname>' defined in '<modulename>' does not have a signature compatible with delegate '<delegatename>'

Extension method '<methodname>' defined in '<modulename>' is not generic (or has no free type parameters) and so cannot have type arguments

Extension method '<methodName>' defined in '<typeName>' does not have the same signature as delegate '<delegateName>'

Extension method '<methodname>' has type constraints that can never be satisfied

Extension methods can be defined only in modules

Extension methods must declare at least one parameter

Field '<fieldname>' is of an unsupported type

Field or property '<membername>' is not found

File <filename> could not be found

File name already declared with a different GUID and checksum value

'Finally' can only appear once in a 'Try' statement

'Finally' cannot appear outside a 'Try' statement

'Finally' must end with a matching 'End Try'

'Finally' statements are not valid in the Immediate window

First operand in a binary 'If' expression must be nullable or a reference type

First statement of a method body cannot be on the same line as the method declaration

First statement of this 'Sub New' must be a call to 'MyBase.New' or 'MyClass.New' (More Than One Accessible Constructor Without Parameters)

First statement of this 'Sub New' must be a call to 'MyBase.New' or 'MyClass.New' (No Accessible Constructor Without Parameters)

First statement of this 'Sub New' must be an explicit call to 'MyBase.New' or 'MyClass.New' because the '<constructorname>' in the base class '<baseclassname>' of '<derivedclassname>' is marked obsolete.

First statement of this 'Sub New' must be an explicit call to 'MyBase.New' or 'MyClass.New' because the '<constructorname>' in the base class '<baseclassname>' of '<derivedclassname>' is marked obsolete: '<errormessage>'

First statement of this 'Sub New' should be an explicit call to 'MyBase.New' or 'MyClass.New' because the '<constructorname>' in the base class '<baseclassname>' of '<derivedclassname>' is marked obsolete.

First statement of this 'Sub New' should be an explicit call to 'MyBase.New' or 'MyClass.New' because the '<constructorname>' in the base class '<baseclassname>' of '<derivedclassname>' is marked obsolete: '<errormessage>'

'For Each' on type '<typename>' is ambiguous because the type implements multiple instantiations of 'System.Collections.Generic.IEnumerable(Of T)'

For loop control variable '<variablename>' already in use by an enclosing For loop

'For' loop control variable already in use by an enclosing 'For' loop

'For' loop control variable cannot be of type '<type>'

'For' must end with a matching 'Next'

Friend assembly reference <reference> is invalid

Friend assembly reference <reference> is invalid. InternalsVisibleTo declarations cannot have a version, culture, public key token, or processor architecture specified.

Full width characters are not valid as XML delimiters

Fully qualified names for types in namespaces cannot be longer than <number> characters

Function '<procedurename>' doesn't return a value on all code paths

Function evaluation is disabled because a previous function evaluation timed out

Function without an 'As' clause; return type of Object assumed

Generic methods cannot be exposed to COM

Generic methods cannot use 'Handles' clause

Generic parameter constraint type <typename> is not CLS-compliant

Generic parameters used as optional parameter types must be class constrained

Generic type '<generictypename>' cannot be imported more than once

'Get' accessor of property '<propertyname>' is not accessible

'Get' is already declared

'Get' statement must end with a matching 'End Get'

'Get' statements are no longer supported

'Get' statements are no longer supported (Visual Basic)

'Global' must be followed by '.' and an identifier

'Global' not allowed in handles; local name expected

'Global' not allowed in this context; identifier expected

'GoSub' statements are no longer supported

'GoTo <labelname>' is not valid because '<labelname>' is inside a 'For' or 'For Each' statement that does not contain this statement

'GoTo <labelname>' is not valid because '<labelname>' is inside a 'SyncLock' statement that does not contain this statement

'GoTo <labelname>' is not valid because '<labelname>' is inside a 'Try', 'Catch' or 'Finally' statement that does not contain this statement

'GoTo <labelname>' is not valid because '<labelname>' is inside a 'With' statement that does not contain this statement

'GoTo <linelabel>' is not valid because '<linelabel>' is inside a 'Using' statement that does not contain this statement

'GoTo' statements are not valid in the Immediate window

GoTo to label '<labelname>' cannot be used within lambda expressions

'Group' not allowed in this context; identifier expected

'Group' or an identifier expected

Handles clause requires a WithEvents variable defined in the containing type or one of its base types

'Handles' in classes must specify a 'WithEvents' variable, 'MyBase', 'MyClass' or 'Me' qualified with a single identifier

'Handles' in modules must specify a 'WithEvents' variable qualified with a single identifier

'Handles' is not valid on operator declaration

Identifier expected

Identifier expected, preceded with a period

Identifier is too long

'If' must end with a matching 'End If'

'If' operands cannot be named arguments

'If' operator requires either two or three operands

'If', 'ElseIf', 'Else', 'End If', or 'Const' expected

Ignoring /noconfig option because it was specified in a response file

Illegal call expression or index expression

Implemented type must be an interface

Implementing class '<classname>' for interface <interfacename> cannot be found

Implementing class '<underlyingclassname>' for interface '<interfacename>' is not accessible in this context because it is '<accesslevel>'

'Implements' is not valid on operator declaration

'Implements' not valid in Modules

'Implements' statement must follow any 'Inherits' statement and precede all declarations in a class

Implicit conversion from '<typename1>' to '<typename2>'

Implicit conversion from '<typename1>' to '<typename2>' in copying the value of 'ByRef' parameter '<parametername>' back to the matching argument.

Implicit variable '<variablename>' is invalid because of '<message>'

Import of type '<typename>' from assembly or module '<name>' failed

Imports alias '<name>' conflicts with '<name2>' declared in the root namespace

'Imports' statements must precede any declarations

'In' expected

Inappropriate use of <keyword> keyword in a module

Index '<indexnumber>' for dimension '<dimensionnumber>' is out of range

Indirect constraint '<constraint1>' obtained from the type parameter constraint '<typeparameter1>' conflicts with the constraint '<constraint2>'

Indirect constraint '<constraint1>' obtained from the type parameter constraint '<typeparameter1>' conflicts with the indirect constraint '<constraint2>' obtained from the type parameter constraint '<typeparameter2>'

Indirect reference is being made to assembly <assemblyname> version <laterversionnumber>, which contains '<typename>'

Information for the type of '<typename>' has not been loaded into the runtime

Inheriting from 'System.<classname>' is not valid

'Inherits' can appear only once within a 'Class' statement and can only specify one class

'Inherits' not valid in Modules

'Inherits' statement must precede all declarations in a class

'Inherits' statements must precede all declarations in an interface

Initialization error

Initializer expected

Initializers on structure members are valid only for 'Shared' members and constants

Instance members and 'Me' cannot be used in a query expression

Instance members and 'Me' cannot be used within a lambda expression in structures

Instance of restricted type '<typename>' cannot be used in a lambda expression

Instance of restricted type '<typename>' cannot be used in a query expression

Integer constant expected

Interface '<interfacename>' can be implemented only once by this type

Interface '<interfacename>' cannot be indexed because it has no default property

Interface '<interfacename>' cannot inherit from itself: <message>

Interface '<interfacename>' is not implemented by this class

Interface can inherit only from another interface

Interface members must be methods, properties, events, or type definitions

'Interface' must end with a matching 'End Interface'

'InterfaceId' and 'EventsId' parameters for 'Microsoft.VisualBasic.ComClassAttribute' on '<typename>' cannot have the same value

Internal compiler error

Internal compiler error: code generator received malformed input

'Into' expected

'Is' expected

'Is' operand of type '<typeparametername>' can be compared only to 'Nothing' because '<typeparametername>' is a type parameter with no class constraint

'Is' operand of type 'typename' can only be compared to 'Nothing', because 'typename' is a nullable type

'Is' requires operands that have reference types, but this operand has the value type '<typename>'

'IsNot' operand of type '<typeparametername>' can be compared only to 'Nothing' because '<typeparametername>' is a type parameter with no class constraint

'IsNot' operand of type 'typename' can only be compared to 'Nothing', because 'typename' is a nullable type

'IsNot' requires operands that have reference types, but this operand has the value type '<typename>'.

'Join' expected

Keyword does not name a type

Keyword is not valid as an identifier

Label '<labelname>' is already defined in the current method

Label '<labelname>' is not defined

Labels are not valid in the Immediate window

Labels are not valid outside methods

Labels that are numbers must be followed by colons

Lambda expression cannot be converted to '<typename>' because '<typename>' is not a delegate type

Lambda expression cannot be converted to '<typename>' because type '<typename>' is declared 'MustInherit' and cannot be created

Lambda expression will not be removed from this event handler

Lambda expressions are not valid in the first expression of a 'Select Case' statement

Lambda parameter '<parameter>' hides a variable in an enclosing block, a previously defined range variable, or an implicitly declared variable in a query expression.

Late binding operations cannot be converted to an expression tree

Late bound resolution; runtime errors could occur

Latebound overload resolution cannot be applied to '<procedurename>' because the accessing instance is an interface type

Leading '.' or '!' can only appear inside a 'With' statement

Leading '.' or '!' cannot appear in a constant expression

'Let' and 'Set' assignment statements are no longer supported

Line continuation character '_' must be preceded by at least one white space and must be the last character on the line

Line is too long

'Line' statements are no longer supported (Smart Device/Visual Basic Compiler Error)

'Line' statements are no longer supported (Visual Basic Compiler Error)

Local variable '<variablename>' cannot be referred to before it is declared

Local variable '<variablename>' is already declared in the current block

Local variable cannot have the same name as the function containing it

Local variables within generic methods cannot be declared 'Static'

Local variables within methods of structures cannot be declared 'Static'

'Loop' cannot have a condition if matching 'Do' has one

Loop control variable cannot be a property or a late-bound indexed array

'Loop' must be preceded by a matching 'Do'

Loop statements are not valid in the Immediate window

Matching '<operatorsymbol1>' operator is required for '<operatorsymbol2>'

Maximum number of errors has been exceeded

Maximum number of warnings has been exceeded

'Me' cannot be the target of an assignment

Member '<classname>.<procedurename>' that matches this signature cannot be overridden because the class '<classname>' contains multiple members with this same name and signature: <signaturelist>

Member '<interfacename>.<procedurename>' that matches this signature cannot be implemented because the interface '<interfacename>' contains multiple members with this same name and signature: <signaturelist>

Member '<membername>' cannot be found in class '<classname>'

Member '<membername>' cannot be initialized in an object initializer expression because it is not a field or property

Member '<membername>' cannot be initialized in an object initializer expression because it is shared

Member '<membername>' conflicts with member '<membername>' in the base type '<basetypename>' and so should not be declared 'Overloads'

Member '<membername>' implicitly defines a member '<implicitmembername>' which has the same name as a type parameter

Member '<membername1>' conflicts with a member implicitly declared for member '<membername2>' in the base type '<basetypename>' and so should not be declared 'Overloads'

Member '<membername1>' implicitly declares '<implicitmembername>', which conflicts with a member implicitly declared for member '<membername2>' in the base class '<baseclassname>'

Member '<membername1>' implicitly declares '<implicitmembername>', which conflicts with a member in the base class '<baseclassname>'

Members in a Module cannot be declared '<specifier>'

Members in a Structure cannot be declared '<specifier>'

Method '<methodname>' cannot be declared 'Partial' because only one method '<methodname>' can be marked 'Partial'

Method '<methodname>' cannot handle Event '<eventname>' because they do not have the same signature

Method '<methodname>' does not have a signature compatible with delegate <'delegatename'>

Method '<methodname>' does not have the same signature as delegate '<delegatename>'

Method '<methodname>' has a link demand, but overrides or implements the following methods which do not have a link demand. A security hole may exist:

Method '<methodname>' is already declared in interface '<interfacename>'

Method '<methodname1>' cannot implement partial method '<methodname2>' because '<methodname3>' already implements it

Method '<methodname1>' does not have the same generic constraints as the partial method '<methodname2>'

Method '<methodname1>' must be declared 'Private' in order to implement partial method '<methodname2>'

Method arguments must be enclosed in parentheses

Method call did not return a value

Method cannot contain both a 'Try' statement and an 'On Error' or 'Resume' statement

Method cannot contain both an 'On Error GoTo' statement and a lambda or query expression

Method cannot have both a ParamArray and Optional parameters

Method declaration statements must be the first on a logical line

Method does not have a signature compatible with the delegate

Method in a structure cannot be declared 'Protected' or 'Protected Friend'

Methods cannot be declared 'Static'

Methods declared in structures cannot have 'Handles' clauses

Methods declared 'Overrides' cannot be declared 'Overridable' because they are implicitly overridable

Methods in a Module cannot be declared '<specifier>'

Methods in a Module cannot implement interface members

Methods of 'System.Nullable(Of T)' cannot be used as operands of the 'AddressOf' operator

Methods or events that implement interface members cannot be declared 'Shared'

'Microsoft.VisualBasic.ComClassAttribute' and '<attribute>' cannot both be applied to the same class

'Microsoft.VisualBasic.ComClassAttribute' cannot be applied to '<classname>' because it is not declared 'Public'

'Microsoft.VisualBasic.ComClassAttribute' cannot be applied to '<classname1>' because its container '<classname2>' is not declared 'Public'

'Microsoft.VisualBasic.ComClassAttribute' cannot be applied to a class that is declared 'MustInherit'

'Microsoft.VisualBasic.ComClassAttribute' cannot be applied to a class that is generic or nested inside a generic type

'Microsoft.VisualBasic.ComClassAttribute' is specified for class '<classname>' but it has no public members that can be exposed to COM; therefore no COM interfaces are generated

'Microsoft.VisualBasic.ComClassAttribute' on class '<classname>' implicitly declares <type> '<membername>', which conflicts with a member of the same name in <type> '<typename>'

Missing required white space

Module '<modulename>' cannot be used as a type

Module attribute '<attributename>' is not valid: <error>

'Module' statement must end with a matching 'End Module'

'Module' statements can occur only at file or namespace level

Modules cannot be declared '<specifier>'

Modules cannot be generic

Multi-dimensional array cannot be converted to an expression tree

Multiple initializations of '<membername>'

'MustInherit' cannot be specified for partial type '<partialtypename>' because it cannot be combined with 'NotInheritable' specified for one of its other partial types

'MustOverride' cannot be specified on '<procedurename>' because it is in a partial type that is declared 'NotInheritable' in another partial definition

'MustOverride' method '<methodname>' cannot be called with 'MyClass'

'MyBase' cannot be used with method '<methodname>' because it is declared 'MustOverride'

'MyBase' must be followed by '.' and an identifier

'MyClass' cannot be used outside of a class

'MyClass' must be followed by '.' and an identifier

Name <membername> is not CLS-compliant

Name '<name>' is either not declared or not in the current scope

Name '<name>' is not declared

Name <namespacename> in the root namespace <fullnamespacename> is not CLS-compliant

Name of field or property being initialized must start with '.'

Name of type parameter '<typeparametername1>' does not match '<typeparametername2>', the corresponding type parameter defined on the partial method declaration '<methodname>'

Named argument cannot match a ParamArray parameter

Named argument expected

Named arguments are not valid as array subscripts

Namespace declaration must start with 'xmlns'

Namespace declaration with prefix cannot have an empty value in XML literals

Namespace or type '<name>' has already been imported

Namespace or type specified in the Imports '<qualifiedelementname>' doesn't contain any public member or cannot be found

Namespace or type specified in the project-level Imports '<qualifiedelementname>' doesn't contain any public member or cannot be found

'Namespace' statement must end with a matching 'End Namespace'

'Namespace' statements can occur only at file or namespace level

Nested function does not have the same signature as delegate '<delegatename>'

Nesting of parentheses in lambda expression's parameter list exceeds maximum allowable depth

'New' cannot be used on a class that is declared 'MustInherit'

'New' cannot be used on a type parameter that does not have a 'New' constraint

'New' cannot be used on an interface

'New' cannot be used on class '<classname>' because it contains a 'MustOverride' member that has not been overridden

'New' constraint and 'Structure' constraint cannot be combined

'New' constraint cannot be specified multiple times for the same type parameter

'New' is not valid in this context

'Next' control variable does not match 'For' loop control variable

Next control variable does not match For loop control variable '<variablename>'

'Next' expected

'Next' must be preceded by a matching 'For'

'Next' statement names more variables than there are matching 'For' statements

No accessible '<genericprocedurename>' accepts this number of type arguments

No accessible '<procedurename>' is most specific: <signaturelist>

No accessible 'Main' method with an appropriate signature was found in '<name>'

No accessible method '<procedurename>' has a signature compatible with delegate '<delegatename>':<suberrorlist>

No accessible non-generic '<procedurename>' found

No input sources specified

Non-CLS-compliant <membername> is not allowed in a CLS-compliant interface

Non-CLS-compliant 'MustOverride' member is not allowed in a CLS-compliant <classname>

None of the accessible 'Main' methods with the appropriate signatures found in '<typename>' can be the startup method since they are either generic or nested in generic types

Non-intrinsic type names are not allowed in conditional compilation expressions

'NonSerialized' attribute will not affect this member because its containing class is not exposed as 'Serializable'

Non-shared members in a Structure cannot be declared 'New'

'Nothing' cannot be evaluated

'NotInheritable' classes cannot have members declared '<specifiername>'

'NotOverridable' cannot be specified on methods that do not override another method

Nullable modifier '?' and array modifiers, '(' and ')', cannot be specified on both a variable and its type

Nullable modifier cannot be specified in variable declarations with 'As New'

Nullable modifier cannot be specified on both a variable and its type

Nullable modifier cannot be used with a variable whose implicit type is 'Object'

Nullable parameters must specify a type

Nullable type inference is not supported in this context

Nullable types are not allowed in conditional compilation expressions

Nullable types are not supported because the current version of 'mscorlib.dll' does not define the type 'Nullable(of T)'

Number of indices exceeds the number of dimensions of the indexed array

Number of indices is less than the number of dimensions of the indexed array

Object created by Edit and Continue is not yet available for evaluation

Object initializer syntax cannot be used to initialize an instance of type 'Object'

Object no longer exists due to compile error or deletion

'Of' required when specifying type arguments for a generic type or method

Omitted argument cannot match a ParamArray parameter

'On Error' statements are not valid in the Immediate window

'On Error' statements are not valid within 'SyncLock' statements

'On Error' statements are not valid within 'Using' statements

'On' expected

'On GoTo' and 'On GoSub' statements are no longer supported

Only conversion operators can be declared '<keyword>'

Only one of 'NotOverridable', 'MustOverride', or 'Overridable' can be specified

Only one of 'Public', 'Private', 'Protected', 'Friend', or 'Protected Friend' can be specified

Only one XML comment block is allowed per language element

Operands of type Object used for operator '<operatorsymbol>'; runtime errors could occur

Operands of type Object used for operator '<operatorsymbol>'; use the 'Is' operator to test object identity

Operands of type Object used for operator '<operatorsymbol>'; use the 'IsNot' operator to test object identity

Operands of type Object used in expressions for 'Select', 'Case' statements; runtime errors could occur

Operator '<operator>' must have a return type of Boolean

Operator '<operator>' must have a second parameter of type 'Integer'

Operator '<operator>' must have either one or two parameters

Operator '<operator>' must have one parameter

Operator '<operator>' must have two parameters

Operator '<operatorname>' is not defined for type '<typename>'

Operator '<operatorname>' is not defined for types '<type1>' and '<type2>'

Operator '<operatorname>' is not defined for types '<typename1>' and '<typename2>'

Operator '<operatorsymbol>' doesn't return a value on all code paths

Operator declaration must be one of: +,-,*,\,/,^, &, Like, Mod, And, Or, Xor, Not, <<, >>, =, <>, <, <=, >, >=, CType, IsTrue, IsFalse

Operator is not overloadable

Operator 'operator' is not defined for types 'type1' and 'type2'

Operator without an 'As' clause; type of Object assumed

Operators cannot be declared '<keyword>'

Operators cannot be declared in Modules

Operators must be declared 'Public'

Operators must be declared 'Shared'

Option /win32manifest ignored

option '<option>' cannot be followed by '+' or '-'; ignored

option <optionname> can be followed only by '+' or '-'

Option <optionname> requires <argument>

'Option <specifier>' statement can only appear once per file

'Option Compare' must be followed by 'Text' or 'Binary'

'Option Explicit' can be followed only by 'On' or 'Off'

'Option Infer' can be followed only by 'On' or 'Off'

'Option' must be followed by 'Compare', 'Explicit', 'Infer', or 'Strict'

'Option' statements must precede any declarations or 'Imports' statements

'Option Strict' can be followed only by 'On' or 'Off'

Option Strict Custom can only be used as an option to the command-line compiler (vbc.exe)

Option Strict On disallows implicit conversions from '<type1>' to '<type2>'

Option Strict On disallows implicit conversions from '<type1>' to '<type2>'; the Visual Basic 6.0 collection type is not compatible with the .NET Framework collection type

Option Strict On disallows late binding

Option Strict On disallows narrowing from type '<typename1>' to type '<typename2>' in copying the value of ByRef parameter <parametername>' back to the matching argument

Option Strict On disallows operands of type Object for operator '<operatorname>'

Option Strict On does not allow narrowing in implicit type conversions between extension method '<extensionmethodname>' defined in '<modulename>' and delegate '<delegatename>'

Option Strict On does not allow narrowing in implicit type conversions between method '<methodname>' and delegate '<delegatename>'

Option Strict On does not allow narrowing in implicit type conversions between the lambda expression and delegate '<delegatename>'

Option Strict On prohibits operands of type Object for operator '<operatorname>'

Option Strict On requires all Function, Property, and Operator declarations to have an 'As' clause

Option Strict On requires all variable declarations to have an 'As' clause

Option Strict On requires each lambda expression parameter to be declared with an 'As' clause if its type cannot be inferred

Option Strict On requires that all method parameters have an 'As' clause

'Optional' and 'ParamArray' cannot be combined

'Optional' cannot be applied to the first parameter of an extension method

'Optional' expected

Optional parameters cannot be declared as the type '<type>'

Optional parameters cannot have structure types

Optional parameters must specify a default value

Out of memory (Visual Basic Compiler Error)

Overflow (Visual Basic Error)

Overload resolution failed because no '<method>' is accessible

Overload resolution failed because no accessible '<genericprocedurename>' accepts this number of type arguments

Overload resolution failed because no accessible '<method>' accepts this number of arguments

Overload resolution failed because no accessible '<method>' can be called with these arguments:<error>

Overload resolution failed because no accessible '<method>' can be called without a narrowing conversion: <error>

Overload resolution failed because no accessible '<method>' is most specific for these arguments:<error>

Overloading methods declared in multiple base interfaces is not valid

'ParamArray' cannot be applied to the first parameter of an extension method

ParamArray parameter must be a one-dimensional array

ParamArray parameter must be an array

ParamArray parameters must be declared 'ByVal'

ParamArray parameters must have an array type

Parameter '<parametername>' already has a matching argument

Parameter '<parametername>' already has a matching omitted argument

Parameter '<parametername>' in '<methodname>' already has a matching omitted argument

Parameter '<parametername>' in extension method '<methodname>' defined in '<typename>' already has a matching argument

Parameter '<parametername>' in extension method '<methodname>' defined in '<typename>' already has a matching omitted argument

Parameter '<parametername>' of '<methodname>' already has a matching argument

Parameter already declared with name '<argumentname>'

Parameter cannot have the same name as its defining function

Parameter name '<parametername1>' does not match the name of the corresponding parameter, '<parametername2>', defined on the partial method declaration '<methodname>'

Parameter specifier is duplicated

Parameter type of this unary operator must be the containing type '<typename>'

Parameter types of '<operator>' must be '<typename>' to be used in a 'For' statement

Partial method '<methodname>' cannot use the 'Implements' keyword

Partial methods must be declared 'Private'

Partial methods must be declared 'Private' instead of '<accessModifier>'

Partial methods must have empty method bodies

Possible problem detected while building assembly '<assemblyname>': <error>

Possible problem detected while building assembly: <error>

'prefix' is an XML prefix and cannot be used as an expression

Project '<projectname>' cannot generate a reference to file '<filename>'

Project '<projectname>' cannot reference project '<projectname>' because '<projectname>' directly or indirectly references '<projectname>'

Project '<projectname>' makes an indirect reference to assembly '<assemblyname>' which contains '<classname>'

Project '<projectname>' requires a reference to version '<versionnumber1>' of assembly '<assemblyname>', but references version '<versionnumber2>' of assembly '<assemblyname>' (Visual Basic Error)

Project '<projectname>' requires a reference to version '<versionnumber1>' of assembly '<assemblyname>', but references version '<versionnumber2>' of assembly '<assemblyname>' (Visual Basic Warning)

Project '<projectname1>' makes an indirect reference to project '<projectname2>', which contains '<typename>'

Project already has a reference to assembly <assemblyidentity>

Project has been closed

Project-level conditional compilation constant '<constantname>' is not valid: <error>

Project-level conditional compilation constant is not valid: <error>

Properties cannot be declared '<modifiername>'

Properties declared 'ReadOnly' cannot have a 'Set'

Properties declared 'WriteOnly' cannot have a 'Get'

Properties in a Module cannot be declared '<specifier>'

Properties with no required parameters cannot be declared 'Default'

Property '<propertyname>' cannot be declared 'Default' because it overrides a Property on the base <type> '<typename>' that is not default

Property '<propertyname>' cannot be initialized in an object initializer expression because all accessible overloads require arguments

Property '<propertyname>' cannot be initialized in an object initializer expression because it requires arguments

Property '<propertyname>' doesn't return a value on all code paths

Property '<propertyname>' implicitly declares '<implicitmembername>', which conflicts with a member implicitly declared for member '<membername>' in the base class '<baseclassname>'

Property '<propertyname>' is of an unsupported type

Property '<propertyname>' is 'ReadOnly'

Property '<propertyname>' is 'WriteOnly'

Property '<propertyname>' must be declared 'Default' because it overrides a default property on the base '<name>'

Property '<propertyname>' with no parameters cannot be found

Property access must assign to the property or use its value

Property accessors cannot be declared '<accessmodifier>' in a 'Default' property

Property accessors cannot be declared '<accessmodifier>' in a 'NotOverridable' property

Property accessors cannot be declared '<keyword>'

Property cannot be declared '<propertymodifier>' because it contains a 'Private' accessor

Property Get/Let/Set are no longer supported; use the new Property declaration syntax

Property missing 'End Property'

Property or field '<name>' does not have a valid attribute type

Property parameters cannot have the name 'Value'

Property without a 'ReadOnly' or 'WriteOnly' specifier must provide both a 'Get' and a 'Set'

Property without an 'As' clause; type of Object assumed

Protected types can only be declared inside of a class

Query expressions are not valid in debug windows

'RaiseEvent' declaration must end with a matching 'End RaiseEvent'

'RaiseEvent' definition missing for event '<eventname>'

'RaiseEvent' is already declared

'RaiseEvent' method must have the same signature as the containing event's delegate type '<signature>'

'RaiseEvent' statements are not valid in the Immediate window

Range specified for 'Case' statement is not valid

Range variable <variable> hides a variable in an enclosing block or a range variable previously defined in the query expression.

Range variable <variable> hides a variable in an enclosing block, a previously defined range variable, or an implicitly declared variable in a query expression

Range variable <variable> is already declared

Range variable name can be inferred only from a simple or qualified name with no arguments

Range variable name cannot match the name of a member of the 'Object' class

'ReadOnly' and 'WriteOnly' cannot be combined

'ReadOnly' attribute property '<propertyfield>' cannot be the target of an assignment

'ReadOnly' properties cannot have an access modifier on 'Get'

'ReadOnly' property '<propertyname>' cannot be the target of an assignment

'ReadOnly' property must provide a 'Get'

'ReadOnly' variable cannot be the target of an assignment

'ReadOnly' variable cannot be the target of an assignment in a lambda expression inside a constructor

'ReDim' cannot change the number of dimensions of an array

'ReDim' statements can no longer be used to declare array variables

'ReDim' statements require a parenthesized list of the new bounds of each dimension of the array

Reference required to assembly '<assemblyidentity>' containing type '<typename>', but a suitable reference could not be found due to ambiguity between projects '<projectname1>' and '<projectname2>'

Reference required to assembly '<assemblyidentity>' containing type '<typename>', but a suitable reference could not be found due to possible circular references: <referencedependencylist>

Reference required to assembly '<assemblyname>' containing the base class '<classname>'

Reference required to assembly '<assemblyname>' containing the definition for event '<eventname>'

Reference required to assembly '<assemblyname>' containing the implemented interface '<interfacename>'

Reference required to assembly '<assemblyname>' containing the type '<membername>'

Reference required to module '<modulename>' containing the base class '<classname>'

Reference required to module '<modulename>' containing the definition for event '<eventname>'

Reference required to module '<modulename>' containing the implemented interface '<interfacename>'

Reference required to module '<modulename>' containing the type '<membername>'

Reference to a non-shared member requires an object reference

Reference to object under construction is not valid when calling another constructor

Referenced '<membername>' has a value of 'Nothing'

Referenced array element has a value of 'Nothing'

Referenced object '<objectname>' has a value of 'Nothing'

Referenced object has a value of 'Nothing'

Relational operator expected

'RemoveHandler' declaration must end with a matching 'End RemoveHandler'

'RemoveHandler' definition missing for event '<eventname>'

'RemoveHandler' is already declared

Required attribute 'version' missing from XML declaration

Resource name '<resourcename>' cannot be used more than once

Response file <filename> included multiple times

'Resume' or 'GoTo' expected

'Resume' statements are not valid in the Immediate window

Return and parameter types of '<logicaloperator>' must be '<typename>' to be used in a '<shortcircuitoperator>' expression

Return and parameter types of '<operator>' must be '<typename>' to be used in a 'For' statement

'Return' statement in a Function, Get, or Operator must return a value

'Return' statement in a Sub or a Set cannot return a value

'Return' statement in an 'AddHandler', 'RemoveHandler', or 'RaiseEvent' method cannot return a value

'Return' statements are not valid in the Immediate window

Return type of function '<procedurename>' is not CLS-compliant

Root namespace <namespacename> is not CLS-compliant

Run-time exception thrown

Run-time exception thrown: <exception> - <exception>

Security attribute '<attributename>' cannot be applied to a module

Security attribute '<attributename>' is not valid: <error>

'Select Case' must end with a matching 'End Select'

'Select' statements are not valid in the Immediate window

'Set' accessor of property '<propertyname>' is not accessible

'Set' is already declared

'Set' method cannot have more than one parameter

'Set' parameter cannot be declared '<specifier>'

'Set' parameter must have the same type as the containing property

'Set' statement must end with a matching 'End Set'

'Shared' attribute property '<propertyfield>' cannot be the target of an assignment

'Shared' cannot be combined with '<specifier>' on a method declaration

'Shared' cannot be combined with '<specifier>' on a property declaration

Shared 'Sub New' cannot be declared '<specifier>'

Shared 'Sub New' cannot have any parameters

Side effects not valid during expression evaluation in this context

Source file <filename> specified multiple times

Specified access '<accesslevel1>' for '<partialtypename>' does not match the access '<accesslevel2>' specified on one of its other partial types

Specifier is duplicated

Specifiers and attributes are not valid on 'Namespace' statements

Specifiers and attributes are not valid on this statement

Specifiers are not valid on 'AddHandler', 'RemoveHandler' and 'RaiseEvent' methods

Specifiers valid only at the beginning of a declaration

Statement cannot appear outside of a method body

Statement cannot appear within a method body

Statement cannot appear within a property body

Statement cannot appear within an Enum body

Statement cannot appear within an event body

Statement cannot appear within an interface body

Statement cannot appear within an interface body (Visual Basic Error)

Statement cannot end a block outside of a line 'If' statement

Statement does not declare a 'Get' or 'Set' method

Statement does not declare an 'AddHandler', 'RemoveHandler' or 'RaiseEvent' method

Statement is not valid in a namespace

Statement is not valid in an interface

Statement is not valid inside a method

Statement recursively calls the containing 'AddHandler' for event '<eventname>'

Statements and labels are not valid between 'Select Case' and first 'Case'

Static local variable '<variablename>' is already declared

Stop request is pending

'Stop' statements are not valid in the Immediate window

String constant expected

String constants must end with a double quote

Structure '<structurename>' cannot be indexed because it has no default property

Structure '<structurename>' cannot contain an instance of itself: <error>

Structure '<structurename>' must contain at least one instance member variable or at least one instance event declaration not marked 'Custom'

Structure '<structurename>' must contain at least one instance member variable or Event declaration

'Structure' constraint and a specific class type constraint cannot be combined

'Structure' constraint cannot be specified multiple times for the same type parameter

Structure in an interface cannot be declared '<specifier>'

'Structure' statement must end with a matching 'End Structure'

Structures cannot declare a non-shared 'Sub New' with no parameters

Structures cannot have 'Inherits' statements

'Sub Main' is declared more than once in '<namespace>': <message>

'Sub Main' was not found in '<name>'

'Sub New' cannot be declared '<modifier>'

'Sub New' cannot be declared in an interface

'Sub New' cannot be declared 'Overrides'

'Sub New' cannot handle events

'Sub New' cannot implement interface members

'Sub' or 'Function' expected

'Sub' or 'Function' expected after 'Delegate'

Suspend request is pending

'SyncLock' operand cannot be of type '<typename>' because '<typename>' is not a reference type

'SyncLock' statement must end with a matching 'End SyncLock'

'SyncLock' statements are not valid in the Immediate window

Syntax error (Visual Basic Error)

Syntax error in cast operator; two arguments separated by comma are required

Syntax error in conditional compilation expression

System.CLSCompliantAttribute cannot be applied to property 'Get'/'Set'

System.Diagnostics.DebuggerHiddenAttribute does not affect 'Get' or 'Set' when applied to the Property definition

'System.Nullable' does not satisfy the 'Structure' constraint for type parameter '<typeparametername>'

'System.ObsoleteAttribute' cannot be applied to the 'AddHandler', 'RemoveHandler', or 'RaiseEvent' definitions

'System.Runtime.InteropServices.DispIdAttribute' value cannot be applied to '<typename>' because 'Microsoft.VisualBasic.ComClassAttribute' reserves values less than zero

'System.Runtime.InteropServices.DispIdAttribute' value cannot be applied to '<typename>' because 'Microsoft.VisualBasic.ComClassAttribute' reserves zero for the default property

'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to a 'Declare'

'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to a 'Get' or 'Set'

'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to a method that is generic or nested in a generic type

'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to a Sub, Function, or Operator with a non-empty body

'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to 'AddHandler', 'RemoveHandler', or 'RaiseEvent' methods

'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to instance methods

'System.Runtime.InteropServices.DllImportAttribute' cannot be applied to interface methods

'System.STAThreadAttribute' and 'System.MTAThreadAttribute' cannot both be applied to '|1'

'System.STAThreadAttribute' and 'System.MTAThreadAttribute' cannot both be applied to the same method

'System.Void' can only be used in a GetType expression

The /moduleassemblyname option may only be specified when building a target of type 'module'

The '?' character cannot be used here

The '<keyword>' keyword is used to overload inherited members; do not use the '<keyword>' keyword when overloading 'Sub New'

The ConnectionTimeout must be greater than 0

The custom-designed version of 'System.Runtime.CompilerServices.ExtensionAttribute' found by the compiler is not valid

The default assembly reference '<reference>' has already been automatically added; ignored

The file '<filename>' is not a text file

The maximum number of errors has been exceeded

The targeted version of the .NET Compact Framework does not support latebinding

The targeted version of the .NET Compact Framework does not support latebound overload resolution

The targeted version of the .NET Compact Framework does not support the 'End' statement

The targeted version of the .NET Compact Framework does not support using the Ansi, Auto or Unicode modifier

The type '<typename>' cannot be an array element type, return type, field type, generics argument type, 'ByRef' parameter type or the type of an expression converted to 'Object' or 'ValueType'

The type for variable '<variablename>' will not be inferred because it is bound to a field in an enclosing scope

the value '<value>' is invalid for option '<optionname>'

This inheritance causes circular dependencies between <type1> '<typename1>' and its nested <type2> '<typename2>'

'Throw' operand must derive from 'System.Exception'

'Throw' statement cannot omit operand outside a 'Catch' statement or inside a 'Finally' statement

'Throw' statements are not valid in the Immediate window

Too few type arguments

Too few type arguments to '<genericMethodName>'

Too few type arguments to extension method '<methodname>' defined in '<typename>'

Too many arguments

Too many arguments to '<procedurename>'

Too many arguments to extension method '<methodname>' defined in '<typename>'

Too many type arguments

Too many type arguments to '<genericMethodName>'

Too many type arguments to extension method '<methodName>' defined in '<typeName>'

'Try' must end with a matching 'End Try'

Try must have at least one 'Catch' or a 'Finally'

'Try' statements are not valid in the Immediate window

'TryCast' operand must be reference type, but '<typename>' is a value type

'TryCast' operands must be class-constrained type parameters, but '<typeparametername>' has no class constraint

Type '<typename>' and partial type '<typename>' conflict in container '<containername>', but are being merged because one of them is declared partial

Type '<typename>' and partial type '<typename>' declared in '<filename>' conflict in container '<containername>', but are being merged because one of them is declared partial

Type '<typename>' cannot be used as an attribute because it is not declared 'Public'

Type '<typename>' cannot be used as an attribute because its container '<containername>' is not declared 'Public'

Type '<typename>' cannot implement interface '<interfacename>' because it declares '<eventsignature>' which has a return type

Type '<typename>' cannot inherit from a type nested within it

Type '<typename>' cannot inherit from a type parameter

Type '<typename>' has no constructors

Type '<typename>' has no type parameters and so cannot have type arguments

Type '<typename>' in assembly '<assemblyname1>' has been forwarded to assembly '<assemblyname2>'

Type '<typename>' is imported from different versions of assembly '<assemblyname>'

Type <typename> is not CLS-compliant

Type '<typename>' is not defined

Type '<typename>' is not defined or the module containing it is not loaded in the debugging session

Type '<typename>' is not supported because it either directly or indirectly inherits from itself

Type '<typeName>' must be a value type or a type argument constrained to 'Structure' in order to be used with 'Nullable' or nullable modifier '?'

Type '<typename>' must define operator '<determinantoperator>' to be used in a '<shortcircuitoperator>' expression

Type '<typename>' must define operator '<operator>' to be used in a 'For' statement

Type '<typename1>' cannot be marked CLS-compliant because its containing type '<typename2>' is not CLS-compliant

Type argument '<typeargumentname>' does not inherit from or implement the constraint type '<typeparametername>'

Type argument '<typeargumentname>' does not satisfy the 'Class' constraint for type parameter '<typeparametername>'

Type argument '<typeargumentname>' does not satisfy the 'Structure' constraint for type parameter '<typeparametername>'

Type argument '<typeargumentname>' is declared 'MustInherit' and does not satisfy the 'New' constraint for type parameter '<typeparametername>'

Type argument '<typeargumentname>' must have a public parameterless instance constructor to satisfy the 'New' constraint for type parameter '<typeparametername>'

Type argument inference failed for type parameter '<typeparametername>' of '<genericproceduresignature>'

Type argument inference failed for type parameter '<typeparametername1>' of '<genericproceduresignature>'

Type arguments cannot be applied to the expression '<expression>'

Type arguments could not be inferred from the delegate

Type arguments for extension method '<methodName>' defined in '<typeName>' could not be inferred from the delegate '<delagateName>'

Type arguments for method '<procedurename>' could not be inferred from the delegate '<delegatename>'

Type arguments inferred for method '<procedurename>' result in the following errors :<errorlist>

Type arguments inferred for method '<procedurename>' result in the following warnings :<warninglist>

Type arguments unexpected

Type arguments unexpected because attributes cannot be generics

Type character '<character>' cannot be used in a declaration with an explicit type

Type character '<charactername>' does not match declared data type '<type>'

Type character cannot be used in a 'Sub' declaration because a 'Sub' doesn't return a value

Type character cannot be used in a type parameter declaration

Type characters are not allowed in label identifiers

Type characters are not allowed on Imports aliases

Type characters cannot be used in anonymous type declarations

Type characters cannot be used in range variable declarations

Type constraint '<expression>' is not a class or interface

Type constraint cannot be a 'NotInheritable' class

Type declaration characters are not valid in this context

Type expected

Type in a Module cannot be declared '<specifier>'

Type of '<variablename>' cannot be inferred because the loop bounds and the step variable do not widen to the same type

Type of '<variablename>' cannot be inferred from an expression containing '<variablename>'

Type of '<variablename>' is ambiguous because the loop bounds and the step variable do not widen to the same type

Type of member '<membername>' is not CLS-compliant

Type of optional value for optional parameter <parametername> is not CLS-compliant

Type of parameter '<parametername>' is not CLS-compliant

Type or 'New' expected

Type or 'With' expected

Type parameter '<typeparametername>' can only have one constraint that is a class

Type parameter '<typeparametername>' cannot be constrained to itself: '<errormessage>'

Type parameter '<typeparametername>' cannot be inferred

Type parameter '<typeparametername>' for '<genericprocedurename>' cannot be inferred

Type parameter '<typeparametername>' for extension method '<methodname>' defined in '<typename>' cannot be inferred

Type parameter '<typeparametername>' has the same name as a type parameter of an enclosing type

Type parameter '<typeparametername1>' must have either a 'New' constraint or a 'Structure' constraint to satisfy the 'New' constraint for type parameter '<typeparametername2>'

Type parameter already declared with name '<typeparametername>'

Type parameter cannot have the same name as its defining function

Type parameter name '<typeparametername1>' does not match the name '<typeparametername2>' of the corresponding type parameter defined on one of the other partial types of '<partialtypename>'

Type parameter not allowed in 'Implements' clause

Type parameter with a 'Structure' constraint cannot be used as a constraint

Type parameters cannot be specified on this declaration

Type parameters cannot be used as qualifiers

Type parameters or types constructed with type parameters are not allowed in attribute arguments

'Type' statements are no longer supported; use 'Structure' statements instead

'TypeOf...Is' requires its left operand to have a reference type, but this operand has the type '<type>'

Types are not available in this context

Types declared 'Private' must be inside another type

Unable to access member

Unable to apply security attribute(s) to '<name>': <error>

Unable to create a .NET Runtime interface: <error>

Unable to create Assembly Linker object: <error message>

Unable to create strong-named assembly from key file '<filename>': <error>

Unable to create temp file in path '<filename>': <error message>

Unable to create XML documentation file '<name>': <message>

Unable to embed resource file '<filename>': <error message>

Unable to emit assembly: <error message>

Unable to evaluate expression

Unable to find entry point '<name>' in DLL '<filename>': <error>

Unable to find required file '<filename>'

Unable to generate a reference to file '<filename>' (use TLBIMP utility to reference COM DLLs): <error message>

Unable to get type information for '<typename>'

Unable to include XML fragment '<elementpath>' of file '<commentfile>'

Unable to link to resource file '<filename>': <error message>

Unable to load DLL '<filename>': <error>

Unable to load information for class '<classname>'

Unable to load referenced library '<filename>': <error>

Unable to open file '<filename>': <error>

Unable to open key file '<filename>': <error>

Unable to open module file '<filename>': <error>

Unable to open resource file '<filename>': <error>

Unable to open response file '<filename>'

Unable to parse XML: <error>

Unable to sign assembly: <error message>

Unable to sign file '<filename>': <error>

Unable to write output to memory

Unable to write temporary file because temporary path is not available

Unable to write to output file '<filename>': <error>

Underlying type <typename> of Enum is not CLS-compliant

Unrecognized option <optionname>; ignored

Unscheduled Fiber

Unused local constant: '<constant>'

Unused local variable: '<localvariablename>'

Use command line option '<option>' or appropriate project settings instead of '<parameter>'

'Using' must end with a matching 'End Using'

'Using' operand of type '<typename>' must implement System.IDisposable

'Using' resource variable must have an explicit initialization

'Using' resource variable type can not be array type

'Using' statements are not valid in the Immediate window

Using the iteration variable in a lambda expression may have unexpected results

Value '<valuename1>' cannot be converted to '<valuename2>'

Value of type '<type1>' cannot be converted to '<type2>'

Value of type '<type1>' cannot be converted to '<type2>' because '<type3>' is not a reference type

Value of type '<type1>' cannot be converted to '<type2>' because '<type3>' is not derived from '<type4>'

Value of type '<type1>' cannot be converted to '<type2>' because the array types have different numbers of dimensions

Value of type '<typename1>' cannot be converted to '<typename2>'

Value of type '<typename1>' cannot be converted to '<typename2>' (Multiple file references)

Value of type 'type1' cannot be converted to 'type2'

Variable '<variablename>' hides a variable in an enclosing block

Variable '<variablename>' is passed by reference before it has been assigned a value

Variable '<variablename>' is passed by reference before it has been assigned a value (Structure Variable)

Variable '<variablename>' is used before it has been assigned a value

Variable '<variablename>' is used before it has been assigned a value (Visual Basic Error)

Variable cannot be initialized with non-array type '<elementname>'

Variable declaration statements are not valid in the Immediate window

Variable declaration without an 'As' clause; type of Object assumed

Variable uses an Automation type not supported in Visual Basic

Variables in Modules cannot be declared '<specifier>'

'Variant' is no longer a supported type; use the 'Object' type instead

Visual Basic compiler is unable to recover from the following error: <error>

Warning number '<number>' for the option '<optionname>' is either not configurable or not valid

Warning treated as error: <error>

Web methods cannot be evaluated in debug windows

'WebMethod' attribute will not affect this member because its containing class is not exposed as a web service

'Wend' statements are no longer supported; use 'End While' statements instead

'While' must end with a matching 'End While'

White space may not appear here

'Widening' and 'Narrowing' cannot be combined

'With' contexts and statements are not valid in debug windows

'With' must end with a matching 'End With'

'WithEvents' variable does not raise any events

'WithEvents' variable does not raise any instance events that are accessible to '<containername>'

WithEvents variable name length cannot exceed 1019 characters

'WithEvents' variables can only be typed as classes, interfaces or type parameters with class constraints

'WithEvents' variables cannot be typed as arrays

'WithEvents' variables must have an 'As' clause

'WriteOnly' properties cannot have an access modifier on 'Set'

'WriteOnly' property must provide a 'Set'

Wrong number of type arguments passed to method '<genericprocedurename>'

XML attribute 'attribute1' must appear before XML attribute 'attribute2'

XML attribute 'version' must be the first attribute in XML declaration

XML attributes cannot be selected from type 'type'

XML axis properties do not support late binding

XML comment block cannot be associated with any language element that supports the application of XML documentation comments

XML comment block must immediately precede the language element to which it applies

XML comment cannot appear within a method or a property

XML comment cannot be applied more than once on a partial <type>

XML comment exception must have a 'cref' attribute

XML comment has a tag with a 'cref' attribute '<attribute>' that could not be resolved

XML comment must be the first statement on a line

XML comment parameter '<parameter>' does not match a parameter on the corresponding <keyword> statement

XML comment parameter must have a 'name' attribute

XML comment tag '<tag>' appears with identical attributes more than once in the same XML comment block

XML comment tag '<tag>' is not permitted on a '<element>' language element

XML comment tag 'include' must have a '<attribute>' attribute

XML comment tag 'returns' is not permitted on a 'declare sub' language element

XML comment tag 'returns' is not permitted on a 'WriteOnly' Property

XML comment type parameter <parameter> does not match a type parameter on the corresponding <keyword> statement

XML comment type parameter must have a 'name' attribute

XML declaration does not allow attribute 'attributeName'

XML descendant elements cannot be selected from type 'type'

XML documentation parse error: <error>

XML documentation parse error: Start tag '<tag>' doesn't have a matching end tag

XML DTDs are not supported

XML elements cannot be selected from type 'type'

XML entity references are not supported

XML literal cannot appear here unless it is enclosed in parentheses

XML literals and XML axis properties are not available

XML literals and XML properties are not supported in embedded code within ASP.NET

XML name expected

XML namespace prefix 'prefix' is already declared

XML namespace prefix 'prefix' is not defined

XML namespace prefix 'prefix' is reserved for use by XML and the namespace URI cannot be changed

XML namespace URI 'http://www.w3.org/XML/1998/namespace' can be bound only to 'xmlns'

XML processing instruction name 'name' is not valid

You must reference at least one range variable on both sides of the 'Equals' operator

Minimize

This topic has not yet been rated - Rate this topic

Constants must be of an intrinsic or enumerated type, not a class, structure, type parameter, or array type

Visual Studio 2008

You have attempted to declare a constant as a class, structure, or array type, or as a type parameter defined by a containing generic type.

Constants must be of an intrinsic type (Boolean, Byte, Date, Decimal, Double, Integer, Long, Object, SByte, Short, Single, String, UInteger, ULong, or UShort), or an Enum type based on one of the integral types.

Error ID: BC30424

To correct this error

Declare the constant as an intrinsic or Enum type.
A constant can also be a special value such as True, False, or Nothing. The compiler considers these predefined values to be of the appropriate intrinsic type.

Concepts

Constants Overview

Data Types in Visual Basic

Reference

Data Type Summary (Visual Basic)

Other Resources

Constants and Enumerations (Visual Basic)

Did you find this helpful? Yes No

Not accurate

Not enough depth

Need more code examples

(1500 characters remaining)

Community Additions

© 2013 Microsoft. All rights reserved.