United States (English)

Home Library Learn Samples Downloads Support Community Forums

MSDN Library

Development Tools and Languages

Visual Studio 2005

Visual Studio

Visual Basic

Reference (Visual Basic)

Visual Basic Reference

Compiler Messages

'>' expected

'=' expected (Let or Set assignment)

'=' expected (Declaration)

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

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

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

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

'<typename>' is an unsupported type

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

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

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

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

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

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

'<typename>' is a delegate type

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

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

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

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

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

'<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 does not inherit from 'System.Attribute'

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

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

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

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

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

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

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

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

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

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

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

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

<type> parameters cannot be declared 'ParamArray'

<type> parameters cannot be declared 'Optional'

'<type>' cannot be inherited more than once

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

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

'<statementname>' statement requires an array

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

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

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

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

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

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

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

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

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

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

'<rsetstmt>' is not declared

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

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

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

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

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

<Property> parameters cannot be declared 'ByRef'

<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

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

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

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

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

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

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

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

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

'<nullconstant>' is not declared

'<namespacename>' is ambiguous

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

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

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

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

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

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

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

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

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

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

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

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

'<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 expose type <type1> in <specifier> <type2> '<typename>' through <name>

'<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 the underlying delegate type '<delegatetype>' of the event it is implementing to <specifier1> '<type1>' through <specifier2> '<type2>'

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

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

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

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

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

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

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

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

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

'<modifier>' is not valid on a Declare

'<methodname>' has multiple definitions with identical signatures

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

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

'<methodname>' cannot be implemented more than once

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

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

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

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

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

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

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

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

'<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 parameters declared 'ParamArray'

'<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 optional parameters

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

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

<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>

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

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

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

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

'<membername>' is not declared

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

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

'<membername>' exists in multiple base interfaces

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

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

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

'<member>' is already declared in this structure

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

'<mathfunction1>' is not declared

'<lsetstmt>' is not declared

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

'<keyword>' is valid only within a class

'<keyword>' is not valid within a structure

'<keyword>' is not valid within a Module

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

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

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

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

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

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

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

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

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

'<function>' is not declared

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

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

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

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

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

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

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

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

'<emptyconstant>' is not declared

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

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

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

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

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

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

'<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>'

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

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

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

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

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

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

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

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

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

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

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

'}' expected

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

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

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

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

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

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

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

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

'.' expected

')' expected

'(' expected

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

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

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

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

'#ExternalSource' directives cannot be nested

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

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

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

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

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

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

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

'-' expected

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

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

Access modifier '<accessmodifier>' is not valid

Alias '<namespacename>' is already declared

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

'AddressOf' expressions are not valid in debug windows

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

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

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

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

'AddHandler' is already declared

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

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

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

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

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

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

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

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

Array declarations cannot specify lower bounds

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

Array bounds cannot appear in type specifiers

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

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 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 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

Attributes cannot be applied to local variables

Attributes cannot be generics or types nested inside generics

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

Bad GUID format

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

'ByVal' and 'ByRef' cannot be combined

Cannot convert to '<type>'

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 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 specify both /win32icon and /win32resource

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

Can't open '<filename>' for writing

'Case' statements are not valid in the Immediate window

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

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

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

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 constant must contain exactly one character

Character is not valid

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

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' constraint cannot be specified multiple times for the same type parameter

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

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

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 '<classname>' should declare a 'Sub New' because the '<constructorname>' in its base class '<baseclassname>' is marked obsolete: '<errormessage>'

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

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

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

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 its base class '<classname2>' does not have an accessible 'Sub New' that can be called with no arguments

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

Classes cannot be declared '<specifier>'

Classes can inherit only from other classes

'Class_Terminate' event is no longer supported

'Class_Initialize' event is no longer supported

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

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

Codepage '<name>' is invalid or not installed

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

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

Compilation failed: <message>

'Compare' expected

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

Comma or ')' expected (Type Argument List)

Comma or ')' expected (Type Parameter List)

Comma or ')' expected (Procedure Parameter List)

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 standard library: '<filename>'

Could not find library '<libraryname>'

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

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

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

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

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

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

Derived classes cannot raise base class events

Delegates cannot implement interface methods

Delegates cannot handle events

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

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

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

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

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

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

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

Default member '<membername>' is not a property

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

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

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

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

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

Declaration expected

Date constant is not valid

'Do' must end with a matching 'Loop'

Division by zero occurred while evaluating this expression

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

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

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

Error creating Win32 resources: <error message>

Error creating assembly manifest: <error message>

Enums must be declared as an integral type

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

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

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

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

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

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

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

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

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

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

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

'End Sub' expected

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

'End' statements are not valid in the Immediate window

'End' statement not valid

'End' statement cannot be used in class library projects

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

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

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

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

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

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

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

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

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

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

'End Operator' expected

End of statement expected

End of parameter list expected

End of expression expected

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

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

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

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

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

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

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

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

'End Function' expected

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

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

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

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

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

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

Evaluation of expression or statement stopped

Evaluation of expression or statement timed out

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 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 recursively calls the containing property '<propertyname>'

Expression recursively calls containing Operator '<operatorsymbol>'

Expression or statement is not valid in debug windows

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

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

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

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

Expression is not a method

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

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

Expression expected

Expression does not produce a value

Expression cannot be evaluated at this time

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 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 cannot be of type '<type>'

'For' must end with a matching 'Next'

'Get' is already declared

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

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

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

Generic parameters used as optional parameter types must be class constrained

Generic methods cannot use 'Handles' clause

Generic methods cannot be exposed to COM

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

Function evaluation is disabled because a previous function evaluation timed out

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

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

'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

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 is too long

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

'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 '<underlyingclassname>' for interface '<interfacename>' is not accessible in this context because it is '<accesslevel>'

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

'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.

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

Initialization error

'Inherits' statements must precede all declarations in an interface

'Inherits' statement must precede all declarations in a class

'Inherits' not valid in Modules

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

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

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

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

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

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

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

Inappropriate use of <keyword> keyword in a module

'Imports' statements must precede any declarations

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

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

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

Internal compiler error: code generator received malformed input

Internal compiler error

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

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

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

Interface can inherit only from another interface

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

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

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

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

Integer constant expected

'IsNot' 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

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

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

'Is' expected

Late bound resolution; runtime errors could occur

Labels that are numbers must be followed by colons

Labels are not valid outside methods

Labels are not valid in the Immediate window

Label '<labelname>' is not defined

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

Keyword is not valid as an identifier

Keyword does not name a type

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

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

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

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

Local variables within generic methods cannot be declared 'Static'

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

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

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

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

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

Line is too long

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

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

Loop statements are not valid in the Immediate window

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

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

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

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

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

Member '<membername1>' conflicts with a member implicitly declared for member '<membername2>' 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 '<membername>' conflicts with member '<membername>' in the base type '<basetypename>' and so should not be declared 'Overloads'

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

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>

'Me' cannot be the target of an assignment

Maximum number of errors has been exceeded

Maximum number of warnings has been exceeded

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

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>' does not have the same signature as delegate '<delegatename>'

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

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

Method declaration statements must be the first on a logical line

Method cannot have both a ParamArray and Optional parameters

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

Method call did not return a value

Method arguments must be enclosed in parentheses

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

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

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

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

Modules cannot be generic

Modules cannot be declared '<specifier>'

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

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

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

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

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

'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' cannot be applied to a class that is generic or nested inside a generic type

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

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

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

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

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

Methods in a Module cannot implement interface members

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

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

Methods declared in structures cannot have 'Handles' clauses

Methods cannot be declared 'Static'

Name '<name>' is not declared

Name <membername> is not CLS-compliant

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

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

'MyClass' cannot be used outside of a class

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

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

Named argument expected

Named argument cannot match a ParamArray parameter

Named arguments are not valid as array subscripts

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

No accessible method '<procedurename>' matches the signature of delegate '<delegatename>':<suberrorlist>

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

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

No accessible non-generic '<procedurename>' found

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

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

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

'Next' expected

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

'New' is not valid in this context

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

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

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

'New' cannot be used on an interface

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

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

No input sources specified

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

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

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

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

'Nothing' cannot be evaluated

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

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

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

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-CLS-compliant 'MustOverride' member is not allowed in a CLS-compliant <classname>

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

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

Object no longer exists due to compile error or deletion

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

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

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

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

Omitted argument cannot match a ParamArray parameter

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

Only one XML comment block is allowed per language element

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

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

Only conversion operators can be declared '<keyword>'

Operator is not overloadable

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

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

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

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

Operator '<operator>' must have two parameters

Operator '<operator>' must have one parameter

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

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

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

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

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

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

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

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

Optional parameters must specify a default value

Optional parameters cannot have structure types

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

'Optional' expected

'Optional' and 'ParamArray' cannot be combined

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

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

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

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

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 late binding

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 implicit conversions from '<type1>' to '<type2>'

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

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

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

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

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

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

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

Option <optionname> requires <argument>

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

Operators must be declared 'Shared'

Operators must be declared 'Public'

Operators cannot be declared in Modules

Operators cannot be declared '<keyword>'

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

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 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>' in '<methodname>' 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 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

Possible problem detected while building assembly: <error>

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

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

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

Properties with no required parameters cannot be declared 'Default'

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

Properties declared 'WriteOnly' cannot have a 'Get'

Properties declared 'ReadOnly' cannot have a 'Set'

Properties cannot be declared '<modifiername>'

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

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

Project has been closed

Project already has a reference to assembly <assemblyidentity>

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

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 Warning)

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

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

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

Property accessors cannot be declared '<keyword>'

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

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

Property access must assign to the property or use its value

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

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

Property '<propertyname>' is 'WriteOnly'

Property '<propertyname>' is 'ReadOnly'

Property '<propertyname>' is of an unsupported type

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

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'

Protected types can only be declared inside of a class

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

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

'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

'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

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

Referenced object has a value of 'Nothing'

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

Referenced array element has a value of 'Nothing'

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

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

Reference to a non-shared member requires an object reference

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 module '<modulename>' containing the type '<membername>'

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

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

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

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

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

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

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

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

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

'RemoveHandler' is already declared

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

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

Relational operator expected

'Resume' statements are not valid in the Immediate window

'Resume' or 'GoTo' expected

Response file <filename> included multiple times

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

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

'Return' statements are not valid in the Immediate window

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

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

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

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

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

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

Run-time exception thrown

Root namespace <namespacename> is not CLS-compliant

'Set' method cannot have more than one parameter

'Set' is already declared

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

'Select' statements are not valid in the Immediate window

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

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

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

Side effects not valid during expression evaluation in this context

Shared 'Sub New' cannot have any parameters

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

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

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

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

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

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

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

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 constants must end with a double quote

String constant expected

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

'Sub' or 'Function' expected

'Sub New' cannot implement interface members

'Sub New' cannot handle events

'Sub New' cannot be declared 'Overrides'

'Sub New' cannot be declared in an interface

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

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

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

Structures cannot have 'Inherits' statements

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

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

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

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

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

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

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

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

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

Syntax error in conditional compilation expression

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

Syntax error (Visual Basic Error)

'SyncLock' statements are not valid in the Immediate window

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

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

Suspend request is pending

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

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

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

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

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

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

'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 a method that is generic or nested in a generic type

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

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

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

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

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

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

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

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

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

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

The ConnectionTimeout must be greater than 0

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

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

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 targeted version of the .NET Compact Framework does not support using the Ansi, Auto or Unicode modifier

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 latebound overload resolution

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

The maximum number of errors has been exceeded

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

Too many arguments to '<procedurename>'

Too few type arguments to '<generictypename>'

'Throw' statements are not valid in the Immediate window

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

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

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

Type expected

Type declaration characters are not valid in this context

Type constraint cannot be a 'NotInheritable' class

Type constraint '<expression>' is not a class or interface

Type characters are not allowed on Imports aliases

Type characters are not allowed in label identifiers

Type character cannot be used in a type parameter declaration

Type character cannot be used in a 'Sub' declaration because a 'Sub' doesn't return a value

Type character '<charactername>' does not match declared data type '<type>'

Type character '<character>' cannot be used in a declaration with an explicit type

Type arguments unexpected because attributes cannot be generics

Type arguments unexpected

Type arguments inferred for method '<procedurename>' result in the following warnings :<warninglist>

Type arguments inferred for method '<procedurename>' result in the following errors :<errorlist>

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

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

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

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

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

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

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

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

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

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

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

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

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 CLS-compliant

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

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

Type '<typename>' has no constructors

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

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

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

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

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>' and partial type '<typename>' conflict in container '<containername>', but are being merged because one of them is declared partial

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

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

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

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

'Try' statements are not valid in the Immediate window

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

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

Too many type arguments to '<generictypename>'

Unable to generate a reference to file '<filename>' (use TLBIMP utility to reference COM DLLs): <error message>

Unable to find required file '<filename>'

Unable to find entry point '<name>' in DLL '<filename>': <error>

Unable to evaluate expression

Unable to emit assembly: <error message>

Unable to embed resource file '<filename>': <error message>

Unable to create XML documentation file '<name>': <message>

Unable to create temp file in path '<filename>': <error message>

Unable to create strong-named assembly from key file '<filename>': <error>

Unable to create Assembly Linker object: <error message>

Unable to create a .NET Runtime interface: <error>

Unable to apply security attribute(s) to '<name>': <error>

Unable to access member

Types declared 'Private' must be inside another type

Types are not available in this context

'TypeOf...Is' requires its left operand to have a reference type, but this operand has the type '<type>'

'Type' statements are no longer supported; use 'Structure' statements instead

Type parameters or types constructed with type parameters are not allowed in attribute arguments

Type parameters cannot be used as qualifiers

Type parameters cannot be specified on this declaration

Type parameter with a 'Structure' constraint cannot be used as a constraint

Type parameter not allowed in 'Implements' clause

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 cannot have the same name as its defining function

Type parameter already declared with name '<typeparametername>'

Type parameter '<typeparametername1>' must have either a 'New' constraint or a 'Structure' constraint to satisfy the 'New' constraint for type parameter '<typeparametername2>'

Type parameter '<typeparametername>' cannot be constrained to itself: '<errormessage>'

Type parameter '<typeparametername>' can only have one constraint that is a class

Type parameter '<typeparametername>' has the same name as a type parameter of an enclosing type

Type parameter '<typeparametername>' for '<genericprocedurename>' cannot be inferred

Type or 'New' expected

Type of parameter '<parametername>' is not CLS-compliant

Type of optional value for optional parameter <parametername> is not CLS-compliant

Type of member '<membername>' is not CLS-compliant

Unable to load referenced library '<filename>': <error>

Unable to load information for class '<classname>'

Unable to load DLL '<filename>': <error>

Unable to link to resource file '<filename>': <error message>

Unable to get type information for '<typename>'

Unable to parse XML: <error>

Unable to open response file '<filename>'

Unable to open resource file '<filename>': <error>

Unable to open module file '<filename>': <error>

Unable to open key file '<filename>': <error>

Unable to open file '<filename>': <error>

Unable to sign file '<filename>': <error>

Unable to sign assembly: <error message>

Unable to write temporary file because temporary path is not available

Unable to write output to memory

Unused local variable: '<localvariablename>'

Unscheduled Fiber

Unrecognized option <optionname>; ignored

Underlying type <typename> of Enum is not CLS-compliant

Unable to write to output file '<filename>': <error>

'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

Value '<valuename1>' cannot be converted to '<valuename2>'

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>'

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

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>' hides a variable in an enclosing block

Variable '<variablename>' is used before it has been assigned a value (Visual Basic Error)

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'

'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 documentation parse error: Start tag '<tag>' doesn't have a matching end tag

XML documentation parse error: <error>

XML comment type parameter must have a 'name' attribute

XML comment type parameter <parameter> does not match a type parameter on the corresponding <keyword> statement

XML comment tag 'returns' is not permitted on a 'WriteOnly' Property

XML comment tag 'returns' is not permitted on a 'declare sub' language element

XML comment tag 'include' must have a '<attribute>' attribute

XML comment tag '<tag>' is not permitted on a '<element>' language element

XML comment tag '<tag>' appears with identical attributes more than once in the same XML comment block

XML comment parameter must have a 'name' attribute

XML comment parameter '<parameter>' does not match a parameter on the corresponding <keyword> statement

XML comment must be the first statement on a line

XML comment has a tag with a 'cref' attribute '<attribute>' that could not be resolved

XML comment exception must have a 'cref' attribute

XML comment cannot be applied more than once on a partial <type>

XML comment cannot appear within a method or a property

XML comment block must immediately precede the language element to which it applies

XML comment block cannot be associated with any language element that supports the application of XML documentation comments

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

cannot send error report automatically

Unable to include XML fragment '<elementpath>' of file '<commentfile>'

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

Attribute 'StructLayout' can not be applied to a generic type

A class used in the expression is not loaded during debugging session

Comment statements cannot be evaluated

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

Next control variable does not match For loop control variable

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

Minimize

This topic has not yet been rated - Rate this topic

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

Visual Studio 2005

Visual Studio 2008

A Try block must include either a Finally block or at least one Catch block before the End Try statement.

Error ID: BC30030

To correct this error

Add a Catch or Finally block within the Try block.

See Also

Reference

Try...Catch...Finally Statement (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.