このブラウザーはサポートされなくなりました。

Microsoft Edge にアップグレードすると、最新の機能、セキュリティ更新プログラム、およびテクニカル サポートを利用できます。

型のメンバーは、ストレージの場所と実行可能コードを定義します。 Type members define storage locations and executable code. メソッド、コンストラクター、イベント、定数、変数、およびプロパティを指定できます。 They can be methods, constructors, events, constants, variables, and properties.

インターフェイス メソッドの実装 Interface Method Implementation

メソッド、イベント、およびプロパティは、インターフェイスメンバーを実装できます。 Methods, events, and properties can implement interface members. インターフェイスメンバーを実装するには、メンバー宣言でキーワードを指定し、 Implements 1 つまたは複数のインターフェイスメンバーを一覧表示します。 To implement an interface member, a member declaration specifies the Implements keyword and lists one or more interface members.

ImplementsClause
    : ( 'Implements' ImplementsList )?
ImplementsList
    : InterfaceMemberSpecifier ( Comma InterfaceMemberSpecifier )*
InterfaceMemberSpecifier
    : NonArrayTypeName Period IdentifierOrKeyword
インターフェイスメンバーを実装するメソッドとプロパティは NotOverridable MustOverride 、、、または別のメンバーをオーバーライドするように宣言しない限り、暗黙的に暗黙的に使用され Overridable ます。Methods and properties that implement interface members are implicitly NotOverridable unless declared to be MustOverride, Overridable, or overriding another member. インターフェイスメンバーを実装するメンバーがである場合、このエラーが発生 Shared します。It is an error for a member implementing an interface member to be Shared. メンバーのアクセシビリティは、インターフェイスメンバーを実装する機能には影響しません。A member's accessibility has no effect on its ability to implement interface members.
インターフェイスの実装を有効にするには、含んでいる型の実装リストが、互換性のあるメンバーを含むインターフェイスに名前を指定する必要があります。For an interface implementation to be valid, the implements list of the containing type must name an interface that contains a compatible member. 互換性のあるメンバーとは、実装するメンバーのシグネチャと一致するシグネチャを持つメンバーのことです。A compatible member is one whose signature matches the signature of the implementing member. ジェネリックインターフェイスが実装されている場合は、Implements 句に指定された型引数が、互換性をチェックするときにシグネチャに置き換えられます。If a generic interface is being implemented, then the type argument supplied in the Implements clause is substituted into the signature when checking compatibility. 次に例を示します。For example:
Interface I1(Of T)
    Sub F(x As T)
End Interface
Class C1
    Implements I1(Of Integer)
    Sub F(x As Integer) Implements I1(Of Integer).F
    End Sub
End Class
Class C2(Of U)
    Implements I1(Of U)
    Sub F(x As U) Implements I1(Of U).F
    End Sub
End Class
デリゲート型を使用して宣言されたイベントがインターフェイスイベントを実装している場合、互換性のあるイベントとは、基になるデリゲート型が同じ型であるイベントのことです。If an event declared using a delegate type is implementing an interface event, then a compatible event is one whose underlying delegate type is the same type. それ以外の場合、イベントは、実装しているインターフェイスイベントのデリゲート型を使用します。Otherwise, the event uses the delegate type from the interface event it is implementing. このようなイベントに複数のインターフェイスイベントが実装されている場合、すべてのインターフェイスイベントの基になるデリゲート型が同じである必要があります。If such an event implements multiple interface events, all the interface events must have the same underlying delegate type. 次に例を示します。For example:
Interface ClickEvents
    Event LeftClick(x As Integer, y As Integer)
    Event RightClick(x As Integer, y As Integer)
End Interface
Class Button
    Implements ClickEvents
    ' OK. Signatures match, delegate type = ClickEvents.LeftClickHandler.
    Event LeftClick(x As Integer, y As Integer) _
        Implements ClickEvents.LeftClick
    ' OK. Signatures match, delegate type = ClickEvents.RightClickHandler.
    Event RightClick(x As Integer, y As Integer) _
        Implements ClickEvents.RightClick
End Class
Class Label
    Implements ClickEvents
    ' Error. Signatures match, but can't be both delegate types.
    Event Click(x As Integer, y As Integer) _
        Implements ClickEvents.LeftClick, ClickEvents.RightClick
End Class
Implements リストのインターフェイスメンバーは、型名、ピリオド、および識別子を使用して指定されます。An interface member in the implements list is specified using a type name, a period, and an identifier. 型名は、implements リスト内のインターフェイス、または implements リスト内のインターフェイスの基本インターフェイスである必要があります。また、識別子は、指定されたインターフェイスのメンバーである必要があります。The type name must be an interface in the implements list or a base interface of an interface in the implements list, and the identifier must be a member of the specified interface. 1つのメンバーは、複数の一致するインターフェイスメンバーを実装できます。A single member can implement more than one matching interface member.
Interface ILeft
    Sub F()
End Interface
Interface IRight
    Sub F()
End Interface
Class Test
    Implements ILeft, IRight
    Sub F() Implements ILeft.F, IRight.F
    End Sub
End Class
実装するインターフェイスメンバーが、複数のインターフェイスの継承によって明示的に実装されたすべてのインターフェイスで使用できない場合は、そのメンバーが使用可能な基本インターフェイスを実装するメンバーが明示的に参照する必要があります。If the interface member being implemented is unavailable in all explicitly implemented interfaces because of multiple interface inheritance, the implementing member must explicitly reference a base interface on which the member is available. たとえば、とがメンバーを含み、とを継承している場合、を I1 I2 M I3 I1 I2 実装する型は I3 とを実装し I1.M I2.M ます。For example, if I1 and I2 contain a member M, and I3 inherits from I1 and I2, a type implementing I3 will implement I1.M and I2.M. インターフェイスのシャドウが継承されたメンバーを乗算する場合、実装する型は、継承されたメンバーとそのメンバーをシャドウするメンバーを実装する必要があります。If an interface shadows multiply inherited members, an implementing type will have to implement the inherited members and the member(s) shadowing them.
Interface ILeft
    Sub F()
End Interface
Interface IRight
    Sub F()
End Interface
Interface ILeftRight
    Inherits ILeft, IRight
    Shadows Sub F()
End Interface
Class Test
    Implements ILeftRight
    Sub LeftF() Implements ILeft.F
    End Sub
    Sub RightF() Implements IRight.F
    End Sub
    Sub LeftRightF() Implements ILeftRight.F
    End Sub
End Class
インターフェイスメンバーのコンテナーインターフェイスを実装する場合は、実装するインターフェイスと同じ型引数を指定する必要があります。If the containing interface of the interface member be implemented is generic, the same type arguments as the interface being implements must be supplied. 次に例を示します。For example:
Interface I1(Of T)
    Function F() As T
End Interface
Class C1
    Implements I1(Of Integer)
    Implements I1(Of Double)
    Function F1() As Integer Implements I1(Of Integer).F
    End Function
    Function F2() As Double Implements I1(Of Double).F
    End Function
    ' Error: I1(Of String) is not implemented by C1
    Function F3() As String Implements I1(Of String).F
    End Function
End Class
Class C2(Of U)
    Implements I1(Of U)
    Function F() As U Implements I1(Of U).F
    End Function
End Class
メソッドMethods
メソッドには、プログラムの実行可能なステートメントが含まれています。Methods contain the executable statements of a program.
MethodMemberDeclaration
    : MethodDeclaration
    | ExternalMethodDeclaration
InterfaceMethodMemberDeclaration
    : InterfaceMethodDeclaration
MethodDeclaration
    : SubDeclaration
    | MustOverrideSubDeclaration
    | FunctionDeclaration
    | MustOverrideFunctionDeclaration
InterfaceMethodDeclaration
    : InterfaceSubDeclaration
    | InterfaceFunctionDeclaration
SubSignature
    : 'Sub' Identifier TypeParameterList?
      ( OpenParenthesis ParameterList? CloseParenthesis )?
FunctionSignature
    : 'Function' Identifier TypeParameterList?
      ( OpenParenthesis ParameterList? CloseParenthesis )?
      ( 'As' Attributes? TypeName )?
SubDeclaration
    : Attributes? ProcedureModifier* SubSignature
      HandlesOrImplements? LineTerminator
      Block
      'End' 'Sub' StatementTerminator
MustOverrideSubDeclaration
    : Attributes? MustOverrideProcedureModifier+ SubSignature
      HandlesOrImplements? StatementTerminator
InterfaceSubDeclaration
    : Attributes? InterfaceProcedureModifier* SubSignature StatementTerminator
FunctionDeclaration
    : Attributes? ProcedureModifier* FunctionSignature
      HandlesOrImplements? LineTerminator
      Block
      'End' 'Function' StatementTerminator
MustOverrideFunctionDeclaration
    : Attributes? MustOverrideProcedureModifier+ FunctionSignature
      HandlesOrImplements? StatementTerminator
InterfaceFunctionDeclaration
    : Attributes? InterfaceProcedureModifier* FunctionSignature StatementTerminator
ProcedureModifier
    : AccessModifier | 'Shadows' | 'Shared' | 'Overridable' | 'NotOverridable' | 'Overrides'
    | 'Overloads' | 'Partial' | 'Iterator' | 'Async'
MustOverrideProcedureModifier
    : ProcedureModifier
    | 'MustOverride'
InterfaceProcedureModifier
    : 'Shadows' | 'Overloads'
HandlesOrImplements
    : HandlesClause
    | ImplementsClause
省略可能なパラメーターのリストと戻り値 (省略可能) を持つメソッドは、共有されているか、共有されていません。Methods, which have an optional list of parameters and an optional return value, are either shared or not shared. 共有メソッドには、クラスまたはクラスのインスタンスを使用してアクセスします。Shared methods are accessed through the class or instances of the class. 非共有メソッド (インスタンスメソッドとも呼ばれます) には、クラスのインスタンスを介してアクセスします。Non-shared methods, also called instance methods, are accessed through instances of the class. 次の例は、 Stack 複数の共有メソッド ( Clone および Flip ) と、いくつかのインスタンスメソッド ( Push 、 Pop 、および ToString ) を持つクラスを示しています。The following example shows a class Stack that has several shared methods (Clone and Flip), and several instance methods (Push, Pop, and ToString):
Public Class Stack
    Public Shared Function Clone(s As Stack) As Stack
    End Function
    Public Shared Function Flip(s As Stack) As Stack
    End Function
    Public Function Pop() As Object
    End Function
    Public Sub Push(o As Object)
    End Sub 
    Public Overrides Function ToString() As String
    End Function 
End Class 
Module Test
    Sub Main()
        Dim s As Stack = New Stack()
        Dim i As Integer
        While i < 10
            s.Push(i)
        End While
        Dim flipped As Stack = Stack.Flip(s)
        Dim cloned As Stack = Stack.Clone(s)
        Console.WriteLine("Original stack: " & s.ToString())
        Console.WriteLine("Flipped stack: " & flipped.ToString())
        Console.WriteLine("Cloned stack: " & cloned.ToString())
    End Sub
End Module
メソッドはオーバーロードすることができます。つまり、複数のメソッドが一意のシグネチャを持つ限り、同じ名前を持つことができます。Methods can be overloaded, which means that multiple methods may have the same name so long as they have unique signatures. メソッドのシグネチャは、パラメーターの数と型で構成されます。The signature of a method consists of the number and types of its parameters. メソッドのシグネチャには、戻り値の型やパラメーター修飾子 (省略可能、ByRef、ParamArray など) は含まれません。The signature of a method specifically does not include the return type or parameter modifiers such as Optional, ByRef or ParamArray. 次の例は、多数のオーバーロードを持つクラスを示しています。The following example shows a class with a number of overloads:
Module Test
    Sub F()
        Console.WriteLine("F()")
    End Sub 
    Sub F(o As Object)
        Console.WriteLine("F(Object)")
    End Sub
    Sub F(value As Integer)
        Console.WriteLine("F(Integer)")
    End Sub 
    Sub F(a As Integer, b As Integer)
        Console.WriteLine("F(Integer, Integer)")
    End Sub 
    Sub F(values() As Integer)
        Console.WriteLine("F(Integer())")
    End Sub 
    Sub G(s As String, Optional s2 As String = 5)
        Console.WriteLine("G(String, Optional String")
    End Sub
    Sub G(s As String)
        Console.WriteLine("G(String)")
    End Sub
    Sub Main()
        F(CType(1, Object))
        F(1, 2)
        F(New Integer() { 1, 2, 3 })
        G("hello")
        G("hello", "world")
    End Sub
End Module
プログラムの出力は次のようになります。The output of the program is:
F(Integer)
F(Object)
F(Integer, Integer)
F(Integer())
G(String)
G(String, Optional String)
省略可能なパラメーターのみが異なるオーバーロードは、ライブラリの "バージョン管理" に使用できます。Overloads that differ only in optional parameters can be used for "versioning" of libraries. たとえば、ライブラリの v1 には、省略可能なパラメーターを持つ関数が含まれる場合があります。For instance, v1 of a library might include a function with optional parameters:
Sub fopen(fileName As String, Optional accessMode as Integer = 0)
次に、ライブラリの v2 は、もう1つの省略可能なパラメーター "password" を追加しようとします。これは、ソースの互換性を損なうことなく (つまり、v1 をターゲットとするアプリケーションを再コンパイルできます)、バイナリの互換性を損なうことなく実行しますThen v2 of the library wants to add another optional parameter "password", and it wants to do so without breaking source compatibility (so applications that used to target v1 can be recompiled), and without breaking binary compatibility (so applications that used to reference v1 can now reference v2 without recompilation). V2 は次のようになります。This is how v2 will look:
Sub fopen(file As String, mode as Integer)
Sub fopen(file As String, Optional mode as Integer = 0, Optional pword As String = "")
パブリック API の省略可能なパラメーターは CLS に準拠していないことに注意してください。Note that optional parameters in a public API are not CLS-compliant. ただし、少なくとも Visual Basic と C# 4 および F # で使用できます。However, they can be consumed at least by Visual Basic and C#4 and F#.
標準、非同期、および反復子メソッドの宣言Regular, Async and Iterator Method Declarations
2種類のメソッドがあります。値を返さない サブルーチン と、関数を実行する 関数 です。There are two types of methods: subroutines, which do not return values, and functions, which do. メソッド End がインターフェイスで定義されているか、または修飾子を持っている場合にのみ、メソッドの本体と構造を省略できます MustOverride 。The body and End construct of a method may only be omitted if the method is defined in an interface or has the MustOverride modifier. 関数に戻り値の型が指定されておらず、厳密なセマンティクスが使用されている場合、コンパイル時エラーが発生します。それ以外の場合、型は暗黙的 Object またはメソッドの型文字の型になります。If no return type is specified on a function and strict semantics are being used, a compile-time error occurs; otherwise the type is implicitly Object or the type of the method's type character. メソッドの戻り値の型とパラメーターの型のアクセシビリティドメインは、またはメソッド自体のアクセシビリティドメインのスーパーセットと同じである必要があります。The accessibility domain of the return type and parameter types of a method must be the same as or a superset of the accessibility domain of the method itself.




    

通常のメソッド は、 Async も修飾子も Iterator ありません。A regular method is one with neither Async nor Iterator modifiers. これは、サブルーチンまたは関数である可能性があります。It may be a subroutine or a function. セクションの 通常のメソッド では、通常のメソッドが呼び出されたときの動作について詳しく説明します。Section Regular Methods details what happens when a regular method is invoked.
Iterator メソッド は修飾子を持ち、修飾子を使用し Iterator ません Async 。An iterator method is one with the Iterator modifier and no Async modifier. これは関数である必要があり、戻り値の型は、、、またはのいずれかである必要があり、パラメーターを持たない必要があり IEnumerator IEnumerable IEnumerator(Of T) IEnumerable(Of T) T ByRef ます。It must be a function, and its return type must be IEnumerator, IEnumerable, or IEnumerator(Of T) or IEnumerable(Of T) for some T, and it must have no ByRef parameters. 「 反復子メソッド 」セクションでは、反復子メソッドが呼び出されたときの動作について詳しく説明します。Section Iterator Methods details what happens when an iterator method is invoked.
非同期メソッド は、修飾子を持ち、修飾子を使用し Async ません Iterator 。An async method is one with the Async modifier and no Iterator modifier. これは、サブルーチン、または戻り値の型がまたはの関数である必要があり、パラメーターを指定することはできません Task Task(Of T) T ByRef 。It must be either a subroutine, or a function with return type Task or Task(Of T) for some T, and must have no ByRef parameters. 「 非同期メソッド 」セクションでは、非同期メソッドが呼び出されたときの動作について詳しく説明します。Section Async Methods details what happens when an async method is invoked.
メソッドがこれら3種類のメソッドのいずれでもない場合、コンパイル時エラーになります。It is a compile-time error if a method is not one of these three kinds of method.
サブルーチンと関数の宣言は、先頭と末尾のステートメントが論理行の先頭から開始する必要があることに特に意味があります。Subroutine and function declarations are special in that their beginning and end statements must each start at the beginning of a logical line. また、非 MustOverride サブルーチンまたは関数宣言の本体は、論理行の先頭から始める必要があります。Additionally, the body of a non-MustOverride subroutine or function declaration must start at the beginning of a logical line. 次に例を示します。For example:
Module Test
    ' Illegal: Subroutine doesn't start the line
    Public x As Integer : Sub F() : End Sub
    ' Illegal: First statement doesn't start the line
    Sub G() : Console.WriteLine("G")
    End Sub
    ' Illegal: End Sub doesn't start the line
    Sub H() : End Sub
End Module
外部メソッドの宣言External Method Declarations
外部メソッドの宣言には、プログラムの外部で実装が提供される新しいメソッドが導入されています。An external method declaration introduces a new method whose implementation is provided external to the program.
ExternalMethodDeclaration
    : ExternalSubDeclaration
    | ExternalFunctionDeclaration
ExternalSubDeclaration
    : Attributes? ExternalMethodModifier* 'Declare' CharsetModifier? 'Sub'
      Identifier LibraryClause AliasClause?
      ( OpenParenthesis ParameterList? CloseParenthesis )? StatementTerminator
ExternalFunctionDeclaration
    : Attributes? ExternalMethodModifier* 'Declare' CharsetModifier? 'Function'
      Identifier LibraryClause AliasClause?
      ( OpenParenthesis ParameterList? CloseParenthesis )?
      ( 'As' Attributes? TypeName )?
      StatementTerminator
ExternalMethodModifier
    : AccessModifier
    | 'Shadows'
    | 'Overloads'
CharsetModifier
    : 'Ansi' | 'Unicode' | 'Auto'
LibraryClause
    : 'Lib' StringLiteral
AliasClause
    : 'Alias' StringLiteral
外部メソッドの宣言には実際の実装がないため、メソッド本体またはコンストラクトはありません End 。Because an external method declaration provides no actual implementation, it has no method body or End construct. 外部メソッドは暗黙的に共有され、型パラメーターを持つことはできません。また、イベントを処理したり、インターフェイスメンバーを実装したりすることはできません。External methods are implicitly shared, may not have type parameters, and may not handle events or implement interface members. 関数に戻り値の型が指定されておらず、厳密なセマンティクスが使用されている場合、コンパイル時エラーが発生します。If no return type is specified on a function and strict semantics are being used, a compile-time error occurs. それ以外の場合、型は暗黙的 Object またはメソッドの型文字の型になります。Otherwise the type is implicitly Object or the type of the method's type character. 外部メソッドの戻り値の型とパラメーターの型のアクセシビリティドメインは、外部メソッド自体のアクセシビリティドメインのスーパーセットと同じである必要があります。The accessibility domain of the return type and parameter types of an external method must be the same as or a superset of the accessibility domain of the external method itself.
外部メソッドの宣言の library 句は、メソッドを実装する外部ファイルの名前を指定します。The library clause of an external method declaration specifies the name of the external file that implements the method. 省略可能な alias 句は、外部ファイル内の数値の序数 (先頭が # 文字) またはメソッドの名前を指定する文字列です。The optional alias clause is a string that specifies the numeric ordinal (prefixed by a # character) or name of the method in the external file. 1文字セット修飾子を指定することもできます。これは、外部メソッドの呼び出し中に文字列をマーシャリングするために使用される文字セットを制御します。A single-character set modifier may also be specified, which governs the character set used to marshal strings during a call to the external method. 修飾子は、 Unicode すべての文字列を Unicode 値にマーシャリングし、 Ansi 修飾子はすべての文字列を ANSI 値にマーシャリングします。修飾子は、 Auto メソッドの名前に基づいて .NET Framework の規則に従って文字列をマーシャリングします。または、指定されている場合はエイリアス名をマーシャリングします。The Unicode modifier marshals all strings to Unicode values, the Ansi modifier marshals all strings to ANSI values, and the Auto modifier marshals the strings according to .NET Framework rules based on the name of the method, or the alias name if specified. 修飾子が指定されていない場合、既定値はに Ansi なります。If no modifier is specified, the default is Ansi.
またはが指定されている場合、 Ansi Unicode メソッド名は外部ファイルでは変更されずに検索されます。If Ansi or Unicode is specified, then the method name is looked up in the external file with no modification. を指定した場合 Auto 、メソッド名の参照はプラットフォームに依存します。If Auto is specified, then method name lookup depends on the platform. プラットフォームが ANSI (たとえば、Windows 95、Windows 98、Windows ME) と見なされた場合、メソッド名は変更されずに検索されます。If the platform is considered to be ANSI (for example, Windows 95, Windows 98, Windows ME), then the method name is looked up with no modification. 参照が失敗した場合、 A が追加され、参照が再試行されます。If the lookup fails, an A is appended and the lookup tried again. プラットフォームが Unicode (Windows NT、Windows 2000、Windows XP など) と見なされた場合、 W が追加され、名前が検索されます。If the platform is considered to be Unicode (for example, Windows NT, Windows 2000, Windows XP), then a W is appended and the name is looked up. 参照が失敗した場合は、を指定せずに参照が再試行され W ます。If the lookup fails, the lookup is tried again without the W. 次に例を示します。For example:
Module Test
    ' All platforms bind to "ExternSub".
    Declare Ansi Sub ExternSub Lib "ExternDLL" ()
    ' All platforms bind to "ExternSub".
    Declare Unicode Sub ExternSub Lib "ExternDLL" ()
    ' ANSI platforms: bind to "ExternSub" then "ExternSubA".
    ' Unicode platforms: bind to "ExternSubW" then "ExternSub".
    Declare Auto Sub ExternSub Lib "ExternDLL" ()
End Module
外部メソッドに渡されるデータ型は、.NET Framework のデータマーシャリング規則に従って、1つの例外でマーシャリングされます。Data types being passed to external methods are marshaled according to the .NET Framework data marshalling conventions with one exception. 値によって渡される文字列変数 (つまり、 ByVal x As String ) は OLE オートメーション BSTR 型にマーシャリングされ、外部メソッドで BSTR に加えられた変更は文字列引数に戻されます。String variables that are passed by value (that is, ByVal x As String) are marshaled to the OLE Automation BSTR type, and changes made to the BSTR in the external method are reflected back in the string argument. これは、外部メソッドの型が変更可能であり、 String この特殊なマーシャリングはその動作を模倣しているためです。This is because the type String in external methods is mutable, and this special marshalling mimics that behavior. 参照によって渡される文字列パラメーター (つまり ByRef x As String ) は、OLE オートメーション BSTR 型へのポインターとしてマーシャリングされます。String parameters that are passed by reference (i.e. ByRef x As String) are marshaled as a pointer to the OLE Automation BSTR type. パラメーターに属性を指定することで、これらの特殊な動作をオーバーライドでき System.Runtime.InteropServices.MarshalAsAttribute ます。It is possible to override these special behaviors by specifying the System.Runtime.InteropServices.MarshalAsAttribute attribute on the parameter.
外部メソッドの使用例を次に示します。The example demonstrates use of external methods:
Class Path
    Declare Function CreateDirectory Lib "kernel32" ( _
        Name As String, sa As SecurityAttributes) As Boolean
    Declare Function RemoveDirectory Lib "kernel32" ( _
        Name As String) As Boolean
    Declare Function GetCurrentDirectory Lib "kernel32" ( _
        BufSize As Integer, Buf As String) As Integer
    Declare Function SetCurrentDirectory Lib "kernel32" ( _
        Name As String) As Boolean
End Class
オーバーライド可能なメソッドOverridable Methods
修飾子は、 Overridable メソッドがオーバーライド可能であることを示します。The Overridable modifier indicates that a method is overridable. 修飾子は、 Overrides メソッドが、同じシグネチャを持つ基本型のオーバーライド可能なメソッドをオーバーライドすることを示します。The Overrides modifier indicates that a method overrides a base-type overridable method that has the same signature. 修飾子は、 NotOverridable オーバーライド可能なメソッドをさらにオーバーライドできないことを示します。The NotOverridable modifier indicates that an overridable method cannot be further overridden. 修飾子は、 MustOverride 派生クラスでメソッドをオーバーライドする必要があることを示します。The MustOverride modifier indicates that a method must be overridden in derived classes.
これらの修飾子の特定の組み合わせは無効です。Certain combinations of these modifiers are not valid:
Overridable と NotOverridable は相互に排他的であり、組み合わせることはできません。Overridable and NotOverridable are mutually exclusive and cannot be combined.
MustOverride はを暗黙的 Overridable に指定できないため、と組み合わせることはできません NotOverridable 。MustOverride implies Overridable (and so cannot specify it) and cannot be combined with NotOverridable.
NotOverridable はまたはと組み合わせることはできません Overridable MustOverride 。また、と組み合わせる必要があり Overrides ます。NotOverridable cannot be combined with Overridable or MustOverride and must be combined with Overrides.
Overrides はを暗黙的 Overridable に指定できないため、と組み合わせることはできません MustOverride 。Overrides implies Overridable (and so cannot specify it) and cannot be combined with MustOverride.
また、オーバーライド可能なメソッドにも追加の制限があります。There are also additional restrictions on overridable methods:
メソッドに MustOverride メソッド本体またはコンストラクトを含めることはできません。別のメソッドをオーバーライドすることはできませ End ん。また、クラスにのみ出現する可能性があり MustInherit ます。A MustOverride method may not include a method body or an End construct, may not override another method, and may only appear in MustInherit classes.
メソッドでが指定 Overrides されていて、オーバーライドする一致する基本メソッドが存在しない場合、コンパイル時エラーが発生します。If a method specifies Overrides and there is no matching base method to override, a compile-time error occurs. オーバーライドするメソッドでを指定することはできません Shadows 。An overriding method may not specify Shadows.




    

オーバーライドするメソッドのアクセシビリティドメインがオーバーライドされるメソッドのアクセシビリティドメインと等しくない場合、メソッドは別のメソッドをオーバーライドすることはできません。A method may not override another method if the overriding method's accessibility domain is not equal to the accessibility domain of the method being overridden. 1つの例外として、アクセス権のない別のアセンブリのメソッドをオーバーライドするメソッドでは、 Protected Friend Friend (ではなく) を指定する必要があり Protected Protected Friend ます。The one exception is that a method overriding a Protected Friend method in another assembly that does not have Friend access must specify Protected (not Protected Friend).
Private メソッドは、、 Overridable 、またはではなく、 NotOverridable 他のメソッドをオーバーライドすることもできません MustOverride 。Private methods may not be Overridable, NotOverridable, or MustOverride, nor may they override other methods.
クラスのメソッド NotInheritable が Overridable またはとして宣言されていない可能性があり MustOverride ます。Methods in NotInheritable classes may not be declared Overridable or MustOverride.
次の例は、overridable メソッドと overridable 以外のメソッドの違いを示しています。The following example illustrates the differences between overridable and nonoverridable methods:
Class Base
    Public Sub F()
        Console.WriteLine("Base.F")
    End Sub
    Public Overridable Sub G()
        Console.WriteLine("Base.G")
    End Sub
End Class
Class Derived
    Inherits Base
    Public Shadows Sub F()
        Console.WriteLine("Derived.F")
    End Sub
    Public Overrides Sub G()
        Console.WriteLine("Derived.G")
    End Sub
End Class
Module Test
    Sub Main()
        Dim d As Derived = New Derived()
        Dim b As Base = d
        b.F()
        d.F()
        b.G()
        d.G()
    End Sub
End Module
この例では、クラスに Base メソッド F とメソッドが導入されて Overridable G います。In the example, class Base introduces a method F and an Overridable method G. クラスでは、 Derived 継承されたをシャドウする新しいメソッドが導入され、継承された F F メソッドもオーバーライドされ G ます。The class Derived introduces a new method F, thus shadowing the inherited F, and also overrides the inherited method G. この例では次の出力が生成されます。The example produces the following output:
Base.F
Derived.F
Derived.G
Derived.G
ではなく、ステートメントが呼び出されることに注意して b.G() Derived.G Base.G ください。Notice that the statement b.G() invokes Derived.G, not Base.G. これは、インスタンスのコンパイル時の型 () ではなく、インスタンスのランタイム型 () が、 Derived Base 呼び出す実際のメソッドの実装を決定するためです。This is because the run-time type of the instance (which is Derived) rather than the compile-time type of the instance (which is Base) determines the actual method implementation to invoke.
共有メソッドShared Methods
修飾子は、 Shared メソッドが 共有メソッド であることを示します。The Shared modifier indicates a method is a shared method. 共有メソッドは、型の特定のインスタンスでは動作せず、型の特定のインスタンスを使用するのではなく、型から直接呼び出すことができます。A shared method does not operate on a specific instance of a type and may be invoked directly from a type rather than through a particular instance of a type. ただし、インスタンスを使用して共有メソッドを修飾することは有効です。It is valid, however, to use an instance to qualify a shared method. Me MyClass 共有メソッドで、、またはを参照することはできません MyBase 。It is invalid to refer to Me, MyClass, or MyBase in a shared method. 共有メソッドを、、またはにすることはできません Overridable NotOverridable 。また、 MustOverride メソッドをオーバーライドすることもできません。Shared methods may not be Overridable, NotOverridable, or MustOverride, and they may not override methods. 標準モジュールおよびインターフェイスで定義されているメソッドは Shared 、暗黙的に存在するため、を指定することはできません Shared 。Methods defined in standard modules and interfaces may not specify Shared, because they are implicitly Shared already.
修飾子のない構造体またはクラスで宣言 Shared されたメソッドは、 インスタンスメソッド です。A method declared in a structure or class without a Shared modifier is an instance method. インスタンスメソッドは、型の特定のインスタンスに対して動作します。An instance method operates on a given instance of a type. インスタンスメソッドは、型のインスタンスを介してのみ呼び出すことができ、式を使用してインスタンスを参照でき Me ます。Instance methods can only be invoked through an instance of a type and may refer to the instance through the Me expression.
次の例は、共有メンバーとインスタンスメンバーにアクセスするための規則を示しています。The following example illustrates the rules for accessing shared and instance members:
Class Test
    Private x As Integer
    Private Shared y As Integer
    Sub F()
        x = 1 ' Ok, same as Me.x = 1.
        y = 1 ' Ok, same as Test.y = 1.
    End Sub
    Shared Sub G()
        x = 1 ' Error, cannot access Me.x.
        y = 1 ' Ok, same as Test.y = 1.
    End Sub
    Shared Sub Main()
        Dim t As Test = New Test()
        t.x = 1 ' Ok.
        t.y = 1 ' Ok.
        Test.x = 1 ' Error, cannot access instance member through type.
        Test.y = 1 ' Ok.
    End Sub
End Class
メソッドは F 、インスタンス関数メンバーで識別子を使用して、インスタンスメンバーと共有メンバーの両方にアクセスできることを示しています。Method F shows that in an instance function member, an identifier can be used to access both instance members and shared members. メソッドは G 、共有関数メンバーで、識別子を使用してインスタンスメンバーにアクセスする際のエラーであることを示しています。Method G shows that in a shared function member, it is an error to access an instance member through an identifier. メソッドは、 Main メンバーアクセス式で、インスタンスメンバーがインスタンスを介してアクセスする必要があることを示します。ただし、共有メンバーは、型またはインスタンスを使用してアクセスできます。Method Main shows that in a member access expression, instance members must be accessed through instances, but shared members can be accessed through types or instances.
メソッドのパラメーターMethod Parameters
パラメーター は、メソッドとの間で情報を渡すために使用できる変数です。A parameter is a variable that can be used to pass information into and out of a method. メソッドのパラメーターは、メソッドのパラメーターリストによって宣言されます。これは、コンマで区切られた1つ以上のパラメーターで構成されます。Parameters of a method are declared by the method's parameter list, which consists of one or more parameters separated by commas.
ParameterList
    : Parameter ( Comma Parameter )*
Parameter
    : Attributes? ParameterModifier* ParameterIdentifier ( 'As' TypeName )?
      ( Equals ConstantExpression )?
ParameterModifier
    : 'ByVal' | 'ByRef' | 'Optional' | 'ParamArray'
ParameterIdentifier
    : Identifier IdentifierModifiers
パラメーターに型が指定されておらず、厳密なセマンティクスが使用されている場合は、コンパイル時エラーが発生します。If no type is specified for a parameter and strict semantics are used, a compile-time error occurs. それ以外の場合、既定の型は Object またはパラメーターの型文字の型になります。Otherwise the default type is Object or the type of the parameter's type character. 寛容なセマンティクスでも、1つのパラメーターに句が含まれている場合 As 、すべてのパラメーターで型を指定する必要があります。Even under permissive semantics, if one parameter includes an As clause, all parameters must specify types.
パラメーターは、値、参照、オプション、または paramarray パラメーターとして、それぞれ修飾子、、、およびで指定し ByVal ByRef Optional ParamArray ます。Parameters are specified as value, reference, optional, or paramarray parameters by the modifiers ByVal, ByRef, Optional, and ParamArray, respectively. を指定しないか、 ByRef ByVal 既定値を持つパラメーター ByVal 。A parameter that does not specify ByRef or ByVal defaults to ByVal.
パラメーター名は、メソッドの本体全体にスコープが設定され、常にパブリックにアクセスできます。Parameter names are scoped to the entire body of the method and are always publicly accessible. メソッドの呼び出しでは、その呼び出しに固有のコピーがパラメーターによって作成され、呼び出しの引数リストによって、新しく作成されたパラメーターに値または変数参照が割り当てられます。A method invocation creates a copy, specific to that invocation, of the parameters, and the argument list of the invocation assigns values or variable references to the newly created parameters. 外部メソッドの宣言とデリゲート宣言には本体がないため、パラメーターリストで重複するパラメーター名を使用できますが、これは推奨されません。Because external method declarations and delegate declarations have no body, duplicate parameter names are allowed in parameter lists, but discouraged.
識別子の後に null 許容の名前修飾子を指定して、 ? null 値が許容されることを示すことができます。また、配列が配列であることを示すために、配列の名前修飾子を指定することもできます。The identifier may be followed by the nullable name modifier ? to indicate that it is nullable, and also by array name modifiers to indicate that it is an array. たとえば、"" を組み合わせることができます ByVal x?() As Integer 。They may be combined, e.g. "ByVal x?() As Integer". 明示的な配列の境界を使用することはできません。また、nullable name 修飾子が存在する場合は、 As 句が存在する必要があります。It is not allowed to use explicit array bounds; also, if the nullable name modifier is present then an As clause must be present.
値パラメーターValue Parameters
値パラメーター は、明示的な修飾子を使用して宣言されて ByVal います。A value parameter is declared with an explicit ByVal modifier. 修飾子が使用されている場合、 ByVal ByRef 修飾子を指定することはできません。If the ByVal modifier is used, the ByRef modifier may not be specified. 値パラメーターは、パラメーターが属しているメンバーの呼び出しと共に存在し、呼び出しで指定された引数の値で初期化されます。A value parameter comes into existence with the invocation of the member the parameter belongs to, and is initialized with the value of the argument given in the invocation. 値パラメーターは、メンバーが返されたときに存在しなくなります。A value parameter ceases to exist upon return of the member.
メソッドは、値パラメーターに新しい値を割り当てることができます。A method is permitted to assign new values to a value parameter. このような割り当ては、値パラメーターによって表されるローカルストレージの場所にのみ影響します。メソッドの呼び出しで指定された実際の引数には影響しません。Such assignments only affect the local storage location represented by the value parameter; they have no effect on the actual argument given in the method invocation.
値パラメーターは、引数の値がメソッドに渡されるときに使用されます。パラメーターを変更しても、元の引数には影響しません。A value parameter is used when the value of an argument is passed into a method, and modifications of the parameter do not impact the original argument. 値パラメーターは、対応する引数の変数とは別の変数である、独自の変数を参照します。A value parameter refers to its own variable, one that is distinct from the variable of the corresponding argument. この変数は、対応する引数の値をコピーすることによって初期化されます。This variable is initialized by copying the value of the corresponding argument. 次の例は、 F という名前の値パラメーターを持つメソッドを示してい p ます。The following example shows a method F that has a value parameter named p:
Module Test
    Sub F(p As Integer)
        Console.WriteLine("p = " & p)
        p += 1
    End Sub 
    Sub Main()
        Dim a As Integer = 1
        Console.WriteLine("pre: a = " & a)
        Console.WriteLine("post: a = " & a)
    End Sub
End Module
この例では、value パラメーターが変更された場合でも、次の出力が生成 p されます。The example produces the following output, even though the value parameter p is modified:
pre: a = 1
p = 1
post: a = 1
参照パラメーターReference Parameters
参照パラメーターは、修飾子を使用して宣言されたパラメーターです ByRef 。A reference parameter is a parameter declared with a ByRef modifier. 修飾子が指定されている場合、 ByRef ByVal 修飾子は使用できません。If the ByRef modifier is specified, the ByVal modifier may not be used. 参照パラメーターでは、新しいストレージの場所は作成されません。A reference parameter does not create a new storage location. 代わりに、参照パラメーターは、メソッドまたはコンストラクターの呼び出しで引数として指定された変数を表します。Instead, a reference parameter represents the variable given as the argument in the method or constructor invocation. 概念的には、参照パラメーターの値は、基になる変数と常に同じです。Conceptually, the value of a reference parameter is always the same as the underlying variable.
参照パラメーターは、エイリアス として、または コピーインコピーバック を使用して、2つのモードで動作します。Reference parameters act in two modes, either as aliases or through copy-in copy-back.
エイリアス.Aliases. 参照パラメーターは、パラメーターが、呼び出し元が指定した引数のエイリアスとして機能する場合に使用されます。A reference parameter is used when the parameter acts as an alias for a caller-provided argument. 参照パラメーターは、それ自体は変数を定義するのではなく、対応する引数の変数を参照します。A reference parameter does not itself define a variable, but rather refers to the variable of the corresponding argument. 参照パラメーターを直接変更し、対応する引数に直ちに影響を与えます。Modifications of a reference parameter directly and immediately impact the corresponding argument. 次の例は、 Swap 2 つの参照パラメーターを持つメソッドを示しています。The following example shows a method Swap that has two reference parameters:




    

Module Test
    Sub Swap(ByRef a As Integer, ByRef b As Integer)
        Dim t As Integer = a
        a = b
        b = t
    End Sub 
    Sub Main()
        Dim x As Integer = 1
        Dim y As Integer = 2
        Console.WriteLine("pre: x = " & x & ", y = " & y)
        Swap(x, y)
        Console.WriteLine("post: x = " & x & ", y = " & y)
    End Sub 
End Module
プログラムの出力は次のようになります。The output of the program is:
pre: x = 1, y = 2
post: x = 2, y = 1
クラスのメソッドの呼び出しでは Swap Main 、はを表し、を a x, b 表し y ます。For the invocation of method Swap in class Main, a represents x, and b represents y. したがって、呼び出しはとの値を交換した場合の効果があり x y ます。Thus, the invocation has the effect of swapping the values of x and y.
参照パラメーターを受け取るメソッドでは、複数の名前が同じストレージの場所を表すことができます。In a method that takes reference parameters, it is possible for multiple names to represent the same storage location:
Module Test
    Private s As String
    Sub F(ByRef a As String, ByRef b As String)
        s = "One"
        a = "Two"
        b = "Three"
    End Sub
    Sub G()
        F(s, s)
    End Sub
End Module
この例では、でメソッドを呼び出す F G と、 s との両方のへの参照が渡され a b ます。In the example the invocation of method F in G passes a reference to s for both a and b. そのため、この呼び出しでは、 s 、 a 、およびは b すべて同じストレージの場所を参照し、3つの代入はすべてインスタンス変数を変更し s ます。Thus, for that invocation, the names s, a, and b all refer to the same storage location, and the three assignments all modify the instance variable s.
コピーインコピーバック。Copy-in copy-back. 参照パラメーターに渡される変数の型が参照パラメーターの型と互換性がない場合、または変数 (プロパティなど) が参照パラメーターに引数として渡されない場合、または呼び出しが遅延バインディングされる場合は、一時変数が割り当てられ、参照パラメーターに渡されます。If the type of the variable being passed to a reference parameter is not compatible with the reference parameter's type, or if a non-variable (e.g. a property) is passed as an argument to a reference parameter, or if the invocation is late-bound, then a temporary variable is allocated and passed to the reference parameter. 渡された値は、メソッドが呼び出される前にこの一時変数にコピーされ、メソッドから制御が戻ったときに、元の変数 (存在する場合は、書き込み可能な場合) にコピーされます。The value being passed in will be copied into this temporary variable before the method is invoked and will be copied back to the original variable (if there is one and if it's writable) when the method returns. このため、参照パラメーターには、渡される変数の正確な格納場所への参照が含まれるとは限りません。また、メソッドが終了するまで、参照パラメーターに対する変更は変数に反映されない可能性があります。Thus, a reference parameter may not necessarily contain a reference to the exact storage of the variable being passed in, and any changes to the reference parameter may not be reflected in the variable until the method exits. 次に例を示します。For example:
Class Base
End Class
Class Derived
    Inherits Base
End Class
Module Test
    Sub F(ByRef b As Base)
        b = New Base()
    End Sub
    Property G() As Base
        End Get
        End Set
    End Property
    Sub Main()
        Dim d As Derived
        F(G)   ' OK.
        F(d)   ' Throws System.InvalidCastException after F returns.
    End Sub
End Module
の最初の呼び出しの場合、 F 一時変数が作成され、プロパティの値 G が割り当てられ、に渡され F ます。In the case of the first invocation of F, a temporary variable is created and the value of the property G is assigned to it and passed into F. から戻った時点 F で、一時変数の値がのプロパティに割り当てられ G ます。Upon return from F, the value in the temporary variable is assigned back to the property of G. 2番目のケースでは、別の一時変数が作成され、の値 d が割り当てられ、に渡され F ます。In the second case, another temporary variable is created and the value of d is assigned to it and passed into F. から制御が戻ると F 、一時変数の値が変数の型にキャストされ、が Derived に割り当てられ d ます。When returning from F, the value in the temporary variable is cast back to the type of the variable, Derived, and assigned to d. 返される値はにキャストできないため Derived 、実行時に例外がスローされます。Since the value being passed back cannot be cast to Derived, an exception is thrown at run time.
省略可能のパラメーターOptional Parameters
省略可能なパラメーターは、修飾子を使用して宣言 Optional します。An optional parameter is declared with the Optional modifier. 仮パラメーターリスト内の省略可能なパラメーターの後に続くパラメーターは、省略可能である必要があります。次のパラメーターに修飾子を指定しない Optional と、コンパイル時エラーが発生します。Parameters that follow an optional parameter in the formal parameter list must be optional as well; failure to specify the Optional modifier on the following parameters will trigger a compile-time error. Null 値が許容される型または null 非許容型の省略可能なパラメーターには、 T? T e 引数が指定されていない場合に既定値として使用される定数式を指定する必要があります。An optional parameter of some type nullable type T? or non-nullable type T must specify a constant expression e to be used as a default value if no argument is specified. が Object 型に評価される場合、パラメーターの e Nothing 型 の既定値がパラメーターの既定値として使用されます。If e evaluates to Nothing of type Object, then the default value of the parameter type will be used as the default for the parameter. それ以外の場合、は CType(e, T) 定数式である必要があり、パラメーターの既定値として取得されます。Otherwise, CType(e, T) must be a constant expression and it is taken as the default for the parameter.
パラメーターの初期化子が有効である唯一の状況は、省略可能なパラメーターです。Optional parameters are the only situation in which an initializer on a parameter is valid. 初期化は常に、メソッド本体内ではなく、呼び出し式の一部として実行されます。The initialization is always done as a part of the invocation expression, not within the method body itself.
Module Test
    Sub F(x As Integer, Optional y As Integer = 20)
        Console.WriteLine("x = " & x & ", y = " & y)
    End Sub
    Sub Main()
        F(10)
        F(30,40)
    End Sub
End Module
プログラムの出力は次のようになります。The output of the program is:
x = 10, y = 20
x = 30, y = 40
省略可能なパラメーターは、デリゲートまたはイベント宣言では指定できません。また、ラムダ式でも指定できません。Optional parameters may not be specified in delegate or event declarations, nor in lambda expressions.
ParamArray パラメーターParamArray Parameters
ParamArray パラメーターは修飾子を使用して宣言され ParamArray ます。ParamArray parameters are declared with the ParamArray modifier. 修飾子が存在する場合は、 ParamArray ByVal 修飾子を指定する必要があり、他のパラメーターで修飾子を使用することはできません ParamArray 。If the ParamArray modifier is present, the ByVal modifier must be specified, and no other parameter may use the ParamArray modifier. ParamArrayパラメーターの型は1次元配列でなければなりません。また、パラメーターリストの最後のパラメーターである必要があります。The ParamArray parameter's type must be a one-dimensional array, and it must be the last parameter in the parameter list.
ParamArrayパラメーターは、の型の不特定数のパラメーターを表し ParamArray ます。A ParamArray parameter represents an indeterminate number of parameters of the type of the ParamArray. メソッド自体で ParamArray は、パラメーターは宣言された型として扱われ、特別なセマンティクスはありません。Within the method itself, a ParamArray parameter is treated as its declared type and has no special semantics. ParamArrayパラメーターは暗黙的に省略可能であり、既定値はの型の空の1次元配列です ParamArray 。A ParamArray parameter is implicitly optional, with a default value of an empty one-dimensional array of the type of the ParamArray.
では、 ParamArray メソッド呼び出しの2つの方法のいずれかで引数を指定できます。A ParamArray permits arguments to be specified in one of two ways in a method invocation:
に指定された引数は、 ParamArray 型に拡大変換される型の1つの式にすることができ ParamArray ます。The argument given for a ParamArray can be a single expression of a type that widens to the ParamArray type. この場合、は、 ParamArray 値パラメーターとまったく同様に動作します。In this case, the ParamArray acts precisely like a value parameter.
また、の呼び出しでは、に0個以上の引数を指定できます ParamArray 。各引数は、の要素型に暗黙的に変換できる型の式です ParamArray 。Alternatively, the invocation can specify zero or more arguments for the ParamArray, where each argument is an expression of a type that is implicitly convertible to the element type of the ParamArray. この場合、呼び出しは、 ParamArray 引数の数に対応する長さの型のインスタンスを作成し、指定された引数値を使用して配列インスタンスの要素を初期化し、新しく作成された配列インスタンスを実引数として使用します。In this case, the invocation creates an instance of the ParamArray type with a length corresponding to the number of arguments, initializes the elements of the array instance with the given argument values, and uses the newly created array instance as the actual argument.
呼び出しで可変個の引数を許可する場合を除き、は、 ParamArray 次の例に示すように、同じ型の値パラメーターと厳密に等価です。Except for allowing a variable number of arguments in an invocation, a ParamArray is precisely equivalent to a value parameter of the same type, as the following example illustrates.
Module Test
    Sub F(ParamArray args() As Integer)
        Dim i As Integer
        Console.Write("Array contains " & args.Length & " elements:")
        For Each i In args
            Console.Write(" " & i)
        Next i
        Console.WriteLine()
    End Sub
    Sub Main()
        Dim a As Integer() = { 1, 2, 3 }
        F(10, 20, 30, 40)
    End Sub
End Module
この例では、出力が生成されます。The example produces the output
Array contains 3 elements: 1 2 3
Array contains 4 elements: 10 20 30 40
Array contains 0 elements:
の最初の呼び出しでは、 F 単に配列を a 値パラメーターとして渡します。The first invocation of F simply passes the array a as a value parameter. の2番目の呼び出しは、 F 指定された要素の値を持つ4要素の配列を自動的に作成し、その配列インスタンスを値パラメーターとして渡します。The second invocation of F automatically creates a four-element array with the given element values and passes that array instance as a value parameter. 同様に、の3番目の呼び出しでは、 F ゼロ要素の配列を作成し、そのインスタンスを値パラメーターとして渡します。Likewise, the third invocation of F creates a zero-element array and passes that instance as a value parameter. 2番目と3番目の呼び出しは、書き込みとまったく同じです。The second and third invocations are precisely equivalent to writing:
F(New Integer() {10, 20, 30, 40})
F(New Integer() {})
ParamArray デリゲートまたはイベント宣言でパラメーターを指定することはできません。ParamArray parameters may not be specified in delegate or event declarations.
イベント処理Event Handling
メソッドは、インスタンスまたは共有変数のオブジェクトによって生成されたイベントを宣言によって処理できます。Methods can declaratively handle events raised by objects in instance or shared variables. イベントを処理するには、メソッドの宣言でキーワードを指定し、 Handles 1 つまたは複数のイベントを一覧表示します。To handle events, a method declaration specifies the Handles keyword and lists one or more events.
HandlesClause
    : ( 'Handles' EventHandlesList )?
EventHandlesList
    : EventMemberSpecifier ( Comma EventMemberSpecifier )*
EventMemberSpecifier
    : Identifier Period IdentifierOrKeyword
    | 'MyBase' Period IdentifierOrKeyword
    | 'MyClass' Period IdentifierOrKeyword
    | 'Me' Period IdentifierOrKeyword
リスト内のイベント Handles は、ピリオドで区切られた2つの識別子によって指定されます。An event in the Handles list is specified by two identifiers separated by a period:
最初の識別子は、修飾子、またはまたはまたはキーワードを指定する、含んでいる型のインスタンスまたは共有変数である必要があります WithEvents MyBase MyClass Me 。それ以外の場合、コンパイル時エラーが発生します。The first identifier must be an instance or shared variable in the containing type that specifies the WithEvents modifier or the MyBase or MyClass or Me keyword; otherwise, a compile-time error occurs. この変数には、このメソッドによって処理されるイベントを発生させるオブジェクトが格納されます。This variable contains the object that will raise the events handled by this method.




    

2番目の識別子では、最初の識別子の型のメンバーを指定する必要があります。The second identifier must specify a member of the type of the first identifier. メンバーはイベントである必要があり、共有されている可能性があります。The member must be an event, and may be shared. 最初の識別子に共有変数が指定されている場合は、イベントを共有するか、エラーの結果を生成する必要があります。If a shared variable is specified for the first identifier, then the event must be shared, or an error results.
ハンドラーメソッド M は、ステートメントが有効である場合にも、イベントの有効なイベントハンドラーと見なされ E AddHandler E, AddressOf M ます。A handler method M is considered a valid event handler for an event E if the statement AddHandler E, AddressOf M would also be valid. ただし、ステートメントとは異なり AddHandler 、明示的なイベントハンドラーを使用すると、厳密なセマンティクスが使用されているかどうかに関係なく、引数のないメソッドでイベントを処理できます。Unlike an AddHandler statement, however, explicit event handlers allow handling an event with a method with no arguments regardless of whether strict semantics are being used or not:
Option Strict On
Class C1
    Event E(x As Integer)
End Class
Class C2
    withEvents C1 As New C1()
    ' Valid
    Sub M1() Handles C1.E
    End Sub
    Sub M2()
        ' Invalid
        AddHandler C1.E, AddressOf M1
    End Sub
End Class
1つのメンバーが複数の一致するイベントを処理でき、複数のメソッドが1つのイベントを処理する場合があります。A single member can handle multiple matching events, and multiple methods may handle a single event. メソッドのアクセシビリティは、イベントを処理する機能には影響しません。A method's accessibility has no effect on its ability to handle events. 次の例は、メソッドがイベントを処理する方法を示しています。The following example shows how a method can handle events:
Class Raiser
    Event E1()
    Sub Raise()
        RaiseEvent E1
    End Sub
End Class
Module Test
    WithEvents x As Raiser
    Sub E1Handler() Handles x.E1
        Console.WriteLine("Raised")
    End Sub
    Sub Main()
        x = New Raiser()
        x.Raise()
        x.Raise()
    End Sub
End Module
次のように出力されます。This will print out:
Raised
Raised
型は、その基本型によって提供されるすべてのイベントハンドラーを継承します。A type inherits all event handlers provided by its base type. 派生型は、その基本型から継承するイベントマッピングを変更することはできませんが、イベントにハンドラーを追加することができます。A derived type cannot in any way alter the event mappings it inherits from its base types, but may add additional handlers to the event.
拡張メソッドExtension Methods
メソッドは、 拡張メソッド を使用して、型宣言の外部から型に追加できます。Methods can be added to types from outside of the type declaration using extension methods. 拡張メソッドは、属性が適用されたメソッドです System.Runtime.CompilerServices.ExtensionAttribute 。Extension methods are methods with the System.Runtime.CompilerServices.ExtensionAttribute attribute applied to them. これらは標準モジュールでのみ宣言でき、メソッドが拡張する型を指定するパラメーターが少なくとも1つ必要です。They can only be declared in standard modules and must have at least one parameter, which specifies the type the method extends. たとえば、次の拡張メソッドは型を拡張し String ます。For example, the following extension method extends the type String:
Imports System.Runtime.CompilerServices
Module StringExtensions
    <Extension> _
    Sub Print(s As String)
        Console.WriteLine(s)
    End Sub
End Module
注意。Note. Visual Basic では、拡張メソッドを標準モジュール内で宣言する必要がありますが、C# などの他の言語では、他の種類の型で宣言することが許可される場合があります。Although Visual Basic requires extension methods to be declared in a standard module, other languages such as C# may allow them to be declared in other kinds of types. ここに記載されている他の規則に従っている限り、含まれている型がオープンジェネリック型ではなく、インスタンス化できない場合、Visual Basic は拡張メソッドを認識します。As long as the methods follow the other conventions outlined here and the containing type is not an open generic type and cannot be instantiated, Visual Basic will recognize the extension methods.
拡張メソッドが呼び出されると、呼び出し先のインスタンスが最初のパラメーターに渡されます。When an extension method is invoked, the instance it is being invoked on is passed to the first parameter. 最初のパラメーターを Optional またはとして宣言することはできません ParamArray 。The first parameter cannot be declared Optional or ParamArray. 型パラメーターを含む任意の型は、拡張メソッドの最初のパラメーターとして表示できます。Any type, including a type parameter, can appear as the first parameter of an extension method. たとえば、次のメソッドは、型、 Integer() を実装する型、 System.Collections.Generic.IEnumerable(Of T) およびすべての型を拡張します。For example, the following methods extend the types Integer(), any type that implements System.Collections.Generic.IEnumerable(Of T), and any type at all:
Imports System.Runtime.CompilerServices
Module Extensions
    <Extension> _
    Sub PrintArray(a() As Integer)
    End Sub
    <Extension> _
    Sub PrintList(Of T)(a As IEnumerable(Of T))
    End Sub
    <Extension> _
    Sub Print(Of T)(a As T)
    End Sub
End Module
前の例で示したように、インターフェイスは拡張できます。As the previous example shows, interfaces can be extended. インターフェイス拡張メソッドは、メソッドの実装を提供します。したがって、拡張メソッドが定義されているインターフェイスを実装する型は、インターフェイスによって最初に宣言されたメンバーのみを実装します。Interface extension methods supply the implementation of the method, so types that implement an interface that has extension methods defined on it still only implement the members originally declared by the interface. 次に例を示します。For example:
Imports System.Runtime.CompilerServices
Interface IAction
  Sub DoAction()
End Interface
Module IActionExtensions 
    <Extension> _
    Public Sub DoAnotherAction(i As IAction) 
        i.DoAction()
    End Sub
End Module
Class C
  Implements IAction
  Sub DoAction() Implements IAction.DoAction
  End Sub
  ' ERROR: Cannot implement extension method IAction.DoAnotherAction
  Sub DoAnotherAction() Implements IAction.DoAnotherAction
  End Sub
End Class
拡張メソッドは、型パラメーターに対して型制約を持つこともできます。また、非拡張ジェネリックメソッドと同様に、型引数を推論することもできます。Extension methods can also have type constraints on their type parameters and, just as with non-extension generic methods, type argument can be inferred:
Imports System.Runtime.CompilerServices
Module IEnumerableComparableExtensions
    <Extension> _
    Public Function Sort(Of T As IComparable(Of T))(i As IEnumerable(Of T)) _
        As IEnumerable(Of T)
    End Function
End Module
拡張メソッドには、拡張される型内の暗黙的なインスタンス式を使用してアクセスすることもできます。Extension methods can also be accessed through implicit instance expressions within the type being extended:
Imports System.Runtime.CompilerServices
Class C1
    Sub M1()
        Me.M2()
    End Sub
End Class
Module C1Extensions
    <Extension>
    Sub M2(c As C1)
    End Sub
End Module
アクセシビリティのために、拡張メソッドは、宣言されている標準モジュールのメンバーとしても扱われます。これらのメソッドは、宣言コンテキストを使用することによって、拡張されているアクセス権を超える型のメンバーに対する追加のアクセス権を持っていません。For the purposes of accessibility, extension methods are also treated as members of the standard module they are declared in -- they have no extra access to the members of the type they are extending beyond the access they have by virtue of their declaration context.
拡張メソッドは、標準モジュールメソッドがスコープ内にある場合にのみ使用できます。Extensions methods are only available when the standard module method is in scope. そうしないと、元の型は拡張されていないように見えます。Otherwise, the original type will not appear to have been extended. 次に例を示します。For example:
Imports System.Runtime.CompilerServices
Class C1
End Class
Namespace N1
    Module C1Extensions
        <Extension> _
        Sub M1(c As C1)
        End Sub
    End Module
End Namespace
Module Test
    Sub Main()
        Dim c As New C1()
        ' Error: c has no member named "M1"
        c.M1()
    End Sub
End Module
型の拡張メソッドだけが使用可能な場合、型を参照しても、コンパイル時エラーが発生します。Referring to a type when only an extension method on the type is available will still produce a compile-time error.
拡張メソッドは、厳密に型指定されたパターンなど、メンバーがバインドされているすべてのコンテキストの型のメンバーであると見なされることに注意して For Each ください。It is important to note that extension methods are considered to be members of the type in all contexts where members are bound, such as the strongly-typed For Each pattern. 次に例を示します。For example:
Imports System.Runtime.CompilerServices
Class C1
End Class
Class C1Enumerator
    ReadOnly Property Current() As C1
        End Get
    End Property
    Function MoveNext() As Boolean
    End Function
End Class
Module C1Extensions
    <Extension> _
    Function GetEnumerator(c As C1) As C1Enumerator
    End Function
End Module
Module Test
    Sub Main()
        Dim c As New C1()
        ' Valid
        For Each o As Object In c
        Next o
    End Sub
End Module
拡張メソッドを参照するデリゲートを作成することもできます。Delegates can also be created that refer to extension methods. したがって、コードは次のようになります。Thus, the code:
Delegate Sub D1()
Module Test
    Sub Main()
        Dim s As String = "Hello, World!"
        Dim d As D1
        d = AddressOf s.Print
    End Sub
End Module
は、次の場合とほぼ同じです。is roughly equivalent to:
Delegate Sub D1()
Module Test
    Sub Main()
      Dim s As String = "Hello, World!"
      Dim d As D1
      d = CType([Delegate].CreateDelegate(GetType(D1), s, _
                GetType(StringExtensions).GetMethod("Print")), D1)
    End Sub
End Module
注意。Note. Visual Basic は、通常、メソッドが呼び出されているインスタンスがの場合にを発生させる、インスタンスメソッドの呼び出しに check を挿入 System.NullReferenceException Nothing します。Visual Basic normally inserts a check on an instance method call that causes a System.NullReferenceException to occur if the instance the method is being invoked on is Nothing. 拡張メソッドの場合は、このチェックを挿入するための効率的な方法がないため、拡張メソッドでを明示的にチェックする必要があり Nothing ます。In the case of extension methods, there is no efficient way to insert this check, so extension methods will need to explicitly check for Nothing.
注意。Note. 値型は、 ByVal インターフェイスとして型指定されたパラメーターに引数として渡されるときにボックス化されます。A value type will be boxed when being passed as a ByVal argument to a parameter typed as an interface.  これは、拡張メソッドの副作用が、元のではなく、構造体のコピーに対して動作することを意味します。This implies that side effects of the extension method will operate on a copy of the structure instead of the original. 言語では、拡張メソッドの最初の引数に制限はありませんが、拡張メソッドを使用して値型を拡張することはできません。また、値型を拡張する場合は、最初のパラメーターが渡されて、 ByRef 元の値に対して副作用が動作するようにすることをお勧めします。While the language puts no restrictions on the first argument of an extension method, it is recommended that extension methods are not used to extend value types or that when extending value types, the first parameter is passed ByRef to ensure that side effects operate on the original value.
部分メソッドPartial Methods
部分メソッド は、メソッドの本体ではなく、シグネチャを指定するメソッドです。A partial method is a method that specifies a signature but not the body of the method. メソッドの本体は、同じ名前およびシグネチャを持つ別のメソッド宣言によって指定できます。この宣言は、通常、型の別の部分宣言に含まれています。The body of the method can be supplied by another method declaration with the same name and signature, most likely in another partial declaration of the type. 次に例を示します。For example:
.vb:a.vb:
' Designer generated code
Public Partial Class MyForm
    Private Partial Sub ValidateControls()
    End Sub
    Public Sub New()
        ' Initialize controls
        ValidateControls()
    End Sub    
End Class
b. vb:b.vb:
Public Partial Class MyForm
    Public Sub ValidateControls()
        ' Validation logic goes here
    End Sub
End Class
この例では、クラスの部分宣言で、 MyForm 実装のない部分メソッドが宣言さ ValidateControls れています。In this example, a partial declaration of the class MyForm declares a partial method ValidateControls with no implementation. ファイルに本文が指定されていない場合でも、部分宣言のコンストラクターは部分メソッドを呼び出します。The constructor in the partial declaration calls the partial method, even though there is no body supplied in the file. のその他の部分宣言は、 MyForm メソッドの実装を提供します。The other partial declaration of MyForm then supplies the implementation of the method.
部分メソッドは、本文が指定されているかどうかに関係なく呼び出すことができます。メソッド本体が指定されていない場合、呼び出しは無視されます。Partial methods can be called regardless of whether a body has been supplied; if no method body is supplied, the call is ignored. 次に例を示します。For example:
Public Class C1
    Private Partial Sub M1()
    End Sub
    Public Sub New()
        ' Since no implementation is supplied, this call will not be made.
    End Sub
End Class
無視される部分メソッド呼び出しに引数として渡されるすべての式は無視され、評価されません。Any expressions that are passed in as arguments to a partial method call that is ignored are ignored also and not evaluated. (注:(Note. つまり、部分メソッドは、2つの部分型に対して定義されている動作を提供する非常に効率的な方法です。部分メソッドは使用されない場合はコストがないためです)。This means that partial methods are a very efficient way of providing behavior that is defined across two partial types, since the partial methods have no cost if they are not used.)




    

部分メソッドの宣言はとして宣言する必要があり、 Private 常に本体にステートメントがないサブルーチンである必要があります。The partial method declaration must be declared as Private and must always be a subroutine with no statements in its body. 部分メソッドは、それ自体がインターフェイスメソッドを実装することはできませんが、その本体を提供するメソッドは使用できます。Partial methods cannot themselves implement interface methods, although the method that supplies their body can.
本文を部分メソッドに渡すことができるのは、1つのメソッドだけです。Only one method can supply a body to a partial method. 部分メソッドに本文を指定するメソッドには、部分メソッドと同じシグネチャ、任意の型パラメーターに対する同じ制約、同じ宣言修飾子、および同じパラメーターと型パラメーター名が必要です。A method supplying a body to a partial method must have the same signature as the partial method, the same constraints on any type parameters, the same declaration modifiers, and the same parameter and type parameter names. 部分メソッドの属性とその本体を提供するメソッドは、メソッドのパラメーターの属性と同様にマージされます。Attributes on the partial method and the method that supplies its body are merged, as are any attributes on the methods' parameters. 同様に、メソッドが処理するイベントの一覧がマージされます。Similarly, the list of events that the methods handle is merged. 次に例を示します。For example:
Class C1
    Event E1()
    Event E2()
    Private Partial Sub S() Handles Me.E1
    End Sub
    ' Handles both E1 and E2
    Private Sub S() Handles Me.E2
    End Sub
End Class
コンストラクターConstructors
コンストラクター は、初期化の制御を可能にする特殊なメソッドです。Constructors are special methods that allow control over initialization. これらは、プログラムが開始した後、または型のインスタンスが作成されたときに実行されます。They are run after the program begins or when an instance of a type is created. 他のメンバーとは異なり、コンストラクターは継承されず、型の宣言空間に名前を導入しません。Unlike other members, constructors are not inherited and do not introduce a name into a type's declaration space. コンストラクターは、オブジェクト作成式または .NET Framework によってのみ呼び出すことができます。直接呼び出すことはできません。Constructors may only be invoked by object-creation expressions or by the .NET Framework; they may never be directly invoked.
注意。Note. コンストラクターには、サブルーチンが持つ行の配置に対して同じ制限があります。Constructors have the same restriction on line placement that subroutines have. 開始ステートメント、終了ステートメント、およびブロックはすべて論理行の先頭に記述する必要があります。The beginning statement, end statement and block must all appear at the beginning of a logical line.
ConstructorMemberDeclaration
    : Attributes? ConstructorModifier* 'Sub' 'New'
      ( OpenParenthesis ParameterList? CloseParenthesis )? LineTerminator
      Block?
      'End' 'Sub' StatementTerminator
ConstructorModifier
    : AccessModifier
    | 'Shared'
インスタンス コンストラクターInstance Constructors
インスタンス コンストラクター は、型のインスタンスを初期化し、インスタンスの作成時に .NET Framework によって実行されます。Instance constructors initialize instances of a type and are run by the .NET Framework when an instance is created. コンストラクターのパラメーターリストは、メソッドのパラメーターリストと同じ規則に従います。The parameter list of a constructor is subject to the same rules as the parameter list of a method. インスタンスコンストラクターがオーバーロードされている可能性があります。Instance constructors may be overloaded.
参照型のすべてのコンストラクターは、別のコンストラクターを呼び出す必要があります。All constructors in reference types must invoke another constructor. 呼び出しが明示的である場合は、コンストラクターのメソッド本体の最初のステートメントである必要があります。If the invocation is explicit, it must be the first statement in the constructor method body. ステートメントでは、型のインスタンスコンストラクターの別のコンストラクターを呼び出すことができます。たとえば、やなどです Me.New(...) MyClass.New(...) 。構造体でない場合は、型の基本型のインスタンスコンストラクターを呼び出すことができます。たとえば、のようになり MyBase.New(...) ます。The statement can either invoke another of the type's instance constructors -- for example, Me.New(...) or MyClass.New(...) -- or if it is not a structure it can invoke an instance constructor of the type's base type -- for example, MyBase.New(...). コンストラクターがそれ自体を呼び出すことはできません。It is invalid for a constructor to invoke itself. コンストラクターが別のコンストラクターの呼び出しを省略した場合、 MyBase.New() は暗黙的にになります。If a constructor omits a call to another constructor, MyBase.New() is implicit. パラメーターなしの基本型コンストラクターがない場合、コンパイル時エラーが発生します。If there is no parameterless base type constructor, a compile-time error occurs. Meは、基底クラスのコンストラクターへの呼び出しの後に構築されるとは見なされないため、コンストラクター呼び出しステートメントのパラメーターは Me 、、 MyClass 、または暗黙的または明示的に参照できません MyBase 。Because Me is not considered to be constructed until after the call to a base class constructor, the parameters to a constructor invocation statement cannot reference Me, MyClass, or MyBase implicitly or explicitly.
コンストラクターの最初のステートメントがの形式である場合 MyBase.New(...) 、コンストラクターは、型で宣言されたインスタンス変数の変数初期化子によって指定された初期化を暗黙的に実行します。When a constructor's first statement is of the form MyBase.New(...), the constructor implicitly performs the initializations specified by the variable initializers of the instance variables declared in the type. これは、直接の基本型コンストラクターを呼び出した直後に実行される代入のシーケンスに対応します。This corresponds to a sequence of assignments that are executed immediately after invoking the direct base type constructor. このような順序を使用すると、インスタンスへのアクセス権を持つステートメントが実行される前に、すべての基本インスタンス変数が変数初期化子によって初期化されます。Such ordering ensures that all base instance variables are initialized by their variable initializers before any statements that have access to the instance are executed. 次に例を示します。For example:
Class A
    Protected x As Integer = 1
End Class
Class B
    Inherits A
    Private y As Integer = x
    Public Sub New()
        Console.WriteLine("x = " & x & ", y = " & y)
    End Sub
End Class
を New B() 使用してのインスタンスを作成すると B 、次の出力が生成されます。When New B() is used to create an instance of B, the following output is produced:
x = 1, y = 1
の値 y は、 1 基本クラスのコンストラクターが呼び出された後に変数初期化子が実行されるためです。The value of y is 1 because the variable initializer is executed after the base class constructor is invoked. 変数初期化子は、型宣言に表示される順序に従って実行されます。Variable initializers are executed in the textual order they appear in the type declaration.
型がコンストラクターのみを宣言する場合、通常は、型 Private から派生する他の型、または型のインスタンスを作成することはできません。唯一の例外は、型の中で入れ子にされた型です。When a type declares only Private constructors, it is not possible in general for other types to derive from the type or create instances of the type; the only exception is types nested within the type. Private コンストラクターは、メンバーだけを含む型でよく使用され Shared ます。Private constructors are commonly used in types that contain only Shared members.
型にインスタンスコンストラクターの宣言が含まれていない場合は、既定のコンストラクターが自動的に指定されます。If a type contains no instance constructor declarations, a default constructor is automatically provided. 既定のコンストラクターは、直接基本型のパラメーターなしのコンストラクターを呼び出すだけです。The default constructor simply invokes the parameterless constructor of the direct base type. 直接の基本型にアクセス可能なパラメーターなしのコンストラクターがない場合、コンパイル時エラーが発生します。If the direct base type does not have an accessible parameterless constructor, a compile-time error occurs. 既定のコンストラクターに対して宣言されたアクセスの種類は、 Public 型がでない限り MustInherit 、既定のコンストラクターは Protected です。The declared access type for the default constructor is Public unless the type is MustInherit, in which case the default constructor is Protected.
注意。Note. 型の既定のコンストラクターの既定のアクセス MustInherit は、 Protected クラスを MustInherit 直接作成できないためです。The default access for a MustInherit type's default constructor is Protected because MustInherit classes cannot be created directly. そのため、既定のコンストラクターを作成するポイントはありません Public 。So there is no point in making the default constructor Public.
次の例では、クラスにコンストラクター宣言が含まれていないため、既定のコンストラクターが用意されています。In the following example a default constructor is provided because the class contains no constructor declarations:
Class Message
    Dim sender As Object
    Dim text As String
End Class
したがって、この例は次のように正確に等価です。Thus, the example is precisely equivalent to the following:
Class Message
    Dim sender As Object
    Dim text As String
    Sub New()
    End Sub
End Class
属性でマークされたデザイナーで生成されたクラスに生成される既定のコンストラクターは、メソッドが存在する場合は、 Microsoft.VisualBasic.CompilerServices.DesignerGeneratedAttribute Sub InitializeComponent() 基本コンストラクターの呼び出しの後に、そのメソッドを呼び出します。Default constructors that are emitted into a designer generated class marked with the attribute Microsoft.VisualBasic.CompilerServices.DesignerGeneratedAttribute will call the method Sub InitializeComponent(), if it exists, after the call to the base constructor. (注:(Note. これにより、WinForms デザイナーによって作成されたファイルなど、デザイナーで生成されたファイルを使用して、デザイナーファイル内のコンストラクターを省略できます。This allows designer generated files, such as those created by the WinForms designer, to omit the constructor in the designer file. これにより、プログラマが選択する場合は、プログラマ自身を指定することができます)。This enables the programmer to specify it themselves, if they so choose.)
共有コンストラクターShared Constructors
共有コンストラクター は、型の共有変数を初期化します。これらは、プログラムの実行開始後、型のメンバーへの参照の前に実行されます。Shared constructors initialize a type's shared variables; they are run after the program begins executing, but before any references to a member of the type. 共有コンストラクターは、修飾子が指定され Shared ている標準モジュール内にない限り、修飾子を指定し Shared ます。A shared constructor specifies the Shared modifier, unless it is in a standard module in which case the Shared modifier is implied.
インスタンスコンストラクターとは異なり、共有コンストラクターは暗黙的なパブリックアクセスを持ち、パラメーターを持たず、他のコンストラクターを呼び出すことができません。Unlike instance constructors, shared constructors have implicit public access, have no parameters, and may not call other constructors. 共有コンストラクターの最初のステートメントの前に、共有コンストラクターは、型で宣言された共有変数の変数初期化子によって指定された初期化を暗黙的に実行します。Before the first statement in a shared constructor, the shared constructor implicitly performs the initializations specified by the variable initializers of the shared variables declared in the type. これは、コンストラクターへの入力時に直ちに実行される割り当てのシーケンスに対応します。This corresponds to a sequence of assignments that are executed immediately upon entry to the constructor. 変数初期化子は、型宣言に表示される順序に従って実行されます。The variable initializers are executed in the textual order they appear in the type declaration.
次の例は、共有 Employee 変数を初期化する共有コンストラクターを持つクラスを示しています。The following example shows an Employee class with a shared constructor that initializes a shared variable:
Imports System.Data
Class Employee
    Private Shared ds As DataSet
    Shared Sub New()
        ds = New DataSet()
    End Sub
    Public Name As String
    Public Salary As Decimal
End Class
閉じられたジェネリック型ごとに個別の共有コンストラクターが存在します。A separate shared constructor exists for each closed generic type. 共有コンストラクターは、閉じられた型ごとに1回だけ実行されるので、制約を介してコンパイル時にチェックできない型パラメーターに対して実行時チェックを適用するのに便利な場所です。Because the shared constructor is executed exactly once for each closed type, it is a convenient place to enforce run-time checks on the type parameter that cannot be checked at compile-time via constraints. たとえば、次の型では、共有コンストラクターを使用して、型パラメーターがまたはであることを強制してい Integer Double ます。For example, the following type uses a shared constructor to enforce that the type parameter is Integer or Double:
Class EnumHolder(Of T)
    Shared Sub New() 
        If Not GetType(T).IsEnum() Then
            Throw New ArgumentException("T must be an enumerated type.")
        End If
    End Sub
End Class
共有コンストラクターが実行される場合、厳密には実装に依存しますが、共有コンストラクターが明示的に定義されている場合は、次のような保証が提供されます。Exactly when shared constructors are run is mostly implementation dependent, though several guarantees are provided if a shared constructor is explicitly defined:




    

共有コンストラクターは、型の静的フィールドに最初にアクセスする前に実行されます。Shared constructors are run before the first access to any static field of the type.
共有コンストラクターは、型の静的メソッドの最初の呼び出しの前に実行されます。Shared constructors are run before the first invocation of any static method of the type.
共有コンストラクターは、その型のコンストラクターの最初の呼び出しの前に実行されます。Shared constructors are run before the first invocation of any constructor for the type.
共有コンストラクターが共有初期化子に対して暗黙的に作成される場合、上記の保証は適用されません。The above guarantees do not apply in the situation where a shared constructor is implicitly created for shared initializers. 次の例の出力は、読み込みの正確な順序が定義されていないため、不確定です。The output from the following example is uncertain, because the exact ordering of loading and therefore of shared constructor execution is not defined:
Module Test
    Sub Main()
        A.F()
        B.F()
    End Sub
End Module
Class A
    Shared Sub New()
        Console.WriteLine("Init A")
    End Sub
    Public Shared Sub F()
        Console.WriteLine("A.F")
    End Sub
End Class
Class B
    Shared Sub New()
        Console.WriteLine("Init B")
    End Sub
    Public Shared Sub F()
        Console.WriteLine("B.F")
    End Sub
End Class
出力は、次のいずれかになります。The output could be either of the following:
Init A
Init B
またはor
Init B
Init A
これに対し、次の例では、予測可能な出力が生成されます。By contrast, the following example produces predictable output. クラスから派生したクラス Shared A であっても、クラスのコンストラクターは実行されないことに注意して B ください。Note that the Shared constructor for the class A never executes, even though class B derives from it:
Module Test
    Sub Main()
        B.G()
    End Sub
End Module
Class A
    Shared Sub New()
        Console.WriteLine("Init A")
    End Sub
End Class
Class B
    Inherits A
    Shared Sub New()
        Console.WriteLine("Init B")
    End Sub
    Public Shared Sub G()
        Console.WriteLine("B.G")
    End Sub
End Class
出力は次のようになります。The output is:
Init B
また、 Shared 次の例のように、変数初期化子を持つ変数を既定値の状態で確認できるようにする、循環依存関係を構築することもできます。It is also possible to construct circular dependencies that allow Shared variables with variable initializers to be observed in their default value state, as in the following example:
Class A
    Public Shared X As Integer = B.Y + 1
End Class
Class B
    Public Shared Y As Integer = A.X + 1
    Shared Sub Main()
        Console.WriteLine("X = " & A.X & ", Y = " & B.Y)
    End Sub
End Class
これにより、次の出力が生成されます。This produces the output:
X = 1, Y = 2
メソッドを実行するために、 Main システムは最初にクラスを読み込み B ます。To execute the Main method, the system first loads class B. Sharedクラスのコンストラクターは B 、の初期値を計算し Y ます。これにより、の値が参照されるため、クラスが再帰的 A に読み込まれ A.X ます。The Shared constructor of class B proceeds to compute the initial value of Y, which recursively causes class A to be loaded because the value of A.X is referenced. Sharedクラスのコンストラクターは、 A の初期値の計算を続行 X します。これにより、の 既定 値である Y 0 がフェッチされます。The Shared constructor of class A in turn proceeds to compute the initial value of X, and in doing so fetches the default value of Y, which is zero. A.X そのため、はに初期化され 1 ます。A.X is thus initialized to 1. 次に、読み込みプロセスが A 完了し、の初期値の計算に戻り Y ます。その結果、がになり 2 ます。The process of loading A then completes, returning to the calculation of the initial value of Y, the result of which becomes 2.
メソッドが Main クラスに配置されていたので、この例では A 次の出力が生成されています。Had the Main method instead been located in class A, the example would have produced the following output:
X = 2, Y = 1
変数の初期化子に循環参照を使用しないで Shared ください。通常、このような参照を含むクラスが読み込まれる順序を決定することはできません。Avoid circular references in Shared variable initializers since it is generally impossible to determine the order in which classes containing such references are loaded.
イベントEvents
イベントは、特定のイベントの発生をコードに通知するために使用されます。Events are used to notify code of a particular occurrence. イベント宣言は、デリゲート型またはパラメーターリストである識別子と、オプションの句で構成さ Implements れます。An event declaration consists of an identifier, either a delegate type or a parameter list, and an optional Implements clause.
EventMemberDeclaration
    : RegularEventMemberDeclaration
    | CustomEventMemberDeclaration
RegularEventMemberDeclaration
    : Attributes? EventModifiers* 'Event'
      Identifier ParametersOrType ImplementsClause? StatementTerminator
InterfaceEventMemberDeclaration
    : Attributes? InterfaceEventModifiers* 'Event'
      Identifier ParametersOrType StatementTerminator
ParametersOrType
    : ( OpenParenthesis ParameterList? CloseParenthesis )?
    | 'As' NonArrayTypeName
EventModifiers
    : AccessModifier
    | 'Shadows'
    | 'Shared'
InterfaceEventModifiers
    : 'Shadows'
デリゲート型が指定されている場合、デリゲート型に戻り値の型を指定することはできません。If a delegate type is specified, the delegate type may not have a return type. パラメーターリストが指定されている場合、パラメーター Optional またはパラメーターを含めることはできません ParamArray 。If a parameter list is specified, it may not contain Optional or ParamArray parameters. パラメーターの型やデリゲート型のアクセシビリティドメインは、イベント自体のアクセシビリティドメインのスーパーセットと同じであるか、またはそのいずれかである必要があります。The accessibility domain of the parameter types and/or delegate type must be the same as, or a superset of, the accessibility domain of the event itself. イベントは、修飾子を指定することによって共有でき Shared ます。Events may be shared by specifying the Shared modifier.
型の宣言空間に追加されたメンバー名に加えて、イベント宣言は、他のいくつかのメンバーを暗黙的に宣言します。In addition to the member name added to the type's declaration space, an event declaration implicitly declares several other members. という名前のイベント X を指定すると、次のメンバーが宣言領域に追加されます。Given an event named X, the following members are added to the declaration space:
宣言の形式がメソッド宣言の場合は、という名前の入れ子になったデリゲートクラス XEventHandler が導入されます。If the form of the declaration is a method declaration, a nested delegate class named XEventHandler is introduced. 入れ子になったデリゲートクラスは、メソッド宣言と一致し、イベントと同じアクセシビリティを持ちます。The nested delegate class matches the method declaration and has the same accessibility as the event. パラメーターリストの属性は、delegate クラスのパラメーターに適用されます。The attributes in the parameter list apply to the parameters of the delegate class.
Privateという名前のデリゲートとして型指定されたインスタンス変数 XEvent 。A Private instance variable typed as the delegate, named XEvent.
とという名前の2つのメソッドを add_X remove_X 呼び出し、オーバーライド、またはオーバーロードすることはできません。Two methods named add_X and remove_X which cannot be invoked, overridden or overloaded.
型が上記のいずれかの名前と一致する名前を宣言しようとすると、コンパイル時エラーが発生し、暗黙的な add_X remove_X 宣言と宣言は名前のバインドのために無視されます。If a type attempts to declare a name that matches one of the above names, a compile-time error will result, and the implicit add_X and remove_X declarations are ignored for the purposes of name binding. 導入されたメンバーをオーバーライドまたはオーバーロードすることはできませんが、派生型でシャドウすることはできます。It is not possible to override or overload any of the introduced members, although it is possible to shadow them in derived types. たとえば、クラス宣言はFor example, the class declaration
Class Raiser
    Public Event Constructed(i As Integer)
End Class
は、次の宣言と同じです。is equivalent to the following declaration
Class Raiser
    Public Delegate Sub ConstructedEventHandler(i As Integer)
    Protected ConstructedEvent As ConstructedEventHandler
    Public Sub add_Constructed(d As ConstructedEventHandler)
        ConstructedEvent = _
            CType( _
                [Delegate].Combine(ConstructedEvent, d), _
                    Raiser.ConstructedEventHandler)
    End Sub
    Public Sub remove_Constructed(d As ConstructedEventHandler)
        ConstructedEvent = _
            CType( _
                [Delegate].Remove(ConstructedEvent, d), _
                    Raiser.ConstructedEventHandler)
    End Sub
End Class
デリゲート型を指定せずにイベントを宣言することは、最も単純で最もコンパクトな構文ですが、各イベントに対して新しいデリゲート型を宣言するという欠点があります。Declaring an event without specifying a delegate type is the simplest and most compact syntax, but has the disadvantage of declaring a new delegate type for each event. たとえば、次の例では、3つの非表示のデリゲート型が作成されていますが、3つのイベントすべてに同じパラメーターリストがあります。For example, in the following example, three hidden delegate types are created, even though all three events have the same parameter list:
Public Class Button
    Public Event Click(sender As Object, e As EventArgs)
    Public Event DoubleClick(sender As Object, e As EventArgs)
    Public Event RightClick(sender As Object, e As EventArgs)
End Class
次の例では、イベントは同じデリゲートを使用し EventHandler ます。In the following example, the events simply use the same delegate, EventHandler:
Public Delegate Sub EventHandler(sender As Object, e As EventArgs)
Public Class Button
    Public Event Click As EventHandler
    Public Event DoubleClick As EventHandler
    Public Event RightClick As EventHandler
End Class
イベントは、静的または動的の2つの方法のいずれかで処理できます。Events can be handled in one of two ways: statically or dynamically. イベントを静的に処理するのは簡単で、 WithEvents 変数と句だけが必要です Handles 。Statically handling events is simpler and only requires a WithEvents variable and a Handles clause. 次の例では、クラスが Form1 オブジェクトのイベントを静的に処理し Click Button ます。In the following example, class Form1 statically handles the event Click of object Button:
Public Class Form1
    Public WithEvents Button1 As New Button()
    Public Sub Button1_Click(sender As Object, e As EventArgs) _
           Handles Button1.Click
        Console.WriteLine("Button1 was clicked!")
    End Sub
End Class
イベントは、明示的に接続してコード内に接続解除する必要があるため、動的にイベントを処理することはより複雑になります。Dynamically handling events is more complex because the event must be explicitly connected and disconnected to in code. ステートメントによって AddHandler イベントのハンドラーが追加され、ステートメントによって RemoveHandler イベントのハンドラーが削除されます。The statement AddHandler adds a handler for an event, and the statement RemoveHandler removes a handler for an event. 次の例は、 Form1 Button1_Click のイベントのイベントハンドラーとしてを追加するクラスを示してい Button1 Click ます。The next example shows a class Form1 that adds Button1_Click as an event handler for Button1's Click event:
Public Class Form1
    Public Sub New()
        ' Add Button1_Click as an event handler for Button1's Click event.
        AddHandler Button1.Click, AddressOf Button1_Click
    End Sub 
    Private Button1 As Button = New Button()
    Sub Button1_Click(sender As Object, e As EventArgs)
        Console.WriteLine("Button1 was clicked!")
    End Sub
    Public Sub Disconnect()
        RemoveHandler Button1.Click, AddressOf Button1_Click
    End Sub 
End Class
メソッドで Disconnect は、イベントハンドラーが削除されます。In method Disconnect, the event handler is removed.
[カスタム イベント]Custom Events
前のセクションで説明したように、イベント宣言では、 add_ remove_ イベントハンドラーを追跡するために使用されるフィールド、メソッド、およびメソッドを暗黙的に定義します。As discussed in the previous section, event declarations implicitly define a field, an add_ method, and a remove_ method that are used to keep track of event handlers. ただし、状況によっては、イベントハンドラーを追跡するためのカスタムコードを提供することが望ましい場合があります。In some situations, however, it may be desirable to provide custom code for tracking event handlers. たとえば、クラスが、少数の処理のみを実行する40イベントを定義する場合、各イベントのハンドラーを追跡するために、40フィールドではなくハッシュテーブルを使用する方が効率的な場合があります。For example, if a class defines forty events of which only a few will ever be handled, using a hash table instead of forty fields to track the handlers for each event may be more efficient. カスタムイベント を使用する add_X と、および remove_X メソッドを明示的に定義できます。これにより、イベントハンドラーのカスタムストレージが有効になります。Custom events allow the add_X and remove_X methods to be defined explicitly, which enables custom storage for event handlers.




    

カスタムイベントは、デリゲート型を指定するイベントを宣言するのと同じ方法で宣言されます。ただし、キーワードは Custom キーワードの前に記述する必要があり Event ます。Custom events are declared in the same way that events that specify a delegate type are declared, with the exception that the keyword Custom must precede the Event keyword. カスタムイベント宣言には、 AddHandler 宣言、宣言、 RemoveHandler および RaiseEvent 宣言という3つの宣言が含まれています。A custom event declaration contains three declarations: an AddHandler declaration, a RemoveHandler declaration and a RaiseEvent declaration. どの宣言も修飾子を持つことはできませんが、属性を持つことはできます。None of the declarations can have any modifiers, although they can have attributes.
CustomEventMemberDeclaration
    : Attributes? EventModifiers* 'Custom' 'Event'
      Identifier 'As' TypeName ImplementsClause? StatementTerminator
      EventAccessorDeclaration+
      'End' 'Event' StatementTerminator
EventAccessorDeclaration
    : AddHandlerDeclaration
    | RemoveHandlerDeclaration
    | RaiseEventDeclaration
AddHandlerDeclaration
    : Attributes? 'AddHandler'
      OpenParenthesis ParameterList CloseParenthesis LineTerminator
      Block?
      'End' 'AddHandler' StatementTerminator
RemoveHandlerDeclaration
    : Attributes? 'RemoveHandler'
      OpenParenthesis ParameterList CloseParenthesis LineTerminator
      Block?
      'End' 'RemoveHandler' StatementTerminator
RaiseEventDeclaration
    : Attributes? 'RaiseEvent'
      OpenParenthesis ParameterList CloseParenthesis LineTerminator
      Block?
      'End' 'RaiseEvent' StatementTerminator
次に例を示します。For example:
Class Test
    Private Handlers As EventHandler
    Public Custom Event TestEvent As EventHandler
        AddHandler(value As EventHandler)
            Handlers = CType([Delegate].Combine(Handlers, value), _
                EventHandler)
        End AddHandler
        RemoveHandler(value as EventHandler)
            Handlers = CType([Delegate].Remove(Handlers, value), _
                EventHandler)
        End RemoveHandler
        RaiseEvent(sender As Object, e As EventArgs)
            Dim TempHandlers As EventHandler = Handlers
            If TempHandlers IsNot Nothing Then
                TempHandlers(sender, e)
            End If
        End RaiseEvent
    End Event
End Class
AddHandler宣言と RemoveHandler 宣言は、1つの ByVal パラメーターを受け取ります。これは、イベントのデリゲート型である必要があります。The AddHandler and RemoveHandler declaration take one ByVal parameter, which must be of the delegate type of the event. AddHandlerまたは RemoveHandler ステートメントが実行されると (または、 Handles 句が自動的にイベントを処理する場合)、対応する宣言が呼び出されます。When an AddHandler or RemoveHandler statement is executed (or a Handles clause automatically handles an event), the corresponding declaration will be called. 宣言は、 RaiseEvent イベントデリゲートと同じパラメーターを受け取り、ステートメントの実行時に呼び出され RaiseEvent ます。The RaiseEvent declaration takes the same parameters as the event delegate and will be called when a RaiseEvent statement is executed. すべての宣言を指定する必要があり、サブルーチンと見なされます。All of the declarations must be provided and are considered to be subroutines.
AddHandler、、およびの各宣言では、 RemoveHandler サブルーチンが RaiseEvent 持つ行の配置に対して同じ制限があることに注意してください。Note that AddHandler, RemoveHandler and RaiseEvent declarations have the same restriction on line placement that subroutines have. 開始ステートメント、終了ステートメント、およびブロックはすべて論理行の先頭に記述する必要があります。The beginning statement, end statement and block must all appear at the beginning of a logical line.
カスタムイベント宣言は、型の宣言空間に追加されたメンバー名に加えて、他のいくつかのメンバーを暗黙的に宣言します。In addition to the member name added to the type's declaration space, a custom event declaration implicitly declares several other members. という名前のイベント X を指定すると、次のメンバーが宣言領域に追加されます。Given an event named X, the following members are added to the declaration space:
add_X宣言に対応する、という名前のメソッド AddHandler 。A method named add_X, corresponding to the AddHandler declaration.
remove_X宣言に対応する、という名前のメソッド RemoveHandler 。A method named remove_X, corresponding to the RemoveHandler declaration.
fire_X宣言に対応する、という名前のメソッド RaiseEvent 。A method named fire_X, corresponding to the RaiseEvent declaration.
型が上記のいずれかの名前と一致する名前を宣言しようとすると、コンパイル時エラーが発生し、暗黙的な宣言はすべて名前のバインドのために無視されます。If a type attempts to declare a name that matches one of the above names, a compile-time error will result, and the implicit declarations are all ignored for the purposes of name binding. 導入されたメンバーをオーバーライドまたはオーバーロードすることはできませんが、派生型でシャドウすることはできます。It is not possible to override or overload any of the introduced members, although it is possible to shadow them in derived types.
注意。Note. Custom は予約語ではありません。Custom is not a reserved word.
WinRT アセンブリのカスタムイベントCustom events in WinRT assemblies
Microsoft Visual Basic 11.0 では、でコンパイルされたファイルで宣言されたイベント、 /target:winmdobj またはそのようなファイル内のインターフェイスで宣言されたイベントは、多少異なる方法で処理されます。As of Microsoft Visual Basic 11.0, events declared in a file compiled with /target:winmdobj, or declared in an interface in such a file and then implemented elsewhere, are treated a little differently.
Winmd を構築するために使用される外部ツールでは、通常、やなどの特定のデリゲート型のみが許可され、他の型は許可 System.EventHandler(Of T) System.TypedEventHandle(Of T, U) されません。External tools used to build the winmd will typically allow only certain delegate types such as System.EventHandler(Of T) or System.TypedEventHandle(Of T, U), and will disallow others.
フィールドの型はです XEvent System.Runtime.InteropServices.WindowsRuntime.EventRegistrationTokenTable(Of T) T 。はデリゲート型です。The XEvent field has type System.Runtime.InteropServices.WindowsRuntime.EventRegistrationTokenTable(Of T) where T is the delegate type.
AddHandler アクセサーはを返し、 System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken RemoveHandler アクセサーは同じ型の1つのパラメーターを受け取ります。The AddHandler accessor returns a System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken, and the RemoveHandler accessor takes a single parameter of the same type.
このようなカスタムイベントの例を次に示します。Here is an example of such a custom event.
Imports System.Runtime.InteropServices.WindowsRuntime
Public NotInheritable Class ClassInWinMD
    Private XEvent As EventRegistrationTokenTable(Of EventHandler(Of Integer))
    Public Custom Event X As EventHandler(Of Integer)
        AddHandler(handler As EventHandler(Of Integer))
            Return EventRegistrationTokenTable(Of EventHandler(Of Integer)).
                   GetOrCreateEventRegistrationTokenTable(XEvent).
                   AddEventHandler(handler)
        End AddHandler
        RemoveHandler(token As EventRegistrationToken)
            EventRegistrationTokenTable(Of EventHandler(Of Integer)).
                GetOrCreateEventRegistrationTokenTable(XEvent).
                RemoveEventHandler(token)
        End RemoveHandler
        RaiseEvent(sender As Object, i As Integer)
            Dim table = EventRegistrationTokenTable(Of EventHandler(Of Integer)).
                GetOrCreateEventRegistrationTokenTable(XEvent).
                InvocationList
            If table IsNot Nothing Then table(sender, i)
        End RaiseEvent
    End Event
End Class
定数Constants
定数 は、型のメンバーである定数値です。A constant is a constant value that is a member of a type.
ConstantMemberDeclaration
    : Attributes? ConstantModifier* 'Const' ConstantDeclarators StatementTerminator
ConstantModifier
    : AccessModifier
    | 'Shadows'
ConstantDeclarators
    : ConstantDeclarator ( Comma ConstantDeclarator )*
ConstantDeclarator
    : Identifier ( 'As' TypeName )? Equals ConstantExpression StatementTerminator
定数は暗黙的に共有されます。Constants are implicitly shared. 宣言に句が含まれている場合 As 、句は、宣言によって導入されたメンバーの型を指定します。If the declaration contains an As clause, the clause specifies the type of the member introduced by the declaration. 型を省略した場合、定数の型は推論されます。If the type is omitted then the type of the constant is inferred. 定数の型は、プリミティブ型またはのみにすることができ Object ます。The type of a constant may only be a primitive type or Object. 定数がとして型指定され、 Object 型文字がない場合、定数の実際の型は定数式の型になります。If a constant is typed as Object and there is no type character, the real type of the constant will be the type of the constant expression. それ以外の場合、定数の型は、定数の型文字の型になります。Otherwise, the type of the constant is the type of the constant's type character.
次の例は、 Constants 2 つのパブリック定数を持つという名前のクラスを示しています。The following example shows a class named Constants that has two public constants:
Class Constants
    Public Const A As Integer = 1
    Public Const B As Integer = A + 1
End Class
定数は、次の例のように、クラスを使用してアクセスできます。この例では、との値を出力し Constants.A Constants.B ます。Constants can be accessed through the class, as in the following example, which prints out the values of Constants.A and Constants.B.
Module Test
    Sub Main()
        Console.WriteLine(Constants.A & ", " & Constants.B)
    End Sub 
End Module
複数の定数を宣言する定数宣言は、1つの定数の複数の宣言と同じです。A constant declaration that declares multiple constants is equivalent to multiple declarations of single constants. 次の例では、1つの宣言ステートメントで3つの定数を宣言しています。The following example declares three constants in one declaration statement.
Class A
    Protected Const x As Integer = 1, y As Long = 2, z As Short = 3
End Class
この宣言は、次の場合と同じです。This declaration is equivalent to the following:
Class A
    Protected Const x As Integer = 1
    Protected Const y As Long = 2
    Protected Const z As Short = 3
End Class
定数の型のアクセシビリティドメインは、定数自体のアクセシビリティドメインのスーパーセットと同じであるか、またはそのスーパーセットと同じである必要があります。The accessibility domain of the type of the constant must be the same as or a superset of the accessibility domain of the constant itself. 定数式は、定数の型の値、または定数の型に暗黙的に変換できる型の値を生成する必要があります。The constant expression must yield a value of the constant's type or of a type that is implicitly convertible to the constant's type. 定数式を循環させることはできません。つまり、定数を定義することはできません。The constant expression may not be circular; that is, a constant may not be defined in terms of itself.
コンパイラは、定数宣言を適切な順序で自動的に評価します。The compiler automatically evaluates the constant declarations in the appropriate order. 次の例では、コンパイラは最初にを評価し、次に、 Y Z と最後 X に値10、11、および12を生成します。In the following example, the compiler first evaluates Y, then Z, and finally X, producing the values 10, 11, and 12, respectively.
Class A
    Public Const X As Integer = B.Z + 1
    Public Const Y As Integer = 10
End Class
Class B
    Public Const Z As Integer = A.Y + 1
End Class
定数値のシンボル名が必要であるが、定数宣言で値の型が許可されていない場合、またはコンパイル時に定数式で値を計算できない場合は、代わりに読み取り専用の変数を使用できます。When a symbolic name for a constant value is desired, but the type of the value is not permitted in a constant declaration or when the value cannot be computed at compile time by a constant expression, a read-only variable may be used instead.
インスタンスと共有変数Instance and Shared Variables
インスタンスまたは共有変数は、情報を格納できる型のメンバーです。An instance or shared variable is a member of a type that can store information.
VariableMemberDeclaration
    : Attributes? VariableModifier+ VariableDeclarators StatementTerminator
VariableModifier
    : AccessModifier
    | 'Shadows'
    | 'Shared'
    | 'ReadOnly'
    | 'WithEvents'
    | 'Dim'
VariableDeclarators
    : VariableDeclarator ( Comma VariableDeclarator )*
VariableDeclarator
    : VariableIdentifiers 'As' ObjectCreationExpression
    | VariableIdentifiers ( 'As' TypeName )? ( Equals Expression )?
VariableIdentifiers
    : VariableIdentifier ( Comma VariableIdentifier )*
VariableIdentifier
    : Identifier IdentifierModifiers
修飾子が指定されていない Dim 場合は修飾子を指定する必要がありますが、それ以外の場合は省略できます。The Dim modifier must be specified if no modifiers are specified, but may be omitted otherwise. 単一の変数宣言には、複数の変数宣言子を含めることができます。各変数宣言子は、新しいインスタンスまたは共有メンバーを導入します。A single variable declaration may include multiple variable declarators; each variable declarator introduces a new instance or shared member.
初期化子が指定されている場合は、変数宣言子で1つのインスタンスまたは共有変数のみを宣言できます。If an initializer is specified, only one instance or shared variable may be declared by the variable declarator:
Class Test
    Dim a, b, c, d As Integer = 10  ' Invalid: multiple initialization
End Class
この制限は、オブジェクト初期化子には適用されません。This restriction does not apply to object initializers:




    

Class Test
    Dim a, b, c, d As New Collection() ' OK
End Class
修飾子を使用して宣言された変数 Shared は 共有変数 です。A variable declared with the Shared modifier is a shared variable. 共有変数は、作成される型のインスタンスの数に関係なく、ストレージの場所を1つだけ識別します。A shared variable identifies exactly one storage location regardless of the number of instances of the type that are created. 共有変数は、プログラムの実行開始時に存在し、プログラムの終了時には存在しなくなります。A shared variable comes into existence when a program begins executing, and ceases to exist when the program terminates.
共有変数は、特定のクローズジェネリック型のインスタンス間でのみ共有されます。A shared variable is shared only among instances of a particular closed generic type. たとえば、次のようなプログラムがあるとします。For example, the program:
Class C(Of V) 
    Shared InstanceCount As Integer = 0
    Public Sub New()  
        InstanceCount += 1 
    End Sub
    Public Shared ReadOnly Property Count() As Integer 
            Return InstanceCount
        End Get
    End Property
End Class
Class Application 
    Shared Sub Main() 
        Dim x1 As New C(Of Integer)()
        Console.WriteLine(C(Of Integer).Count)
        Dim x2 As New C(Of Double)() 
        Console.WriteLine(C(Of Integer).Count)
        Dim x3 As New C(Of Integer)() 
        Console.WriteLine(C(Of Integer).Count)
    End Sub
End Class
印刷する:Prints out:
修飾子を指定せずに宣言された変数 Shared は、 インスタンス変数 と呼ばれます。A variable declared without the Shared modifier is called an instance variable. クラスのすべてのインスタンスには、クラスのすべてのインスタンス変数の個別のコピーが含まれています。Every instance of a class contains a separate copy of all instance variables of the class. 参照型のインスタンス変数は、その型の新しいインスタンスが作成されるときに存在し、そのインスタンスへの参照がなく、メソッドが実行されたときに存在しなく Finalize なります。An instance variable of a reference type comes into existence when a new instance of that type is created, and ceases to exist when there are no references to that instance and the Finalize method has executed. 値型のインスタンス変数は、そのインスタンスが属する変数と正確に同じ有効期間を持ちます。An instance variable of a value type has exactly the same lifetime as the variable to which it belongs. つまり、値型の変数が存在する場合、または存在しなくなった場合は、値型のインスタンス変数が発生します。In other words, when a variable of a value type comes into existence or ceases to exist, so does the instance variable of the value type.
宣言子に句が含まれている場合 As 、句は、宣言によって導入されたメンバーの型を指定します。If the declarator contains an As clause, the clause specifies the type of the members introduced by the declaration. 型が省略され、厳密なセマンティクスが使用されている場合、コンパイル時エラーが発生します。If the type is omitted and strict semantics are being used, a compile-time error occurs. それ以外の場合、メンバーの型は暗黙的に、またはメンバーの型 Object 文字の型になります。Otherwise the type of the members is implicitly Object or the type of the members' type character.
注意。Note. 構文にあいまいさはありません。宣言子が型を省略した場合、常に次の宣言子の型が使用されます。There is no ambiguity in the syntax: if a declarator omits a type, it will always use the type of a following declarator.
インスタンスまたは共有変数の型または配列要素型のアクセシビリティドメインは、インスタンスまたは共有変数自体のアクセシビリティドメインのスーパーセットと同じであるか、またはそのスーパーセットと同じである必要があります。The accessibility domain of an instance or shared variable's type or array element type must be the same as or a superset of the accessibility domain of the instance or shared variable itself.
次の例は Color 、、、およびという名前の内部インスタンス変数を持つクラスを示してい redPart greenPart bluePart ます。The following example shows a Color class that has internal instance variables named redPart, greenPart, and bluePart:
Class Color
    Friend redPart As Short
    Friend bluePart As Short
    Friend greenPart As Short
    Public Sub New(red As Short, blue As Short, green As Short)
        redPart = red
        bluePart = blue
        greenPart = green
    End Sub
End Class
Read-Only 変数Read-Only Variables
インスタンス変数または共有変数の宣言に修飾子が含まれている場合 ReadOnly 、宣言によって導入された変数への代入は、宣言の一部として、または同じクラスのコンストラクター内でのみ発生する可能性があります。When an instance or shared variable declaration includes a ReadOnly modifier, assignments to the variables introduced by the declaration may only occur as part of the declaration or in a constructor in the same class. 具体的には、読み取り専用インスタンスまたは共有変数への割り当ては、次の状況でのみ許可されます。Specifically, assignments to a read-only instance or shared variable are permitted only in the following situations:
(宣言に変数初期化子を含めることによって) インスタンスまたは共有変数を導入する変数宣言。In the variable declaration that introduces the instance or shared variable (by including a variable initializer in the declaration).
インスタンス変数の場合は、変数宣言を含むクラスのインスタンスコンストラクター。For an instance variable, in the instance constructors of the class that contains the variable declaration. インスタンス変数にアクセスできるのは、非修飾の方法、 Me またはまたは MyClass です。The instance variable can only be accessed in an unqualified manner or through Me or MyClass.
共有変数の場合は、共有変数宣言を含むクラスの共有コンストラクター。For a shared variable, in the shared constructor of the class that contains the shared variable declaration.
共有読み取り専用変数は、定数値のシンボル名が必要な場合、定数宣言で値の型が許可されていない場合、またはコンパイル時に定数式によって値を計算できない場合に便利です。A shared read-only variable is useful when a symbolic name for a constant value is desired, but when the type of the value is not permitted in a constant declaration, or when the value cannot be computed at compile time by a constant expression.
最初のアプリケーションの例は次のようになります。色共有変数は、 ReadOnly 他のプログラムによって変更されないように宣言されています。An example of the first such application follows, in which color shared variables are declared ReadOnly to prevent them from being changed by other programs:
Class Color
    Friend redPart As Short
    Friend bluePart As Short
    Friend greenPart As Short
    Public Sub New(red As Short, blue As Short, green As Short)
        redPart = red
        bluePart = blue
        greenPart = green
    End Sub 
    Public Shared ReadOnly Red As Color = New Color(&HFF, 0, 0)
    Public Shared ReadOnly Blue As Color = New Color(0, &HFF, 0)
    Public Shared ReadOnly Green As Color = New Color(0, 0, &HFF)
    Public Shared ReadOnly White As Color = New Color(&HFF, &HFF, &HFF)
End Class
定数と読み取り専用の共有変数のセマンティクスは異なります。Constants and read-only shared variables have different semantics. 式が定数を参照する場合、定数の値はコンパイル時に取得されますが、式が読み取り専用の共有変数を参照している場合、共有変数の値は実行時まで取得されません。When an expression references a constant, the value of the constant is obtained at compile time, but when an expression references a read-only shared variable, the value of the shared variable is not obtained until run time. 次のアプリケーションを考えてみます。このアプリケーションは、2つの異なるプログラムで構成されています。Consider the following application, which consists of two separate programs.
file1. vb:file1.vb:
Namespace Program1
    Public Class Utils
        Public Shared ReadOnly X As Integer = 1
    End Class
End Namespace
file2 .vb:file2.vb:
Namespace Program2
    Module Test
        Sub Main()
            Console.WriteLine(Program1.Utils.X)
        End Sub
    End Module
End Namespace
名前空間 Program1 とは、 Program2 個別にコンパイルされる2つのプログラムを表します。The namespaces Program1 and Program2 denote two programs that are compiled separately. 変数はとして宣言されているので Program1.Utils.X Shared ReadOnly 、ステートメントによって出力される値 Console.WriteLine はコンパイル時には認識されませんが、実行時に取得されます。Because variable Program1.Utils.X is declared as Shared ReadOnly, the value output by the Console.WriteLine statement is not known at compile time, but rather is obtained at run time. したがって、の値 X が変更されて再コンパイルされると、 Program1 が再コンパイルされて Console.WriteLine いない場合でも、ステートメントは新しい値を出力し Program2 ます。Thus, if the value of X is changed and Program1 is recompiled, the Console.WriteLine statement will output the new value even if Program2 is not recompiled. ただし、が定数であった場合、 X の値は X コンパイル時に取得され、 Program2 が再 Program1 コンパイルされるまでの変更の影響を受けたままになり Program2 ます。However, if X had been a constant, the value of X would have been obtained at the time Program2 was compiled, and would have remained unaffected by changes in Program1 until Program2 was recompiled.
WithEvents 変数WithEvents Variables
型は、イベントを発生させたインスタンスまたは共有変数を修飾子で宣言することによって、インスタンスまたは共有変数のいずれかによって発生するイベントのセットを処理することを宣言でき WithEvents ます。A type can declare that it handles some set of events raised by one of its instance or shared variables by declaring the instance or shared variable that raises the events with the WithEvents modifier. 次に例を示します。For example:
Class Raiser
    Public Event E1()
    Public Sub Raise()
        RaiseEvent E1
    End Sub
End Class
Module Test
    Private WithEvents x As Raiser
    Private Sub E1Handler() Handles x.E1
        Console.WriteLine("Raised")
    End Sub
    Public Sub Main()
        x = New Raiser()
    End Sub
End Module
この例では、メソッドは、 E1Handler E1 Raiser インスタンス変数に格納されている型のインスタンスによって発生するイベントを処理し x ます。In this example, the method E1Handler handles the event E1 that is raised by the instance of the type Raiser stored in the instance variable x.
WithEvents修飾子を指定すると、変数の名前が先頭のアンダースコアに変更され、イベントのフックと同じ名前のプロパティに置き換えられます。The WithEvents modifier causes the variable to be renamed with a leading underscore and replaced with a property of the same name that does the event hookup. たとえば、変数の名前がの場合、名前が F に変更され、 _F プロパティ F が暗黙的に宣言されます。For example, if the variable's name is F, it is renamed to _F and a property F is implicitly declared. 変数の新しい名前と別の宣言との間に競合がある場合は、コンパイル時エラーが報告されます。If there is a collision between the variable's new name and another declaration, a compile-time error will be reported. 変数に適用された属性は、名前が変更された変数に引き継がれます。Any attributes applied to the variable are carried over to the renamed variable.
宣言によって作成された暗黙的なプロパティは、 WithEvents フックを処理し、関連するイベントハンドラーのアンフック中を行います。The implicit property created by a WithEvents declaration takes care of hooking and unhooking the relevant event handlers. 変数に値が割り当てられている場合、プロパティはまず、 remove 変数に現在あるインスタンスのイベントのメソッドを呼び出します (既存のイベントハンドラーがある場合はアンフック中)。When a value is assigned to the variable, the property first calls the remove method for the event on the instance currently in the variable (unhooking the existing event handler, if any). 次に、割り当てが行われ、プロパティは、 add 変数内の新しいインスタンスでイベントのメソッドを呼び出します (新しいイベントハンドラーをフックします)。Next the assignment is made, and the property calls the add method for the event on the new instance in the variable (hooking up the new event handler). 次のコードは、標準モジュールの上記のコードに相当し Test ます。The following code is equivalent to the code above for the standard module Test:
Module Test
    Private _x As Raiser
    Public Property x() As Raiser
            Return _x
        End Get
        Set (Value As Raiser)
            ' Unhook any existing handlers.
            If _x IsNot Nothing Then
                RemoveHandler _x.E1, AddressOf E1Handler
            End If
            ' Change value.
            _x = Value
            ' Hook-up new handlers.
            If _x IsNot Nothing Then
                AddHandler _x.E1, AddressOf E1Handler
            End If
        End Set
    End Property
    Sub E1Handler()
        Console.WriteLine("Raised")
    End Sub
    Sub Main()
        x = New Raiser()
    End Sub
End Module
WithEvents変数が構造体として型指定されているかのように、インスタンスまたは共有変数を宣言することは無効です。It is not valid to declare an instance or shared variable as WithEvents if the variable is typed as a structure. また、は WithEvents 構造体では指定できません。また、 WithEvents とを ReadOnly 組み合わせることはできません。In addition, WithEvents may not be specified in a structure, and WithEvents and ReadOnly cannot be combined.
変数初期化子Variable Initializers
構造体のクラスおよびインスタンス変数宣言 (共有変数宣言ではありません) のインスタンスおよび共有変数宣言には、変数初期化子が含まれる場合があります。Instance and shared variable declarations in classes and instance variable declarations (but not shared variable declarations) in structures may include variable initializers. 変数の場合 Shared 、変数初期化子は、プログラムの開始後、変数が最初に参照される前に実行される代入ステートメントに対応し Shared ます。For Shared variables, variable initializers correspond to assignment statements that are executed after the program begins, but before the Shared variable is first referenced. インスタンス変数の場合、変数初期化子は、クラスのインスタンスが作成されるときに実行される代入ステートメントに対応します。For instance variables, variable initializers correspond to assignment statements that are executed when an instance of the class is created. パラメーターなしのコンストラクターは変更できないため、構造体にインスタンス変数初期化子を指定することはできません。Structures cannot have instance variable initializers because their parameterless constructors cannot be modified.




    

次の例を確認してください。Consider the following example:
Class Test
    Public Shared x As Double = Math.Sqrt(2.0)
    Public i As Integer = 100
    Public s As String = "Hello"
End Class
Module TestModule
    Sub Main()
        Dim a As New Test()
        Console.WriteLine("x = " & Test.x & ", i = " & a.i & ", s = " & a.s)
    End Sub
End Module
この例では次の出力が生成されます。The example produces the following output:
x = 1.4142135623731, i = 100, s = Hello
クラスの読み込み時にが割り当てられ x 、 i s クラスの新しいインスタンスが作成されるときにとが割り当てられます。An assignment to x occurs when the class is loaded, and assignments to i and s occur when a new instance of the class is created.
変数初期化子は、型のコンストラクターのブロックに自動的に挿入される代入ステートメントと考えると便利です。It is useful to think of variable initializers as assignment statements that are automatically inserted in the block of the type's constructor. 次の例には、いくつかのインスタンス変数初期化子が含まれています。The following example contains several instance variable initializers.
Class A
    Private x As Integer = 1
    Private y As Integer = -1
    Private count As Integer
    Public Sub New()
        count = 0
    End Sub
    Public Sub New(n As Integer)
        count = n
    End Sub
End Class
Class B
    Inherits A
    Private sqrt2 As Double = Math.Sqrt(2.0)
    Private items As ArrayList = New ArrayList(100)
    Private max As Integer
    Public Sub New()
        Me.New(100)
        items.Add("default")
    End Sub
    Public Sub New(n As Integer)
        MyBase.New(n - 1)
        max = n
    End Sub
End Class
この例は、次に示すコードに対応しています。各コメントは、自動的に挿入されたステートメントを示しています。The example corresponds to the code shown below, where each comment indicates an automatically inserted statement.
Class A
    Private x, y, count As Integer
    Public Sub New()
        MyBase.New ' Invoke object() constructor.
        x = 1 ' This is a variable initializer.
        y = -1 ' This is a variable initializer.
        count = 0
    End Sub
    Public Sub New(n As Integer)
        MyBase.New ' Invoke object() constructor. 
        x = 1 ' This is a variable initializer.
        y = - 1 ' This is a variable initializer.
        count = n
    End Sub
End Class
Class B
    Inherits A
    Private sqrt2 As Double
    Private items As ArrayList
    Private max As Integer
    Public Sub New()
        Me.New(100) 
        items.Add("default")
    End Sub
    Public Sub New(n As Integer)
        MyBase.New(n - 1) 
        sqrt2 = Math.Sqrt(2.0) ' This is a variable initializer.
        items = New ArrayList(100) ' This is a variable initializer.
        max = n
    End Sub
End Class
変数初期化子が実行される前に、すべての変数がその型の既定値に初期化されます。All variables are initialized to the default value of their type before any variable initializers are executed. 次に例を示します。For example:
Class Test
    Public Shared b As Boolean
    Public i As Integer
End Class
Module TestModule
    Sub Main()
        Dim t As New Test()
        Console.WriteLine("b = " & Test.b & ", i = " & t.i)
    End Sub
End Module
bは、クラスの読み込み時に既定値に自動的に初期化され、 i クラスのインスタンスが作成されるときに自動的に既定値に初期化されるため、上記のコードでは次の出力が生成されます。Because b is automatically initialized to its default value when the class is loaded and i is automatically initialized to its default value when an instance of the class is created, the preceding code produces the following output:
b = False, i = 0
各変数初期化子は、変数の型の値、または変数の型に暗黙的に変換できる型の値を生成する必要があります。Each variable initializer must yield a value of the variable's type or of a type that is implicitly convertible to the variable's type. 変数初期化子は、循環しているか、その後に初期化される変数を参照している可能性があります。この場合、参照先の変数の値は、初期化子のための既定値になります。A variable initializer may be circular or refer to a variable that will be initialized after it, in which case the value of the referenced variable is its default value for the purposes of the initializer. このような初期化子は、あいまい値です。Such an initializer is of dubious value.
変数初期化子には、標準初期化子、配列サイズ初期化子、およびオブジェクト初期化子の3つの形式があります。There are three forms of variable initializers: regular initializers, array-size initializers, and object initializers. 最初の2つの形式は、型名の後の等号の後に表示されます。後者の2つは宣言自体の一部です。The first two forms appear after an equal sign that follows the type name, the latter two are part of the declaration itself. 特定の宣言で使用できる初期化子の形式は1つだけです。Only one form of initializer may be used on any particular declaration.
標準初期化子Regular Initializers
通常の初期化子 は、変数の型に暗黙的に変換できる式です。A regular initializer is an expression that is implicitly convertible to the type of the variable. これは、型名の後の等号の後に表示され、値として分類される必要があります。It appears after an equal sign that follows the type name and must be classified as a value. 次に例を示します。For example:
Module Test
    Dim x As Integer = 10
    Dim y As Integer = 20
    Sub Main()
        Console.WriteLine("x = " & x & ", y = " & y)
    End Sub
End Module
このプログラムでは、次の出力が生成されます。This program produces the output:
x = 10, y = 20
変数宣言に通常の初期化子がある場合は、一度に1つの変数のみを宣言できます。If a variable declaration has a regular initializer, then only a single variable can be declared at a time. 次に例を示します。For example:
Module Test
    Sub Main()
        ' OK, only one variable declared at a time.
        Dim x As Integer = 10, y As Integer = 20
        ' Error: Can't initialize multiple variables at once.
        Dim a, b As Integer = 10
    End Sub
End Module
オブジェクト初期化子Object Initializers
オブジェクト初期化子 は、型名の代わりにオブジェクト作成式を使用して指定します。An object initializer is specified using an object creation expression in the place of the type name. オブジェクト初期化子は、オブジェクト作成式の結果を変数に割り当てる標準初期化子に相当します。An object initializer is equivalent to a regular initializer assigning the result of the object creation expression to the variable. そのため、So
Module TestModule
    Sub Main()
        Dim x As New Test(10)
    End Sub
End Module
上記の式は、次の式と同じです。is equivalent to
Module TestModule
    Sub Main()
        Dim x As Test = New Test(10)
    End Sub
End Module
オブジェクト初期化子のかっこは、常にコンストラクターの引数リストとして解釈され、配列型修飾子としては解釈されません。The parenthesis in an object initializer is always interpreted as the argument list for the constructor and never as array type modifiers. オブジェクト初期化子を持つ変数名には、配列型修飾子または null 許容型修飾子を指定できません。A variable name with an object initializer cannot have an array type modifier or a nullable type modifier.
Array-Size 初期化子Array-Size Initializers
配列サイズ初期化子 は、式によって示される次元の上限のセットを提供する変数の名前に対する修飾子です。An array-size initializer is a modifier on the name of the variable that gives a set of dimension upper bounds denoted by expressions.
ArraySizeInitializationModifier
    : OpenParenthesis BoundList CloseParenthesis ArrayTypeModifiers?
BoundList
    : Bound ( Comma Bound )*
Bound
    : Expression
    | '0' 'To' Expression
上限式は、値として分類する必要があり、に暗黙的に変換できる必要があり Integer ます。The upper bound expressions must be classified as values and must be implicitly convertible to Integer. 上限のセットは、指定された上限を持つ配列作成式の変数初期化子に相当します。The set of upper bounds is equivalent to a variable initializer of an array-creation expression with the given upper bounds. 配列型の次元数は、配列サイズ初期化子から推論されます。The number of dimensions of the array type is inferred from the array size initializer. そのため、So
Module Test
    Sub Main()
        Dim x(5, 10) As Integer
    End Sub
End Module
上記の式は、次の式と同じです。is equivalent to
Module Test
    Sub Main()
        Dim x As Integer(,) = New Integer(5, 10) {}
    End Sub
End Module
すべての上限は-1 以上である必要があり、すべてのディメンションには上限が指定されている必要があります。All upper bounds must be equal to or greater than -1, and all dimensions must have an upper bound specified. 初期化される配列の要素型がそれ自体が配列型である場合、配列型の修飾子は配列サイズ初期化子の右側になります。If the element type of the array being initialized is itself an array type, the array-type modifiers go to the right of the array-size initializer. 次に例を示します。For example
Module Test
    Sub Main()
        Dim x(5,10)(,,) As Integer
    End Sub
End Module
型がの3次元配列であるローカル変数を宣言し x Integer ます。これは、最初の次元のの境界を持つ配列に初期化され、 0..5 2 番目の次元に初期化され 0..10 ます。declares a local variable x whose type is a two-dimensional array of three-dimensional arrays of Integer, initialized to an array with bounds of 0..5 in the first dimension and 0..10 in the second dimension. 配列サイズ初期化子を使用して、型が配列の配列である変数の要素を初期化することはできません。It is not possible to use an array size initializer to initialize the elements of a variable whose type is an array of arrays.
配列サイズの初期化子を持つ変数宣言では、その型または標準の初期化子に配列型修飾子を含めることはできません。A variable declaration with an array-size initializer cannot have an array type modifier on its type or a regular initializer.
MarshalByRefObject クラスSystem.MarshalByRefObject Classes
クラスから派生したクラス System.MarshalByRefObject は、(つまり、値によって) コピーするのではなく、プロキシを使用してコンテキスト境界を越えてマーシャリングされます (つまり、参照渡し)。Classes that derive from the class System.MarshalByRefObject are marshaled across context boundaries using proxies (that is, by reference) rather than through copying (that is, by value). つまり、このようなクラスのインスタンスは実際のインスタンスではなくてもかまいませんが、コンテキスト境界を越えて変数アクセスとメソッド呼び出しをマーシャリングするスタブにするだけで済みます。This means that an instance of such a class may not be a true instance but instead may just be a stub that marshals variable accesses and method calls across a context boundary.
そのため、このようなクラスで定義されている変数の格納場所への参照を作成することはできません。As a result, it is not possible to create a reference to the storage location of variables defined on such classes. つまり、から派生したクラスとして型指定された変数を System.MarshalByRefObject 参照パラメーターに渡すことはできません。また、値型として型指定された変数のメソッドと変数にはアクセスできません。This means that variables typed as classes derived from System.MarshalByRefObject cannot be passed to reference parameters, and methods and variables of variables typed as value types may not be accessed. 代わりに、このようなクラスで定義されている変数はプロパティと同じように処理されます (制限はプロパティと同じであるため、Visual Basic ではプロパティとして扱われます)。Instead, Visual Basic treats variables defined on such classes as if they were properties (since the restrictions are the same on properties).
この規則には例外が1つあります。は常にプロキシではなく実際のオブジェクトであることが保証されるため、暗黙的または明示的に修飾されたメンバーは、 Me 上記の制限から除外されます。 MeThere is one exception to this rule: a member implicitly or explicitly qualified with Me is exempt from the above restrictions, because Me is always guaranteed to be an actual object, not a proxy.
プロパティProperties
プロパティ は、変数の自然な拡張です。どちらも、関連付けられた型を持つ名前付きのメンバーであり、変数およびプロパティにアクセスするための構文は同じです。Properties are a natural extension of variables; both are named members with associated types, and the syntax for accessing variables and properties is the same. ただし、変数とは異なり、プロパティはストレージの場所を意味しません。Unlike variables, however, properties do not denote storage locations. 代わりに、プロパティに アクセサー があります。アクセサーは、値の読み取りまたは書き込みを行うために実行するステートメントを指定します。Instead, properties have accessors, which specify the statements to execute in order to read or write their values.
プロパティは、プロパティ宣言を使用して定義されます。Properties are defined with property declarations. プロパティ宣言の最初の部分は、フィールド宣言に似ています。The first part of a property declaration resembles a field declaration. 2番目の部分には、アクセサーまたはアクセサーが含まれ Get Set ます。The second part includes a Get accessor and/or a Set accessor.
PropertyMemberDeclaration
    : RegularPropertyMemberDeclaration
    | MustOverridePropertyMemberDeclaration
    | AutoPropertyMemberDeclaration
PropertySignature
    : 'Property'
      Identifier ( OpenParenthesis ParameterList? CloseParenthesis )?
      ( 'As' Attributes? TypeName )?
RegularPropertyMemberDeclaration
    : Attributes? PropertyModifier* PropertySignature
      ImplementsClause? LineTerminator
      PropertyAccessorDeclaration+
      'End' 'Property' StatementTerminator
MustOverridePropertyMemberDeclaration
    : Attributes? MustOverridePropertyModifier+ PropertySignature
      ImplementsClause? StatementTerminator
AutoPropertyMemberDeclaration
    : Attributes? AutoPropertyModifier* 'Property' Identifier
      ( OpenParenthesis ParameterList? CloseParenthesis )?
      ( 'As' Attributes? TypeName )? ( Equals Expression )?
      ImplementsClause? LineTerminator
    | Attributes? AutoPropertyModifier* 'Property' Identifier
      ( OpenParenthesis ParameterList? CloseParenthesis )?
      'As' Attributes? 'New'
      ( NonArrayTypeName ( OpenParenthesis ArgumentList? CloseParenthesis )? )?
      ObjectCreationExpressionInitializer?
      ImplementsClause? LineTerminator
InterfacePropertyMemberDeclaration
    : Attributes? InterfacePropertyModifier* PropertySignature StatementTerminator
AutoPropertyModifier
    : AccessModifier
    | 'Shadows'
    | 'Shared'
    | 'Overridable'
    | 'NotOverridable'
    | 'Overrides'
    | 'Overloads'
PropertyModifier
    : AutoPropertyModifier
    | 'Default'
    | 'ReadOnly'
    | 'WriteOnly'
    | 'Iterator'
MustOverridePropertyModifier
    : PropertyModifier
    | 'MustOverride'
InterfacePropertyModifier
    : 'Shadows'
    | 'Overloads'
    | 'Default'
    | 'ReadOnly'
    | 'WriteOnly'
PropertyAccessorDeclaration
    : PropertyGetDeclaration
    | PropertySetDeclaration
次の例では、 Button クラスがプロパティを定義して Caption います。In the example below, the Button class defines a Caption property.




    

Public Class Button
    Private captionValue As String
    Public Property Caption() As String
            Return captionValue
        End Get
        Set (Value As String)
            captionValue = value
            Repaint()
        End Set
    End Property
End Class
上記のクラスに基づいて Button 、プロパティの使用例を次に示し Caption ます。Based on the Button class above, the following is an example of use of the Caption property:
Dim okButton As Button = New Button()
okButton.Caption = "OK" ' Invokes Set accessor.
Dim s As String = okButton.Caption ' Invokes Get accessor.
ここで Set は、プロパティに値を割り当てることによってアクセサーが呼び出され、 Get 式のプロパティを参照することによってアクセサーが呼び出されます。Here, the Set accessor is invoked by assigning a value to the property, and the Get accessor is invoked by referencing the property in an expression.
プロパティに型が指定されておらず、厳密なセマンティクスが使用されている場合、コンパイル時エラーが発生します。それ以外の場合は、プロパティの型が暗黙的 Object またはプロパティの型文字の型になります。If no type is specified for a property and strict semantics are being used, a compile-time error occurs; otherwise the type of the property is implicitly Object or the type of the property's type character. プロパティの宣言には、プロパティ Get の値を取得するアクセサー、 Set プロパティの値を格納するアクセサー、またはその両方を含めることができます。A property declaration may contain either a Get accessor, which retrieves the value of the property, a Set accessor, which stores the value of the property, or both. プロパティはメソッドを暗黙的に宣言するので、メソッドと同じ修飾子を使用してプロパティを宣言できます。Because a property implicitly declares methods, a property may be declared with the same modifiers as a method. プロパティがインターフェイスで定義されている場合、または修飾子を使用して定義されている場合は、 MustOverride プロパティ本体と End コンストラクトを省略する必要があります。そうしないと、コンパイル時エラーが発生します。If the property is defined in an interface or defined with the MustOverride modifier, the property body and the End construct must be omitted; otherwise, a compile-time error occurs.
インデックスパラメーターリストは、プロパティのシグネチャを作成するので、プロパティの型ではなく、インデックスパラメーターに対してプロパティがオーバーロードされる可能性があります。The index parameter list makes up the signature of the property, so properties may be overloaded on index parameters but not on the type of the property. インデックスパラメーターリストは、通常のメソッドの場合と同じです。The index parameter list is the same as for a regular method. ただし、修飾子を使用してパラメーターを変更することはできません。また、これらのパラメーターのいずれにも名前を付けることはできません ByRef Value (アクセサーの暗黙的な値パラメーター用に予約されてい Set ます)。However, none of the parameters may be modified with the ByRef modifier and none of them may be named Value (which is reserved for the implicit value parameter in the Set accessor).
プロパティは次のように宣言できます。A property may be declared as follows:
プロパティがプロパティ型修飾子を指定しない場合、プロパティはアクセサーとアクセサーの両方を持つ必要があり Get Set ます。If the property specifies no property type modifier, the property must have both a Get accessor and a Set accessor. プロパティは、読み取り/書き込みプロパティと呼ばれます。The property is said to be a read-write property.
プロパティが修飾子を指定 ReadOnly する場合、プロパティはアクセサーを持つ必要があり、 Get アクセサーを持つことはできません Set 。If the property specifies the ReadOnly modifier, the property must have a Get accessor and may not have a Set accessor. プロパティは、読み取り専用プロパティと呼ばれます。The property is said to be read-only property. 読み取り専用プロパティが割り当てのターゲットである場合、コンパイル時エラーになります。It is a compile-time error for a read-only property to be the target of an assignment.
プロパティが修飾子を指定 WriteOnly する場合、プロパティはアクセサーを持つ必要があり、 Set アクセサーを持つことはできません Get 。If the property specifies the WriteOnly modifier, the property must have a Set accessor and may not have a Get accessor. プロパティは、書き込み専用プロパティと呼ばれます。The property is said to be write-only property. 代入のターゲットまたはメソッドの引数として、式で書き込み専用のプロパティを参照する場合、コンパイル時エラーになります。It is a compile-time error to reference a write-only property in an expression except as the target of an assignment or as an argument to a method.
Get Set プロパティのアクセサーとアクセサーは、個別のメンバーではなく、プロパティのアクセサーを個別に宣言することはできません。The Get and Set accessors of a property are not distinct members, and it is not possible to declare the accessors of a property separately. 次の例では、1つの読み取り/書き込みプロパティを宣言しません。The following example does not declare a single read-write property. 代わりに、同じ名前の2つのプロパティを宣言します。1つは読み取り専用で、もう1つは書き込み専用です。Rather, it declares two properties with the same name, one read-only and one write-only:
Class A
    Private nameValue As String
    ' Error, contains a duplicate member name.
    Public ReadOnly Property Name() As String 
            Return nameValue
        End Get
    End Property
    ' Error, contains a duplicate member name.
    Public WriteOnly Property Name() As String 
        Set (Value As String)
            nameValue = value
        End Set
    End Property
End Class
同じクラスで宣言された2つのメンバーは同じ名前を持つことができないため、この例ではコンパイル時エラーが発生します。Since two members declared in the same class cannot have the same name, the example causes a compile-time error.
既定では、プロパティの Get アクセサーとアクセサーのアクセシビリティ Set は、プロパティ自体のアクセシビリティと同じです。By default, the accessibility of a property's Get and Set accessors is the same as the accessibility of the property itself. ただし、 Get アクセサーとアクセサーは、プロパティとは Set 別にアクセシビリティを指定することもできます。However, the Get and Set accessors can also specify accessibility separately from the property. この場合、アクセサーのアクセシビリティは、プロパティのアクセシビリティよりも制限されている必要があり、1つのアクセサーだけがプロパティから異なるアクセシビリティレベルを持つことができます。In that case, the accessibility of an accessor must be more restrictive than the accessibility of the property and only one accessor can have a different accessibility level from the property. アクセスの種類は、次のように制限の厳しいものと見なされます。Access types are considered more or less restrictive as follows:
Private は、、、 Public 、またはよりも制限されてい Protected Friend Protected Friend ます。Private is more restrictive than Public, Protected Friend, Protected, or Friend.
Friend はまたはよりも制限されてい Protected Friend Public ます。Friend is more restrictive than Protected Friend or Public.
Protected はまたはよりも制限されてい Protected Friend Public ます。Protected is more restrictive than Protected Friend or Public.
Protected Friend はよりも制限されてい Public ます。Protected Friend is more restrictive than Public.
プロパティのアクセサーのいずれかにアクセスできても、もう一方がアクセスできない場合、プロパティは読み取り専用または書き込み専用であるかのように扱われます。When one of a property's accessors is accessible but the other one is not, the property is treated as if it was read-only or write-only. 次に例を示します。For example:
Class A
    Public Property P() As Integer
        End Get
        Private Set (Value As Integer)
        End Set
    End Property
End Class
Module Test
    Sub Main()
        Dim a As A = New A()
        ' Error: A.P is read-only in this context.
        a.P = 10
    End Sub
End Module
派生型がプロパティをシャドウする場合、派生プロパティは、読み取りと書き込みの両方について、シャドウされたプロパティを非表示にします。When a derived type shadows a property, the derived property hides the shadowed property with respect to both reading and writing. 次の例では、 P のプロパティは、 B P A 読み取りと書き込みの両方に関して、のプロパティを非表示にします。In the following example, the P property in B hides the P property in A with respect to both reading and writing:
Class A
    Public WriteOnly Property P() As Integer
        Set (Value As Integer)
        End Set
    End Property
End Class
Class B
    Inherits A
    Public Shadows ReadOnly Property P() As Integer
       End Get
    End Property
End Class
Module Test
    Sub Main()
        Dim x As B = New B
        B.P = 10     ' Error, B.P is read-only.
    End Sub
End Module
戻り値の型またはパラメーターの型のアクセシビリティドメインは、またはプロパティ自体のアクセシビリティドメインのスーパーセットと同じである必要があります。The accessibility domain of the return type or parameter types must be the same as or a superset of the accessibility domain of the property itself. プロパティは、アクセサーとアクセサーを1つだけ持つことができ Set Get ます。A property may only have one Set accessor and one Get accessor.
宣言と呼び出しの構文の違いを除いて、、、、、およびの各プロパティは、、、、 Overridable 、およびの各メソッドとまったく同じように動作し NotOverridable Overrides MustOverride MustInherit Overridable NotOverridable Overrides MustOverride MustInherit ます。Except for differences in declaration and invocation syntax, Overridable, NotOverridable, Overrides, MustOverride, and MustInherit properties behave exactly like Overridable, NotOverridable, Overrides, MustOverride, and MustInherit methods. プロパティがオーバーライドされた場合、オーバーライドするプロパティは同じ型 (読み取り/書き込み、読み取り専用、書き込み専用) である必要があります。When a property is overridden, the overriding property must be of the same type (read-write, read-only, write-only). Overridableプロパティにアクセサーを含めることはできません Private 。An Overridable property cannot contain a Private accessor.
次の例では、は読み取り専用プロパティ、は読み取り/書き込みプロパティ、は読み取り/ X Overridable 書き込みプロパティ Y Overridable Z MustOverride です。In the following example X is an Overridable read-only property, Y is an Overridable read-write property, and Z is a MustOverride read-write property.
MustInherit Class A
    Private _y As Integer
    Public Overridable ReadOnly Property X() As Integer
            Return 0
        End Get
    End Property
    Public Overridable Property Y() As Integer
            Return _y
         End Get
        Set (Value As Integer)
            _y = value
        End Set
    End Property
    Public MustOverride Property Z() As Integer
End Class
はであるため Z MustOverride 、含んでいるクラスが宣言されている A 必要があり MustInherit ます。Because Z is MustOverride, the containing class A must be declared MustInherit.
これに対して、クラスから派生するクラスを A 次に示します。By contrast, a class that derives from class A is shown below:
Class B
    Inherits A
    Private _z As Integer
    Public Overrides ReadOnly Property X() As Integer
            Return MyBase.X + 1
        End Get
    End Property
    Public Overrides Property Y() As Integer
            Return MyBase.Y
        End Get
        Set (Value As Integer)
            If value < 0 Then
                MyBase.Y = 0
                MyBase.Y = Value
            End If
        End Set
    End Property
    Public Overrides Property Z() As Integer
            Return _z
        End Get
        Set (Value As Integer)
            _z = Value
        End Set
    End Property
End Class
ここでは、プロパティの宣言、 X Y 、およびは、 Z 基本プロパティよりも優先されます。Here, the declarations of properties X,Y, and Z override the base properties. 各プロパティ宣言は、対応する継承されたプロパティのアクセシビリティ修飾子、型、および名前と完全に一致します。Each property declaration exactly matches the accessibility modifiers, type, and name of the corresponding inherited property. プロパティの Get アクセサー X とプロパティのアクセサーは、継承され Set Y MyBase たプロパティにアクセスするためにキーワードを使用します。The Get accessor of property X and the Set accessor of property Y use the MyBase keyword to access the inherited properties. プロパティの宣言は、プロパティをオーバーライドします Z MustOverride 。したがって、クラスには未解決のメンバーはなく、 MustOverride 通常のクラスにすることもでき B B ます。The declaration of property Z overrides the MustOverride property -- thus, there are no outstanding MustOverride members in class B, and B is permitted to be a regular class.




    

プロパティを使用して、リソースが最初に参照されるまで、リソースの初期化を遅延させることができます。Properties can be used to delay initialization of a resource until the moment it is first referenced. 次に例を示します。For example:
Imports System.IO
Public Class ConsoleStreams
    Private Shared reader As TextReader
    Private Shared writer As TextWriter
    Private Shared errors As TextWriter
    Public Shared ReadOnly Property [In]() As TextReader
            If reader Is Nothing Then
                reader = Console.In
            End If
            Return reader
        End Get
    End Property
    Public Shared ReadOnly Property Out() As TextWriter
            If writer Is Nothing Then
                writer = Console.Out
            End If
            Return writer
        End Get
    End Property
    Public Shared ReadOnly Property [Error]() As TextWriter
            If errors Is Nothing Then
                errors = Console.Error
            End If
            Return errors
        End Get
    End Property
End Class
クラスには、、、 ConsoleStreams およびという3つのプロパティが含まれています。これらのプロパティは、 In Out Error 標準入力、出力、およびエラーデバイスをそれぞれ表します。The ConsoleStreams class contains three properties, In, Out, and Error, that represent the standard input, output, and error devices, respectively. これらのメンバーをプロパティとして公開することにより、 ConsoleStreams クラスは実際に使用されるまで初期化を遅延させることができます。By exposing these members as properties, the ConsoleStreams class can delay their initialization until they are actually used. たとえば、最初にプロパティを参照したとき Out に、 ConsoleStreams.Out.WriteLine("hello, world") 出力デバイスの基になるが TextWriter 初期化されます。For example, upon first referencing the Out property, as in ConsoleStreams.Out.WriteLine("hello, world"), the underlying TextWriter for the output device is initialized. ただし、アプリケーションがプロパティとプロパティを参照しない場合 In Error 、これらのデバイスのオブジェクトは作成されません。But if the application makes no reference to the In and Error properties, then no objects are created for those devices.
Get アクセサー宣言Get Accessor Declarations
Getアクセサー (getter) は、プロパティ宣言を使用して宣言され Get ます。A Get accessor (getter) is declared by using a property Get declaration. プロパティ宣言は、 Get キーワードとそれ Get に続くステートメントブロックで構成されます。A property Get declaration consists of the keyword Get followed by a statement block. という名前のプロパティを指定した P 場合、 Get アクセサー宣言は、 get_P プロパティと同じ修飾子、型、およびパラメーターリストを持つメソッドを暗黙的に宣言します。Given a property named P, a Get accessor declaration implicitly declares a method with the name get_P with the same modifiers, type, and parameter list as the property. 型にその名前の宣言が含まれている場合、コンパイル時エラーが発生しますが、暗黙的な宣言は名前のバインドのために無視されます。If the type contains a declaration with that name, a compile-time error results, but the implicit declaration is ignored for the purposes of name binding.
プロパティと同じ名前のアクセサー本体の宣言領域で暗黙的に宣言されている特殊なローカル変数は、 Get プロパティの戻り値を表します。A special local variable, which is implicitly declared in the Get accessor body's declaration space with the same name as the property, represents the return value of the property. ローカル変数は、式で使用されるときに特別な名前解決セマンティクスを持ちます。The local variable has special name resolution semantics when used in expressions. 呼び出し式など、メソッドグループとして分類された式を必要とするコンテキストでローカル変数が使用されている場合、その名前はローカル変数ではなく関数に解決されます。If the local variable is used in a context that expects an expression that is classified as a method group, such as an invocation expression, then the name resolves to the function rather than to the local variable. 次に例を示します。For example:
ReadOnly Property F(i As Integer) As Integer
        If i = 0 Then
            F = 1    ' Sets the return value.
            F = F(i - 1) ' Recursive call.
        End If
    End Get
End Property
かっこを使用すると、あいまいな状況が発生する可能性があります (ここで、 F(1) F は、型が1次元配列であるプロパティです)。The use of parentheses can cause ambiguous situations (such as F(1) where F is a property whose type is a one-dimensional array). あいまいな状況では、名前がローカル変数ではなくプロパティに解決されます。In all ambiguous situations, the name resolves to the property rather than the local variable. 次に例を示します。For example:
ReadOnly Property F(i As Integer) As Integer()
        If i = 0 Then
            F = new Integer(2) { 1, 2, 3 }
            F = F(i - 1) ' Recursive call, not index.
        End If
    End Get
End Property
制御フローがアクセサー本体から出たときに、 Get ローカル変数の値が呼び出し式に渡されます。When control flow leaves the Get accessor body, the value of the local variable is passed back to the invocation expression. アクセサーを呼び出す Get ことは、変数の値を読み取ることと概念的には同じであるため、 Get 次の例に示すように、アクセサーが観測可能な副作用を持つことができないと考えられます。Because invoking a Get accessor is conceptually equivalent to reading the value of a variable, it is considered bad programming style for Get accessors to have observable side effects, as illustrated in the following example:
Class Counter
    Private Value As Integer
    Public ReadOnly Property NextValue() As Integer
            Value += 1
            Return Value
        End Get
    End Property
End Class
プロパティの値は、 NextValue プロパティが以前にアクセスされた回数によって異なります。The value of the NextValue property depends on the number of times the property has previously been accessed. したがって、プロパティにアクセスすると、観測可能な副作用が生成されます。代わりに、プロパティをメソッドとして実装する必要があります。Thus, accessing the property produces an observable side effect, and the property should instead be implemented as a method.
アクセサーに対する "副作用なし" 規則は、 Get Get アクセサーが常に変数に格納されている値を返すように常に記述されていることを意味するわけではありません。The "no side effects" convention for Get accessors does not mean that Get accessors should always be written to simply return values stored in variables. 実際、 Get アクセサーでは、複数の変数にアクセスしたりメソッドを呼び出したりすることによって、多くの場合、プロパティの値を計算します。Indeed, Get accessors often compute the value of a property by accessing multiple variables or invoking methods. ただし、適切にデザインされたアクセサーでは、 Get オブジェクトの状態に対して監視可能な変更を引き起こすアクションは実行されません。However, a properly designed Get accessor performs no actions that cause observable changes in the state of the object.
注意。Note. Get アクセサーには、サブルーチンが持つ行の配置に対して同じ制限があります。Get accessors have the same restriction on line placement that subroutines have. 開始ステートメント、終了ステートメント、およびブロックはすべて論理行の先頭に記述する必要があります。The beginning statement, end statement and block must all appear at the beginning of a logical line.
PropertyGetDeclaration
    : Attributes? AccessModifier? 'Get' LineTerminator
      Block?
      'End' 'Get' StatementTerminator
アクセサー宣言の設定Set Accessor Declarations
Setアクセサー (セッター) は、プロパティセット宣言を使用して宣言されます。A Set accessor (setter) is declared by using a property set declaration. プロパティセットの宣言は、キーワード Set 、省略可能なパラメーターリスト、およびステートメントブロックで構成されます。A property set declaration consists of the keyword Set, an optional parameter list, and a statement block. という名前のプロパティを指定した P 場合、setter 宣言は、 set_P プロパティと同じ修飾子とパラメーターリストを持つメソッドを暗黙的に宣言します。Given a property named P, a setter declaration implicitly declares a method with the name set_P with the same modifiers and parameter list as the property. 型にその名前の宣言が含まれている場合、コンパイル時エラーが発生しますが、暗黙的な宣言は名前のバインドのために無視されます。If the type contains a declaration with that name, a compile-time error results, but the implicit declaration is ignored for the purposes of name binding.
パラメーターリストが指定されている場合は、1つのメンバーを持つ必要があります。ただし、そのメンバーは、以外の修飾子を持つ必要があり、 ByVal 型はプロパティの型と同じである必要があります。If a parameter list is specified, it must have one member, that member must have no modifiers except ByVal, and its type must be the same as the type of the property. パラメーターは、設定されるプロパティ値を表します。The parameter represents the property value being set. パラメーターを省略すると、という名前のパラメーター Value が暗黙的に宣言されます。If the parameter is omitted, a parameter named Value is implicitly declared.
注意。Note. Set アクセサーには、サブルーチンが持つ行の配置に対して同じ制限があります。Set accessors have the same restriction on line placement that subroutines have. 開始ステートメント、終了ステートメント、およびブロックはすべて論理行の先頭に記述する必要があります。The beginning statement, end statement and block must all appear at the beginning of a logical line.
PropertySetDeclaration
    : Attributes? AccessModifier? 'Set'
      ( OpenParenthesis ParameterList? CloseParenthesis )? LineTerminator
      Block?
      'End' 'Set' StatementTerminator
既定のプロパティDefault Properties
修飾子を指定するプロパティは、 Default 既定の プロパティ と呼ばれます。A property that specifies the modifier Default is called a default property. プロパティを許可する型には、インターフェイスを含む既定のプロパティが含まれる場合があります。Any type that allows properties may have a default property, including interfaces. プロパティの名前を使用してインスタンスを修飾しなくても、既定のプロパティを参照できます。The default property may be referenced without having to qualify the instance with the name of the property. したがって、クラスが指定されています。Thus, given a class
Class Test
    Public Default ReadOnly Property Item(i As Integer) As Integer
            Return i
        End Get
    End Property
End Class
コードthe code
Module TestModule
    Sub Main()
        Dim x As Test = New Test()
        Dim y As Integer
        y = x(10)
    End Sub
End Module
上記の式は、次の式と同じです。is equivalent to
Module TestModule
    Sub Main()
        Dim x As Test = New Test()
        Dim y As Integer
        y = x.Item(10)
    End Sub
End Module
プロパティが宣言さ Default れると、継承階層内のその名前でオーバーロードされたすべてのプロパティが、宣言されているかどうかにかかわらず、既定のプロパティになり Default ます。Once a property is declared Default, all of the properties overloaded on that name in the inheritance hierarchy become the default property, whether they have been declared Default or not. Default基底クラスで別の名前によって既定のプロパティを宣言した場合に、派生クラスでプロパティを宣言すると、やなどの他の修飾子は必要ありません Shadows Overrides 。Declaring a property Default in a derived class when the base class declared a default property by another name does not require any other modifiers such as Shadows or Overrides. これは、既定のプロパティに id またはシグネチャがないため、シャドウまたはオーバーロードできないためです。This is because the default property has no identity or signature and so cannot be shadowed or overloaded. 次に例を示します。For example:
Class Base
    Public ReadOnly Default Property Item(i As Integer) As Integer
            Console.WriteLine("Base = " & i)
        End Get
    End Property
End Class
Class Derived
    Inherits Base
    ' This hides Item, but does not change the default property.
    Public Shadows ReadOnly Property Item(i As Integer) As Integer
            Console.WriteLine("Derived = " & i)
        End Get
    End Property
End Class
Class MoreDerived
    Inherits Derived
    ' This declares a new default property, but not Item.
    ' This does not need to be declared Shadows
    Public ReadOnly Default Property Value(i As Integer) As Integer
            Console.WriteLine("MoreDerived = " & i)
        End Get
    End Property
End Class
Module Test
    Sub Main()
        Dim x As MoreDerived = New MoreDerived()
        Dim y As Integer
        Dim z As Derived = x
        y = x(10)        ' Calls MoreDerived.Value.
        y = x.Item(10)   ' Calls Derived.Item
        y = z(10)        ' Calls Base.Item
    End Sub
End Module
このプログラムでは、次の出力が生成されます。This program will produce the output:
MoreDerived = 10
Derived = 10
Base = 10
型の中で宣言されたすべての既定のプロパティは、同じ名前である必要があります。わかりやすくするために、修飾子を指定する必要があり