Разное

Интерфейс в visual basic: Интерфейсы — Visual Basic | Microsoft Docs

Содержание

Интерфейсы — Visual Basic | Microsoft Docs



  • Чтение занимает 4 мин

В этой статье

Интерфейсы определяют свойства, методы и события, которые можно реализовать в классах.Interfaces define the properties, methods, and events that classes can implement. Интерфейсы позволяют определить возможности в виде небольших групп тесно связанных свойств, методов и событий. Это снижает число проблем совместимости, так как можно создавать усовершенствованные реализации интерфейсов без изменения существующего кода.Interfaces allow you to define features as small groups of closely related properties, methods, and events; this reduces compatibility problems because you can develop enhanced implementations for your interfaces without jeopardizing existing code. Вы можете добавлять новые функции в любое время с помощью дополнительных интерфейсов и реализаций.You can add new features at any time by developing additional interfaces and implementations.

Далее представлены другие причины, из-за которых вам может потребоваться использовать интерфейсы вместо наследования классов.There are several other reasons why you might want to use interfaces instead of class inheritance:

  • Интерфейсы более удобны в ситуациях, в которых приложениям требуется множество возможно несвязанных типов объектов для предоставления определенных возможностей.Interfaces are better suited to situations in which your applications require many possibly unrelated object types to provide certain functionality.

  • Интерфейсы более гибкие, чем базовые классы, так как вы можете определить одну реализацию, в которой можно реализовать несколько интерфейсов.Interfaces are more flexible than base classes because you can define a single implementation that can implement multiple interfaces.

  • Интерфейсы предпочтительнее в случаях, в которых нет необходимости наследовать реализацию базового класса.Interfaces are better in situations in which you do not have to inherit implementation from a base class.

  • Интерфейсы полезны, когда невозможно использовать наследование класса.Interfaces are useful when you cannot use class inheritance. Например, структуры не могут наследовать от классов, но они могут реализовывать интерфейсы.For example, structures cannot inherit from classes, but they can implement interfaces.

Объявление интерфейсовDeclaring Interfaces

Определения интерфейса заключаются в операторы Interface и End Interface.Interface definitions are enclosed within the Interface and End Interface statements. После оператора Interface можно добавить необязательный оператор Inherits, в котором указывается один или несколько наследуемых интерфейсов.Following the Interface statement, you can add an optional Inherits statement that lists one or more inherited interfaces. Операторы Inherits должны предшествовать всем другим операторам в объявлении, за исключением комментариев.The Inherits statements must precede all other statements in the declaration except comments. Остальными операторами в определении интерфейса должны быть Event, Sub, Function, Property, Interface, Class, Structure и Enum.The remaining statements in the interface definition should be Event, Sub, Function, Property, Interface, Class, Structure, and Enum statements. Интерфейсы не могут содержать код реализаций или операторы, связанные с кодом реализации, такие как End Sub и End Property.Interfaces cannot contain any implementation code or statements associated with implementation code, such as End Sub or End Property.

В пространстве имен операторы интерфейса по умолчанию относятся к типу Friend, но также их можно явно объявить как Public или Friend.In a namespace, interface statements are Friend by default, but they can also be explicitly declared as Public or Friend. Интерфейсы, определенные в классах, модулях, интерфейсах и структурах по умолчанию объявлены как Public, но их также можно явно объявить как Public, Friend, Protected и Private.Interfaces defined within classes, modules, interfaces, and structures are Public by default, but they can also be explicitly declared as Public, Friend, Protected, or Private.

Примечание

Ключевое слово Shadows может применяться ко всем элементам интерфейса.The Shadows keyword can be applied to all interface members. Ключевое слово Overloads слово может применяться к операторам Sub, Function, и Property, объявленным в определении интерфейса.The Overloads keyword can be applied to Sub, Function, and Property statements declared in an interface definition. Кроме того, операторы Property могут содержать модификаторы Default, ReadOnly и WriteOnly.In addition, Property statements can have the Default, ReadOnly, or WriteOnly modifiers. Другие модификаторы (Public, Private, Friend, Protected, Shared, Overrides, MustOverride и Overridable) не разрешены.None of the other modifiers—Public, Private, Friend, Protected, Shared, Overrides, MustOverride, or Overridable—are allowed. Дополнительные сведения см. в разделе Контексты объявления и уровни доступа по умолчанию.For more information, see Declaration Contexts and Default Access Levels.

Например, в следующем примере кода определяется интерфейс с одной функцией, одним свойством и одним событием.For example, the following code defines an interface with one function, one property, and one event.

Interface IAsset
    Event ComittedChange(ByVal Success As Boolean)
    Property Division() As String
    Function GetID() As Integer
End Interface

Реализация интерфейсовImplementing Interfaces

Зарезервированное слово Visual Basic Implements используется двумя способами.The Visual Basic reserved word Implements is used in two ways. Оператор Implements означает, что класс или структура реализуют интерфейс.The Implements statement signifies that a class or structure implements an interface. Ключевое слово Implements указывает, что элемент класса или структуры реализует определенный элемент интерфейса.The Implements keyword signifies that a class member or structure member implements a specific interface member.

Оператор ImplementsImplements Statement

Если класс или структура реализует один или несколько интерфейсов, они должны содержать оператор Implements сразу после оператора Class или Structure.If a class or structure implements one or more interfaces, it must include the Implements statement immediately after the Class or Structure statement. Оператору Implements требуется разделенный запятыми список интерфейсов, которые должны быть реализованы с помощью класса.The Implements statement requires a comma-separated list of interfaces to be implemented by a class. Структура или класс должны реализовать все элементы интерфейса с помощью ключевого слова Implements.The class or structure must implement all interface members using the Implements keyword.

Ключевое слово ImplementsImplements Keyword

Ключевому слову Implements требуется разделенный запятыми список элементов интерфейса, которые необходимо реализовать.The Implements keyword requires a comma-separated list of interface members to be implemented. Как правило, указывается только один элемент интерфейса, но можно указать несколько элементов.Generally, only a single interface member is specified, but you can specify multiple members. Спецификация элемента интерфейса состоит из имени интерфейса, которое должно быть указано в операторе implements внутри класса, точки и имени реализуемой функции-члена, свойства или события.The specification of an interface member consists of the interface name, which must be specified in an implements statement within the class; a period; and the name of the member function, property, or event to be implemented. Имя члена, реализующего член интерфейса, может использовать любой допустимый идентификатор, и оно не ограничивается InterfaceName_MethodName соглашением, используемым в более ранних версиях Visual Basic.The name of a member that implements an interface member can use any legal identifier, and it is not limited to the InterfaceName_MethodName convention used in earlier versions of Visual Basic.

Например, в следующем примере кода показано, как объявить подпрограмму с именем Sub1, в которой реализуется метод интерфейса:For example, the following code shows how to declare a subroutine named Sub1 that implements a method of an interface:

Class Class1
    Implements interfaceclass.interface2

    Sub Sub1(ByVal i As Integer) Implements interfaceclass.interface2.Sub1
    End Sub
End Class

Типы параметров и типы возвращаемого значения элемента реализации должны соответствовать объявлению свойства или элемента в интерфейсе.The parameter types and return types of the implementing member must match the interface property or member declaration in the interface. Наиболее распространенный способ реализации элемента интерфейса — использование элемента с таким же, как у интерфейса, именем, как показано в предыдущем примере.The most common way to implement an element of an interface is with a member that has the same name as the interface, as shown in the previous example.

Для объявления реализации метода интерфейса можно использовать любые атрибуты, которые допустимы в объявлении метода экземпляра, включая Overloads, Overrides, Overridable, Public, Private, Protected, Friend, Protected Friend, MustOverride, Default и Static.To declare the implementation of an interface method, you can use any attributes that are legal on instance method declarations, including Overloads, Overrides, Overridable, Public, Private, Protected, Friend, Protected Friend, MustOverride, Default, and Static. Атрибут Shared недопустим, поскольку он определяет класс, а не метод экземпляра.The Shared attribute is not legal since it defines a class rather than an instance method.

С помощью Implements можно также написать один метод, который реализует несколько методов, определенных в интерфейсе, как показано в следующем примере:Using Implements, you can also write a single method that implements multiple methods defined in an interface, as in the following example:

Class Class2
    Implements I1, I2

    Protected Sub M1() Implements I1.M1, I1.M2, I2.M3, I2.M4
    End Sub
End Class

Закрытый элемент можно использовать для реализации члена интерфейса.You can use a private member to implement an interface member. Если закрытый член реализует член интерфейса, этот элемент становится доступен через интерфейс, хотя он недоступен напрямую через переменные класса.When a private member implements a member of an interface, that member becomes available by way of the interface even though it is not available directly on object variables for the class.

Примеры реализации интерфейсовInterface Implementation Examples

Классы, реализующие интерфейс, должны реализовать все свойства, методы и события.Classes that implement an interface must implement all its properties, methods, and events.

В примере ниже определены два интерфейса.The following example defines two interfaces. Второй интерфейс, Interface2, наследует Interface1 и определяет дополнительное свойство и метод.The second interface, Interface2, inherits Interface1 and defines an additional property and method.

Interface Interface1
    Sub sub1(ByVal i As Integer)
End Interface

' Demonstrates interface inheritance.
Interface Interface2
    Inherits Interface1
    Sub M1(ByVal y As Integer)
    ReadOnly Property Num() As Integer
End Interface

В следующем примере реализуется Interface1, интерфейс, определенный в предыдущем примере:The next example implements Interface1, the interface defined in the previous example:

Public Class ImplementationClass1
    Implements Interface1
    Sub Sub1(ByVal i As Integer) Implements Interface1.sub1
        ' Insert code here to implement this method.
    End Sub
End Class

В последнем примере реализуется Interface2, включающий метод, унаследованный от Interface1:The final example implements Interface2, including a method inherited from Interface1:

Public Class ImplementationClass2
    Implements Interface2
    Dim INum As Integer = 0
    Sub sub1(ByVal i As Integer) Implements Interface2.sub1
        ' Insert code here that implements this method.
    End Sub
    Sub M1(ByVal x As Integer) Implements Interface2.M1
        ' Insert code here to implement this method.
    End Sub

    ReadOnly Property Num() As Integer Implements Interface2.Num
        Get
            Num = INum
        End Get
    End Property
End Class

Можно реализовать свойство только для чтения со свойством, доступным для чтения и записи (т. е. не нужно объявлять его свойством только для чтения в классе реализации).You can implement a readonly property with a readwrite property (that is, you do not have to declare it readonly in the implementing class). В реализации интерфейса должны быть по крайней мере реализованы элементы, которые объявляются интерфейсом, но можно обеспечить дополнительные возможности, например разрешить запись свойства.Implementing an interface promises to implement at least the members that the interface declares, but you can offer more functionality, such as allowing your property to be writable.

Интерфейсы в Visual Basic.NET

Интерфейсы

Последнее обновление: 30.10.2015

Важную роль в системе ООП играют интерфейсы. Они определяют некоторый абстрактный функционал, не имеющий конкретной реализации, который уже реализуют
классы, наследующие эти интерфейсы. Определение интерфейса похоже на определения класса: интерфейс также может содержать свойства, методы и события.
Чтобы объявить интерфейс, надо использовать ключевое слово Interface (обратите внимание, что имена интерфейсов обычно начинаются с заглавной буквы
I). Итак, в прошлой главе мы создали небольшую систему из классов Person, Employee и Client, которые сейчас выглядят так:


Public MustInherit Class Person

    Public Property FirstName() As String
    Public Property LastName() As String
    'Абстрактный метод
    Public MustOverride Sub Display()

    Public Sub New(fName As String, lName As String)
        FirstName = fName
        LastName = lName
    End Sub

End Class

Public Class Employee
    Inherits Person

    Public Property Bank As String

    Public Overrides Sub Display()
        Console.WriteLine(FirstName & " " & LastName & " works in " & Bank)
    End Sub

    Public Sub New(fName As String, lName As String, _bank As String)
        MyBase.New(fName, lName)
        Bank = _bank
    End Sub

End Class

Public Class Client
    Inherits Person

    Public Property Bank As String

    Public Overrides Sub Display()
        Console.WriteLine(FirstName & " " & LastName & " has an account in bank " & Bank)
    End Sub

    Public Sub New(fName As String, lName As String, _bank As String)
        MyBase.New(fName, lName)
        Bank = _bank
    End Sub

End Class

Теперь добавим в наше приложение интерфейс IAccount, который будет содержать методы и свойства, которые понадобятся при работе с счетом клиента.
Чтобы добавить интерфейс, в меню Project выберите пункт Add New Item… и в появившемся списке выберите пункт Code File.
Назовите новый файл IAccount.vb. Будет создан пустой файл, и затем добавьте в него следующий код интерфейса:


Public Interface IAccount
    'Текущая сумма на счете
    ReadOnly Property CurentSum() As Integer
    'Метод для добавления денег на счет
    Sub Put(sum As Integer)
    'Метод для снятия денег со счета
    Sub Withdraw(sum As Integer)
    'Процент начислений
    ReadOnly Property Procentage() As Integer
End Interface

Обратите внимание, что методы и свойства не имеют реализации, в этом они сближаются с абстрактными методами абстрактных классов. Сущность нашего интерфейса
проста: он определяет два свойства для текущей суммы денег на счете и ставки процента по вкладам и два метода для добавления денег на счет и изъятия
денег. Теперь нам надо реализовать интерфейс в классе Client, так как клиент у нас обладает счетом. Чтобы реализовать интерфейс,
нам надо использовать ключевое слово Implements. Изменим класс Client следующим образом:


Public Class Client
    Inherits Person
    Implements IAccount

    'Переменная для хранения суммы
    Dim _sum As Integer
    'Переменная для хранения процента
    Dim _procentage As Integer

    Public Property Bank As String

    'Текущая сумма на счете
    ReadOnly Property CurentSum() As Integer Implements IAccount.CurentSum
        Get
            Return _sum
        End Get
    End Property
    'Метод для добавления денег на счет
    Sub Put(sum As Integer) Implements IAccount.Put
        _sum += sum
    End Sub
    'Метод для снятия денег со счета
    Sub Withdraw(sum As Integer) Implements IAccount.Withdraw
        If sum <= CurentSum Then
            _sum -= sum
        End If
    End Sub
    'Процент начислений
    ReadOnly Property Procentage() As Integer Implements IAccount.Procentage
        Get
            Return _procentage
        End Get
    End Property

    Public Overrides Sub Display()
        Console.WriteLine(FirstName & " " & LastName & " has an account in bank " & Bank)
    End Sub

    Public Sub New(fName As String, lName As String, _bank As String, _sum As Integer)
        MyBase.New(fName, lName)
        Bank = _bank
        Me._sum = _sum
    End Sub

Обратите внимание, что класс, реализующий интерфейс, обязан реализовать все его свойства, методы и события. Интерфейсы, как и классы, могут наследоваться:


Public Interface IDepositAccount
    Inherits IAccount

    'Начисление процентов
    Sub GetIncome()

End Interface

Зачем же нужны интерфейсы, если по сути они ничего не делают, только объявляют методы и свойства? Во-первых, интерфейсы позволяют реализовать
концепцию множественного наследования. Если некоторый класс может иметь только один базовый класс, то при этом он может реализовать множество интерфейсов.
Во-вторых, они более гибки по сравнению с классами, так как не содержат конкретной реализации.

Создание и реализация интерфейсов — Visual Basic



  • Чтение занимает 3 мин

В этой статье

Интерфейсы описывают характеристики свойств, методов и событий, но не содержат сведений о реализации до структур или классов.Interfaces describe the characteristics of properties, methods, and events, but leave the implementation details up to structures or classes.

В этом пошаговом руководстве показано, как объявить и реализовать интерфейс.This walkthrough demonstrates how to declare and implement an interface.

Примечание

В этом пошаговом руководстве не содержатся сведения о создании пользовательского интерфейса.This walkthrough doesn’t provide information about how to create a user interface.

Примечание

Отображаемые на компьютере имена или расположения некоторых элементов пользовательского интерфейса Visual Studio могут отличаться от указанных в следующих инструкциях.Your computer might show different names or locations for some of the Visual Studio user interface elements in the following instructions. Это зависит от имеющегося выпуска Visual Studio и используемых параметров.The Visual Studio edition that you have and the settings that you use determine these elements. Дополнительные сведения см. в разделе Персонализация среды IDE.For more information, see Personalizing the IDE.

Определение интерфейсаTo define an interface

  1. Откройте новый проект приложения Windows на Visual Basic.Open a new Visual Basic Windows Application project.

  2. Добавьте в проект новый модуль, выбрав в меню проект пункт Добавить модуль .Add a new module to the project by clicking Add Module on the Project menu.

  3. Присвойте новому модулю имя Module1.vb и нажмите кнопку Добавить.Name the new module Module1.vb and click Add. Отобразится код для нового модуля.The code for the new module is displayed.

  4. Определите интерфейс с именем TestInterface в Module1 , введя Interface TestInterface между Module End Module операторами и, а затем нажав клавишу ВВОД.Define an interface named TestInterface within Module1 by typing Interface TestInterface between the Module and End Module statements, and then pressing ENTER. Редактор кода смещает Interface ключевое слово и добавляет End Interface оператор для формирования блока кода.The Code Editor indents the Interface keyword and adds an End Interface statement to form a code block.

  5. Определите свойство, метод и событие для интерфейса, поместив следующий код между Interface End Interface операторами и:Define a property, method, and event for the interface by placing the following code between the Interface and End Interface statements:

    Property Prop1() As Integer
    Sub Method1(ByVal X As Integer)
    Event Event1()
    

РеализацияImplementation

Вы можете заметить, что синтаксис, используемый для объявления членов интерфейса, отличается от синтаксиса, используемого для объявления членов класса.You may notice that the syntax used to declare interface members is different from the syntax used to declare class members. Это различие отражает тот факт, что интерфейсы не могут содержать код реализации.This difference reflects the fact that interfaces cannot contain implementation code.

Реализация интерфейсаTo implement the interface

  1. Добавьте класс с именем, ImplementationClass добавив следующий оператор в Module1 , после End Interface оператора, но перед End Module оператором, а затем нажав клавишу ВВОД:Add a class named ImplementationClass by adding the following statement to Module1, after the End Interface statement but before the End Module statement, and then pressing ENTER:

    Class ImplementationClass
    

    При работе в интегрированной среде разработки Редактор кода предоставляет соответствующий End Class оператор при нажатии клавиши ВВОД.If you are working within the integrated development environment, the Code Editor supplies a matching End Class statement when you press ENTER.

  2. Добавьте следующий Implements оператор в ImplementationClass , который именует интерфейс, реализуемый классом:Add the following Implements statement to ImplementationClass, which names the interface the class implements:

    Implements TestInterface
    

    При указании отдельно от других элементов в верхней части класса или структуры Implements оператор указывает, что класс или структура реализуют интерфейс.When listed separately from other items at the top of a class or structure, the Implements statement indicates that the class or structure implements an interface.

    При работе в интегрированной среде разработки Редактор кода реализует члены класса, необходимые TestInterface при нажатии клавиши ВВОД, и вы можете пропустить следующий шаг.If you are working within the integrated development environment, the Code Editor implements the class members required by TestInterface when you press ENTER, and you can skip the next step.

  3. Если вы не работаете в интегрированной среде разработки, необходимо реализовать все члены интерфейса MyInterface .If you are not working within the integrated development environment, you must implement all the members of the interface MyInterface. Добавьте следующий код в ImplementationClass для реализации Event1 , Method1 и Prop1 :Add the following code to ImplementationClass to implement Event1, Method1, and Prop1:

    Event Event1() Implements TestInterface.Event1
    
    Public Sub Method1(ByVal X As Integer) Implements TestInterface.Method1
    End Sub
    
    Public Property Prop1() As Integer Implements TestInterface.Prop1
        Get
        End Get
        Set(ByVal value As Integer)
        End Set
    End Property
    

    ImplementsОператор именует интерфейс и член интерфейса, который реализуется.The Implements statement names the interface and interface member being implemented.

  4. Завершите определение Prop1 , добавив закрытое поле в класс, который сохранил значение свойства:Complete the definition of Prop1 by adding a private field to the class that stored the property value:

    ' Holds the value of the property.
    Private pval As Integer
    

    Возврат значения pval из метода доступа get свойства.Return the value of the pval from the property get accessor.

    Return pval
    

    Задайте значение pval в методе доступа к набору свойств.Set the value of pval in the property set accessor.

    pval = value
    
  5. Завершите определение Method1 , добавив следующий код.Complete the definition of Method1 by adding the following code.

    MsgBox("The X parameter for Method1 is " & X)
    RaiseEvent Event1()
    

Тестирование реализации интерфейсаTo test the implementation of the interface

  1. Щелкните правой кнопкой мыши форму запуска проекта в Обозреватель решенийи выберите пункт Просмотреть код.Right-click the startup form for your project in the Solution Explorer, and click View Code. Редактор отображает класс для начальной формы.The editor displays the class for your startup form. По умолчанию вызывается форма запуска Form1 .By default, the startup form is called Form1.

  2. Добавьте в testInstance класс следующее поле Form1 :Add the following testInstance field to the Form1 class:

    Dim WithEvents testInstance As TestInterface
    

    Если объявить testInstance как WithEvents , Form1 класс может управлять его событиями.By declaring testInstance as WithEvents, the Form1 class can handle its events.

  3. Добавьте следующий обработчик событий в Form1 класс для обработки событий, вызванных testInstance :Add the following event handler to the Form1 class to handle events raised by testInstance:

    Sub EventHandler() Handles testInstance.Event1
        MsgBox("The event handler caught the event.")
    End Sub
    
  4. Добавьте подпрограммы с именем Test в Form1 класс для проверки класса реализации:Add a subroutine named Test to the Form1 class to test the implementation class:

    Sub Test()
        '  Create an instance of the class.
        Dim T As New ImplementationClass
        ' Assign the class instance to the interface.
        ' Calls to the interface members are 
        ' executed through the class instance.
        testInstance = T
        ' Set a property.
        testInstance.Prop1 = 9
        ' Read the property.
        MsgBox("Prop1 was set to " & testInstance.Prop1)
        '  Test the method and raise an event.
        testInstance.Method1(5)
    End Sub
    

    TestПроцедура создает экземпляр класса, реализующего MyInterface , присваивает этот экземпляр testInstance полю, устанавливает свойство и запускает метод через интерфейс.The Test procedure creates an instance of the class that implements MyInterface, assigns that instance to the testInstance field, sets a property, and runs a method through the interface.

  5. Добавьте код для вызова Test процедуры из Form1 Load процедуры формы запуска:Add code to call the Test procedure from the Form1 Load procedure of your startup form:

    Private Sub Form1_Load(ByVal sender As System.Object,
                           ByVal e As System.EventArgs) Handles MyBase.Load
        Test() ' Test the class.
    End Sub
    
  6. Выполните Test процедуру, нажав клавишу F5.Run the Test procedure by pressing F5. Отображается сообщение «Prop1 имело значение 9».The message «Prop1 was set to 9» is displayed. После нажатия кнопки ОК отображается сообщение «параметр X для Method1 равен 5».After you click OK, the message «The X parameter for Method1 is 5» is displayed. Нажмите кнопку ОК, после чего появится сообщение «обработчик событий захватил событие».Click OK, and the message «The event handler caught the event» is displayed.

См. также разделSee also

Оператор Interface — Visual Basic



  • Чтение занимает 5 мин

В этой статье

Объявляет имя интерфейса и вводит определения членов, содержащихся в интерфейсе.Declares the name of an interface and introduces the definitions of the members that the interface comprises.

СинтаксисSyntax

[ <attributelist> ] [ accessmodifier ] [ Shadows ] _  
Interface name [ ( Of typelist ) ]  
    [ Inherits interfacenames ]  
    [ [ modifiers ] Property membername ]  
    [ [ modifiers ] Function membername ]  
    [ [ modifiers ] Sub membername ]  
    [ [ modifiers ] Event membername ]  
    [ [ modifiers ] Interface membername ]  
    [ [ modifiers ] Class membername ]  
    [ [ modifiers ] Structure membername ]  
End Interface  

КомпонентыParts

ТерминTerm ОпределениеDefinition
attributelist Необязательный элемент.Optional. См. список атрибутов.See Attribute List.
accessmodifier Необязательный элемент.Optional. Может применяться один из перечисленных ниже типов.Can be one of the following:

— Закрытый- Public
— От- Protected
— Объявление- Friend
— Личному- Private
— Защищенный дружественный- Protected Friend
— Частный защищенный- Private Protected

См. раздел уровни доступа в Visual Basic.See Access levels in Visual Basic.

Shadows Необязательный элемент.Optional. См. раздел Shadows.See Shadows.
name Обязательный элемент.Required. Имя этого интерфейса.Name of this interface. См. раздел Declared Element Names.See Declared Element Names.
Of Необязательный элемент.Optional. Указывает, что это универсальный интерфейс.Specifies that this is a generic interface.
typelist Требуется, если используется ключевое слово of .Required if you use the Of keyword. Список параметров типа для этого интерфейса.List of type parameters for this interface. При необходимости каждый параметр типа можно объявить как Variant с помощью In Out модификаторов и.Optionally, each type parameter can be declared variant by using In and Out generic modifiers. См. список типов.See Type List.
Inherits Необязательный элемент.Optional. Указывает, что этот интерфейс наследует атрибуты и члены другого интерфейса или интерфейсов.Indicates that this interface inherits the attributes and members of another interface or interfaces. См. раздел оператор Inherits.See Inherits Statement.
interfacenames Требуется, если используется Inherits оператор.Required if you use the Inherits statement. Имена интерфейсов, из которых наследуется этот интерфейс.The names of the interfaces from which this interface derives.
modifiers Необязательный элемент.Optional. Соответствующие модификаторы для определяемого члена интерфейса.Appropriate modifiers for the interface member being defined.
Property Необязательный элемент.Optional. Определяет свойство, которое является членом интерфейса.Defines a property that is a member of the interface.
Function Необязательный элемент.Optional. Определяет Function процедуру, которая является членом интерфейса.Defines a Function procedure that is a member of the interface.
Sub Необязательный элемент.Optional. Определяет Sub процедуру, которая является членом интерфейса.Defines a Sub procedure that is a member of the interface.
Event Необязательный элемент.Optional. Определяет событие, которое является членом интерфейса.Defines an event that is a member of the interface.
Interface Необязательный элемент.Optional. Определяет интерфейс, который является вложенным в этот интерфейс.Defines an interface that is a nested within this interface. Определение вложенного интерфейса должно завершаться End Interface оператором.The nested interface definition must terminate with an End Interface statement.
Class Необязательный элемент.Optional. Определяет класс, который является членом интерфейса.Defines a class that is a member of the interface. Определение класса члена должно завершаться End Class оператором.The member class definition must terminate with an End Class statement.
Structure Необязательный элемент.Optional. Определяет структуру, которая является членом интерфейса.Defines a structure that is a member of the interface. Определение структуры элемента должно завершаться End Structure оператором.The member structure definition must terminate with an End Structure statement.
membername Требуется для каждого свойства, процедуры, события, интерфейса, класса или структуры, определенной как член интерфейса.Required for each property, procedure, event, interface, class, or structure defined as a member of the interface. Имя элемента.The name of the member.
End Interface Завершает Interface Определение.Terminates the Interface definition.

RemarksRemarks

Интерфейс определяет набор элементов, таких как свойства и процедуры, которые могут реализовывать классы и структуры.An interface defines a set of members, such as properties and procedures, that classes and structures can implement. Интерфейс определяет только подписи членов, а не их внутреннюю работу.The interface defines only the signatures of the members and not their internal workings.

Класс или структура реализует интерфейс путем предоставления кода для каждого члена, определенного интерфейсом.A class or structure implements the interface by supplying code for every member defined by the interface. Наконец, когда приложение создает экземпляр из этого класса или структуры, объект существует и выполняется в памяти.Finally, when the application creates an instance from that class or structure, an object exists and runs in memory. Дополнительные сведения см. в разделе объекты и классы и интерфейсы.For more information, see Objects and Classes and Interfaces.

Можно использовать Interface только на уровне пространства имен или модуля.You can use Interface only at namespace or module level. Это означает, что контекст объявления для интерфейса должен быть исходным файлом, пространством имен, классом, структурой, модулем или интерфейсом и не может быть процедурой или блоком.This means the declaration context for an interface must be a source file, namespace, class, structure, module, or interface, and cannot be a procedure or block. Дополнительные сведения см. в разделе Контексты объявления и уровни доступа по умолчанию.For more information, see Declaration Contexts and Default Access Levels.

Интерфейсы по умолчанию имеют доступ Friend .Interfaces default to Friend access. Уровни доступа можно изменить с помощью модификаторов доступа.You can adjust their access levels with the access modifiers. Дополнительные сведения см. в разделе уровни доступа в Visual Basic.For more information, see Access levels in Visual Basic.

ПравилаRules

  • Вложенные интерфейсы.Nesting Interfaces. Можно определить один интерфейс в другом.You can define one interface within another. Внешний интерфейс называется содержащим интерфейсом, а внутренний интерфейс называется вложенным интерфейсом.The outer interface is called the containing interface, and the inner interface is called a nested interface.

  • Объявление члена.Member Declaration. При объявлении свойства или процедуры в качестве члена интерфейса определяется только сигнатура этого свойства или процедуры.When you declare a property or procedure as a member of an interface, you are defining only the signature of that property or procedure. Это включает тип элемента (свойство или процедура), его параметры и типы параметров, а также тип возвращаемого значения.This includes the element type (property or procedure), its parameters and parameter types, and its return type. В связи с этим определение элемента использует только одну строку кода, а завершающие операторы, такие как End Function или End Property , недопустимы в интерфейсе.Because of this, the member definition uses only one line of code, and terminating statements such as End Function or End Property are not valid in an interface.

    Напротив, при определении перечисления или структуры или вложенного класса или интерфейса необходимо включить их члены данных.In contrast, when you define an enumeration or structure, or a nested class or interface, it is necessary to include their data members.

  • Модификаторы членов.Member Modifiers. Нельзя использовать модификаторы доступа при определении членов модуля, а также нельзя указывать Общие или модификаторы процедур, кроме перегрузок.You cannot use any access modifiers when defining module members, nor can you specify Shared or any procedure modifier except Overloads. Можно объявить любой член с тенями, и можно использовать значение по умолчанию при определении свойства, а также ReadOnly или WriteOnly.You can declare any member with Shadows, and you can use Default when defining a property, as well as ReadOnly or WriteOnly.

  • Цепочк.Inheritance. Если интерфейс использует инструкцию Inherits, можно указать один или несколько базовых интерфейсов.If the interface uses the Inherits Statement, you can specify one or more base interfaces. Можно наследовать от двух интерфейсов, даже если каждый из них определяет член с тем же именем.You can inherit from two interfaces even if they each define a member with the same name. В этом случае реализующий код должен использовать уточнение имени, чтобы указать, какой член он реализует.If you do so, the implementing code must use name qualification to specify which member it is implementing.

    Интерфейс не может наследовать от другого интерфейса с более узким уровнем доступа.An interface cannot inherit from another interface with a more restrictive access level. Например, Public интерфейс не может наследовать от Friend интерфейса.For example, a Public interface cannot inherit from a Friend interface.

    Интерфейс не может наследовать от вложенного в него интерфейса.An interface cannot inherit from an interface nested within it.

  • Реализации.Implementation. Если класс использует оператор Implements для реализации этого интерфейса, он должен реализовать каждый член, определенный в интерфейсе.When a class uses the Implements statement to implement this interface, it must implement every member defined within the interface. Кроме того, каждая сигнатура в коде реализации должна точно соответствовать соответствующей сигнатуре, определенной в этом интерфейсе.Furthermore, each signature in the implementing code must exactly match the corresponding signature defined in this interface. Однако имя члена в коде реализации не обязательно соответствует имени члена, как определено в интерфейсе.However, the name of the member in the implementing code does not have to match the member name as defined in the interface.

    Когда класс реализует процедуру, он не может обозначать процедуру как Shared .When a class is implementing a procedure, it cannot designate the procedure as Shared.

  • Свойство по умолчанию.Default Property. Интерфейс может указывать не более одного свойства в качестве свойства по умолчанию, на которое можно ссылаться без использования имени свойства.An interface can specify at most one property as its default property, which can be referenced without using the property name. Вы указываете такое свойство, объявляя его с помощью модификатора по умолчанию .You specify such a property by declaring it with the Default modifier.

    Обратите внимание, что это означает, что интерфейс может определить свойство по умолчанию только в том случае, если оно наследует None.Notice that this means that an interface can define a default property only if it inherits none.

ПоведениеBehavior

  • Уровень доступа.Access Level. Все члены интерфейса неявно имеют открытый доступ.All interface members implicitly have Public access. Нельзя использовать модификатор доступа при определении элемента.You cannot use any access modifier when defining a member. Однако класс, реализующий интерфейс, может объявить уровень доступа для каждого реализованного члена.However, a class implementing the interface can declare an access level for each implemented member.

    Если экземпляр класса назначается переменной, уровень доступа его членов может зависеть от того, является ли тип данных переменной базовым интерфейсом или реализующим классом.If you assign a class instance to a variable, the access level of its members can depend on whether the data type of the variable is the underlying interface or the implementing class. Это показано в следующем примере.The following example illustrates this.

    Public Interface IDemo
        Sub DoSomething()
    End Interface
    Public Class implementIDemo
        Implements IDemo
        Private Sub DoSomething() Implements IDemo.DoSomething
        End Sub
    End Class
    Dim varAsInterface As IDemo = New implementIDemo()
    Dim varAsClass As implementIDemo = New implementIDemo()
    

    При доступе к членам класса через varAsInterface все они имеют общий доступ.If you access class members through varAsInterface, they all have public access. Однако при доступе к членам с помощью varAsClass Sub процедура doSomething имеет закрытый доступ.However, if you access members through varAsClass, the Sub procedure doSomething has private access.

  • Которых.Scope. Областью действия интерфейса является пространство имен, класс, структура или модуль.An interface is in scope throughout its namespace, class, structure, or module.

    Областью действия каждого члена интерфейса является весь интерфейс.The scope of every interface member is the entire interface.

  • Контролиру.Lifetime. Интерфейс сам по себе не имеет времени существования и не выполняет его члены.An interface does not itself have a lifetime, nor do its members. Когда класс реализует интерфейс и объект создается как экземпляр этого класса, объект имеет время существования в приложении, в котором оно выполняется.When a class implements an interface and an object is created as an instance of that class, the object has a lifetime within the application in which it is running. Дополнительные сведения см. в разделе «время существования» в операторе Class.For more information, see «Lifetime» in Class Statement.

ПримерExample

В следующем примере оператор используется Interface для определения интерфейса с именем thisInterface , который должен быть реализован с помощью Property оператора и Function оператора.The following example uses the Interface statement to define an interface named thisInterface, which must be implemented with a Property statement and a Function statement.

Public Interface thisInterface
    Property ThisProp(ByVal thisStr As String) As Char
    Function ThisFunc(ByVal thisInt As Integer) As Integer
End Interface

Обратите внимание, что Property Function инструкции и не представляют блоки, End Property которые заканчиваются и End Function находятся внутри интерфейса.Note that the Property and Function statements do not introduce blocks ending with End Property and End Function within the interface. Интерфейс определяет только сигнатуры его членов.The interface defines only the signatures of its members. Полные Property блоки и Function появятся в классе, реализующем интерфейс thisInterface .The full Property and Function blocks appear in a class that implements thisInterface.

См. такжеSee also

Справка по пользовательскому интерфейсу Visual Basic



  • Чтение занимает 2 мин

В этой статье

В этом разделе также содержатся элементы пользовательского интерфейса редактора Visual Basic, такие как команды, диалоговые окна, окна и панели инструментов.This section also includes user interface elements of the Visual Basic Editor, such as commands, dialog boxes, windows, and toolbars.

Примечание

Хотите создавать решения, которые расширяют возможности Office на разнообразных платформах?Interested in developing solutions that extend the Office experience across multiple platforms? Ознакомьтесь с новой моделью надстроек Office.Check out the new Office Add-ins model. У надстроек Office мало места по сравнению с надстройками и решениями VSTO, которые можно создавать с помощью практически любой технологии веб-программирования, например HTML5, JavaScript, CSS3 и XML.Office Add-ins have a small footprint compared to VSTO Add-ins and solutions, and you can build them by using almost any web programming technology, such as HTML5, JavaScript, CSS3, and XML.

См. такжеSee also

Поддержка и обратная связьSupport and feedback

Есть вопросы или отзывы, касающиеся Office VBA или этой статьи?Have questions or feedback about Office VBA or this documentation? Руководство по другим способам получения поддержки и отправки отзывов см. в статье Поддержка Office VBA и обратная связь.Please see Office VBA support and feedback for guidance about the ways you can receive support and provide feedback.



Создание вариативных универсальных интерфейсов — Visual Basic



  • Чтение занимает 4 мин

В этой статье

Параметры универсального типа можно объявить в интерфейсах как ковариантные или контравариантные.You can declare generic type parameters in interfaces as covariant or contravariant. Ковариация позволяет методам интерфейса иметь тип возвращаемого значения, степень наследования которого больше, чем указано в параметрах универсального типа.Covariance allows interface methods to have more derived return types than that defined by the generic type parameters. Контравариантность позволяет методам интерфейса иметь типы аргументов, степень наследования которых меньше, чем указано в параметре универсального типа.Contravariance allows interface methods to have argument types that are less derived than that specified by the generic parameters. Универсальный интерфейс, который имеет ковариантные или контравариантные параметры универсального типа, называется вариантным.A generic interface that has covariant or contravariant generic type parameters is called variant.

Объявление вариантных универсальных интерфейсовDeclaring Variant Generic Interfaces

Вариантные универсальные интерфейсы можно объявить с помощью ключевых слов in и out для параметров универсального типа.You can declare variant generic interfaces by using the in and out keywords for generic type parameters.

Важно!

ByRefпараметры в Visual Basic не могут быть вариантными.ByRef parameters in Visual Basic cannot be variant. Типы значений также не поддерживают вариативность.Value types also do not support variance.

Для объявления ковариантного параметра универсального типа можно использовать ключевое слово out.You can declare a generic type parameter covariant by using the out keyword. Ковариантный тип должен удовлетворять следующим условиям:The covariant type must satisfy the following conditions:

  • Тип используется только в качестве типа значения, возвращаемого методами интерфейса, и не используется в качестве типа аргументов метода.The type is used only as a return type of interface methods and not used as a type of method arguments. Это показано в следующем примере, в котором тип R объявлен ковариантным.This is illustrated in the following example, in which the type R is declared covariant.

    Interface ICovariant(Of Out R)
        Function GetSomething() As R
        ' The following statement generates a compiler error.
        ' Sub SetSomething(ByVal sampleArg As R)
    End Interface
    

    Существует одно исключение из данного правила.There is one exception to this rule. Если в качестве параметра метода используется контравариантный универсальный делегат, этот тип можно использовать в качестве параметра универсального типа для этого делегата.If you have a contravariant generic delegate as a method parameter, you can use the type as a generic type parameter for the delegate. Это продемонстрировано ниже на примере типа R.This is illustrated by the type R in the following example. Дополнительные сведения см. в разделе вариативность в делегатах (Visual Basic) и Использование вариативности для универсальных делегатов Func и Action (Visual Basic).For more information, see Variance in Delegates (Visual Basic) and Using Variance for Func and Action Generic Delegates (Visual Basic).

    Interface ICovariant(Of Out R)
        Sub DoSomething(ByVal callback As Action(Of R))
    End Interface
    
  • Тип не используется в качестве универсального ограничения для методов интерфейса.The type is not used as a generic constraint for the interface methods. Это демонстрируется в следующем примере кода.This is illustrated in the following code.

    Interface ICovariant(Of Out R)
        ' The following statement generates a compiler error
        ' because you can use only contravariant or invariant types
        ' in generic constraints.
        ' Sub DoSomething(Of T As R)()
    End Interface
    

Для объявления контравариантного параметра универсального типа можно использовать ключевое слово in.You can declare a generic type parameter contravariant by using the in keyword. Контравариантный тип можно использовать только в качестве типа аргументов метода, но не в качестве типа значения, возвращаемого методами интерфейса.The contravariant type can be used only as a type of method arguments and not as a return type of interface methods. Контравариантный тип можно также использовать для универсальных ограничений.The contravariant type can also be used for generic constraints. В следующем примере кода показано объявление контравариантного интерфейса и использование универсального ограничения для одного из его методов.The following code shows how to declare a contravariant interface and use a generic constraint for one of its methods.

Interface IContravariant(Of In A)
    Sub SetSomething(ByVal sampleArg As A)
    Sub DoSomething(Of T As A)()
    ' The following statement generates a compiler error.
    ' Function GetSomething() As A
End Interface

Кроме того, можно реализовать поддержку ковариации и контравариации в одном интерфейсе, но для разных параметров типа, как показано в следующем примере кода.It is also possible to support both covariance and contravariance in the same interface, but for different type parameters, as shown in the following code example.

Interface IVariant(Of Out R, In A)
    Function GetSomething() As R
    Sub SetSomething(ByVal sampleArg As A)
    Function GetSetSomething(ByVal sampleArg As A) As R
End Interface

В Visual Basic нельзя объявлять события в вариативных интерфейсах без указания типа делегата.In Visual Basic, you can’t declare events in variant interfaces without specifying the delegate type. Кроме того, вариантный интерфейс не может иметь вложенные классы, перечисления или структуры, но может иметь вложенные интерфейсы.Also, a variant interface can’t have nested classes, enums, or structures, but it can have nested interfaces. Это демонстрируется в следующем примере кода.This is illustrated in the following code.

Interface ICovariant(Of Out R)
    ' The following statement generates a compiler error.
    ' Event SampleEvent()
    ' The following statement specifies the delegate type and
    ' does not generate an error.
    Event AnotherEvent As EventHandler

    ' The following statements generate compiler errors,
    ' because a variant interface cannot have
    ' nested enums, classes, or structures.

    'Enum SampleEnum : test : End Enum
    'Class SampleClass : End Class
    'Structure SampleStructure : Dim value As Integer : End Structure

    ' Variant interfaces can have nested interfaces.
    Interface INested : End Interface
End Interface

Реализация вариантных универсальных интерфейсовImplementing Variant Generic Interfaces

Для реализации вариантных универсальных интерфейсов в классах используется тот же синтаксис, что и для инвариантных интерфейсов.You implement variant generic interfaces in classes by using the same syntax that is used for invariant interfaces. В следующем примере кода показана реализация ковариантного интерфейса в универсальном классе.The following code example shows how to implement a covariant interface in a generic class.

Interface ICovariant(Of Out R)
    Function GetSomething() As R
End Interface

Class SampleImplementation(Of R)
    Implements ICovariant(Of R)
    Public Function GetSomething() As R _
    Implements ICovariant(Of R).GetSomething
        ' Some code.
    End Function
End Class

Классы, которые реализуют вариантные интерфейсы, являются инвариантными.Classes that implement variant interfaces are invariant. Например, рассмотрим следующий код.For example, consider the following code.

 The interface is covariant.
Dim ibutton As ICovariant(Of Button) =
    New SampleImplementation(Of Button)
Dim iobj As ICovariant(Of Object) = ibutton

' The class is invariant.
Dim button As SampleImplementation(Of Button) =
    New SampleImplementation(Of Button)
' The following statement generates a compiler error
' because classes are invariant.
' Dim obj As SampleImplementation(Of Object) = button

Расширение вариантных универсальных интерфейсовExtending Variant Generic Interfaces

При расширении вариантных универсальных интерфейсов необходимо использовать ключевые слова in и out для явного указания того, поддерживает ли вариативность производный интерфейс.When you extend a variant generic interface, you have to use the in and out keywords to explicitly specify whether the derived interface supports variance. Компилятор не подразумевает вариативность интерфейса, который расширяется.The compiler does not infer the variance from the interface that is being extended. Например, рассмотрим следующие интерфейсы.For example, consider the following interfaces.

Interface ICovariant(Of Out T)
End Interface

Interface IInvariant(Of T)
    Inherits ICovariant(Of T)
End Interface

Interface IExtCovariant(Of Out T)
    Inherits ICovariant(Of T)
End Interface

В Invariant(Of T) интерфейсе параметр универсального типа T является инвариантным, тогда как в IExtCovariant (Of Out T) параметре типа является ковариантным, хотя оба интерфейса расширяют один и тот же интерфейс.In the Invariant(Of T) interface, the generic type parameter T is invariant, whereas in IExtCovariant (Of Out T)the type parameter is covariant, although both interfaces extend the same interface. То же правило применяется к контравариантным параметрам универсального типа.The same rule is applied to contravariant generic type parameters.

Можно создать интерфейс, который расширяет и интерфейс, в котором параметр универсального типа T является ковариантным, и интерфейс, где он является контравариантным, если в расширяемом интерфейсе параметр универсального типа T является инвариантным.You can create an interface that extends both the interface where the generic type parameter T is covariant and the interface where it is contravariant if in the extending interface the generic type parameter T is invariant. Это показано в следующем примере кода.This is illustrated in the following code example.

Interface ICovariant(Of Out T)
End Interface

Interface IContravariant(Of In T)
End Interface

Interface IInvariant(Of T)
    Inherits ICovariant(Of T), IContravariant(Of T)
End Interface

Тем не менее, если параметр универсального типа T объявлен ковариантным в одном интерфейсе, его нельзя объявить контравариантным в расширенном интерфейсе и наоборот.However, if a generic type parameter T is declared covariant in one interface, you cannot declare it contravariant in the extending interface, or vice versa. Это показано в следующем примере кода.This is illustrated in the following code example.

Interface ICovariant(Of Out T)
End Interface

' The following statements generate a compiler error.
' Interface ICoContraVariant(Of In T)
'     Inherits ICovariant(Of T)
' End Interface

Недопущение неоднозначностиAvoiding Ambiguity

При реализации вариантных универсальных интерфейсов вариативность может приводить к неоднозначности.When you implement variant generic interfaces, variance can sometimes lead to ambiguity. Этого следует избегать.This should be avoided.

Например, если вы явно реализуете один вариантный универсальный интерфейс с разными параметрами универсального типа в одном классе, это может создавать неоднозначность.For example, if you explicitly implement the same variant generic interface with different generic type parameters in one class, it can create ambiguity. Компилятор не сообщает об ошибке в данном случае, но и не указывает, какая реализация интерфейса будет выбрана во время выполнения.The compiler does not produce an error in this case, but it is not specified which interface implementation will be chosen at runtime. Это может привести к возникновению неявных ошибок в коде.This could lead to subtle bugs in your code. Рассмотрим следующий пример кода:Consider the following code example.

Примечание

В Option Strict Off Visual Basic создает предупреждение компилятора при возникновении неоднозначной реализации интерфейса.With Option Strict Off, Visual Basic generates a compiler warning when there is an ambiguous interface implementation. В Option Strict On Visual Basic создает ошибку компилятора.With Option Strict On, Visual Basic generates a compiler error.

' Simple class hierarchy.
Class Animal
End Class

Class Cat
    Inherits Animal
End Class

Class Dog
    Inherits Animal
End Class

' This class introduces ambiguity
' because IEnumerable(Of Out T) is covariant.
Class Pets
    Implements IEnumerable(Of Cat), IEnumerable(Of Dog)

    Public Function GetEnumerator() As IEnumerator(Of Cat) _
        Implements IEnumerable(Of Cat).GetEnumerator
        Console.WriteLine("Cat")
        ' Some code.
    End Function

    Public Function GetEnumerator1() As IEnumerator(Of Dog) _
        Implements IEnumerable(Of Dog).GetEnumerator
        Console.WriteLine("Dog")
        ' Some code.
    End Function

    Public Function GetEnumerator2() As IEnumerator _
        Implements IEnumerable.GetEnumerator
        ' Some code.
    End Function
End Class

Sub Main()
    Dim pets As IEnumerable(Of Animal) = New Pets()
    pets.GetEnumerator()
End Sub

В этом примере не указано, каким образом метод pets.GetEnumerator делает выбор между Cat и Dog.In this example, it is unspecified how the pets.GetEnumerator method chooses between Cat and Dog. Это может вызвать проблемы в вашем коде.This could cause problems in your code.

См. также разделSee also

Программирование на Visual Basic.NET, Создание графического интерфейса

Урок из серии  «Программирование на Visual Basic.NET для школьников»

Продолжим изучать систему программирования Visual Basic.NET 2003.

На предыдущем уроке мы настроили среду разработки Visual Studio.NET на язык программирвания Visual Basic.

В этом уроке мы познакомимся с основными инструментами среды разработки  Visual Studio.NET и с  основными этапами создания проектов.

Чтобы познакомится с инструментами  среды разработки, запустим  среду программирования и создадим новый проект.

Создание проекта

  1. Для запуска среды программирования  Visual Studio.Net выполните команду:
    Пуск – Все программы – Microsoft Visual Basic.NET – Microsoft Visual Studio.NET 2003.

    Загрузится Начальная страница Visual Studio.

    На вкладке Проекты, в нижней её части, есть две кнопки, которые предоставляют  возможность открыть существующий проект или создать новый.

  2. Нажмите кнопку Создать проект. Появиться диалоговое окно Создать проект.На левой стороне представлены Типы проектов, на правой показаны так называемые Шаблоны, которые относятся к выбранному типу проекта.

    Для того, чтобы создать приложение  Windows:

    • В списке Типы проектов выберите тип Проекты Visual Basic.
    • В окне Шаблоны выберите шаблон Приложение для Windows.
    • В текстовом поле Имя введите имя проекта
    • В поле Расположение укажите путь для хранения файлов проекта.  Чтобы выбрать папку на диске, можно нажать кнопку Обзор.
    • Нажмите ОК.
  3. Откроется новый созданный проект и на экране отобразится пустая графическая форма Windows (обычно имеющая название Form1), на основе которой вы будите создавать интерфейс для пользователя вашего приложения.Вы видите все основные инструменты среды разработки Visual Studio:
    • Окно формы. Окно будущего приложения.
    • Область элементов. Содержит элементы управления, которые можно использовать для создания интерфейса пользователя.
    • Обозреватель решений. Содержит файлы проекта.
    • Окно Свойства. Отображает свойства текущего объекта

Теперь у нас есть все необходимые инструменты и можно приступить к визуальному проектированию графического интерфейса пользователя.

Визуальное проектирование интерфейса пользователя

После создания проекта открылась наша первая форма.

Форма  это основной объект графического интерфейса (окно приложения), на её основе мы будем создавать интерфейс для пользователя.

Вы можете изменить размеры представленной формы и другие её свойства.

Свойства формы отображаются в окне Свойства в правой части среды разработки. Эти свойства разделены на группы и их довольно много. Некоторые свойства имеют свои подсвойства. Например, свойство Font (Шрифт) имеет подсвойства: Name,  Size и др.

Изменением этих свойств мы можем полностью видоизменить данную форму. Например, изменением свойства BackColor мы можем изменить цвет фона этой формы.

Надо отметить, что форма является одним из объектов Visual Basic. На левой стороне в Области элементов содержится перечень  других объектов системы, которые мы можем использовать для визуального проектирования интерфейса пользователя.
Как мы то будем делать?

В названии содержится  слово Visual, которое подсказывает способ, при помощи которого создается графический интерфейс.

Это делается визуально, то есть на глаз..

Программист выбирает элементы управления  из Области элементов Visual Studio и рисует их в нужном месте окна приложения.  Это похоже на то, как создаются простейшие фигуры  в графическом редакторе.

Если Область элементов не видна, то её можно вывести на экран,  выполнив команду Вид — Область элементов.

Давайте установим на Форме,  например, Кнопку (Button).

Для размещения кнопки на форме,  щелкните соответствующую элемент в Области элементов, а затем установите указатель мыши в нужном месте на форме, протяните мышь вниз и вправо.

Появиться серая рамка — это контуры будущей кнопки. Доведите курсор мыши до нужного размера объекта и опустите кнопку мыши. На форме появиться выбранный вами элемент управления с маркерами изменения размера.

Как только элемент управления из панели Область элементов поместили на форму, он превращается в объект, так как уже имеет  набор свойств по умолчанию: цвет, шрифт, местоположение.

Например, элемент управления Button станет объектом Button1 (кнопкой) и будет иметь свойства, которые ему предписаны по умолчанию.

Значения свойств элементов управления можно настраивать (изменить) после их размещения на форме.

Для установки свойств какого-либо объекта необходимо его выделить, щелкнув по нему мышью.  Тогда в окне Свойства отображаются свойства этого объекта, в этом окне их можно будет настраивать.

На форму можно поместить  несколько экземпляров одного класса элементов управления. Например, несколько кнопок, каждая из которых будет иметь свои индивидуальные свойства (надпись, размеры и т.д.).

Для удаления элемента управления достаточно его выделить и нажать клавишу Delete.

После создания проекта программный код для формы и тех элементов управления, которые мы на ней разместили, генерируется автоматически.

Программный код проекта

Давайте посмотрим, какой код Visual Basic автоматически создал для нашей Формы.

Для этого в окне Обозреватель решений нажмите кнопку Посмотреть код. В центральном окне отобразится код, появиться новая вкладка Form1.vb.

Теперь с помощью вкладок Form1.vb[Design] и Form1.vb можно будет перемещаться с Формы в соответствующий код, и обратно.

За пиктограммой со знаком «+» скрывается свертываемый блок кода, который называется «Код, автоматически созданный конструктором форм Windows».

Этот блок кода находится между командами #Region и #End Region.

Во время визуального проектирования Формы, ввода в неё элементов с панели Область элементов, файл Form.vb будет автоматически дополняться.

И только после этого мы будем записывать наш код, предназначенный для решения наших задач.

Таким образом, в создание проекта можно выделить несколько последовательных этапов.

Этапы создания проекта на Visual Basic.NET

Для создания проекта с самого начала, необходимо выполнить четыре  основных шага:

  1. Создать новый проект.
  2. Создать графический интерфейс пользователя c помощью элементов управления из Области элементов Visual Studio.
  3. Настроить свойства этих элементов управления.
  4. Написать программный код, который определит, что будет делать ваша  программа.

В этом уроке мы познакомились с основными инструментами разработки в среде Visual Studio и с  основными этапами создания проектов.

В следующем уроке мы создадим наш первый проект.

Следующий урок: Создание первого проекта в Visual Basic.NET

Интерфейсы — Visual Basic | Документы Microsoft

  • Чтение занимает 4 мин

В этой статье

Интерфейсы определяют свойства, методы и события, которые можно реализовать в классах. Интерфейсы определяют свойства, методы и события, которые могут реализовывать классы. Интерфейсы позволяют определить возможности в виде сетевых средств взаимодействия, методов и событий.Это снижает число проблем совместимости, так как можно создать усовершенствованные реализации интерфейса без изменений существующего кода. Интерфейсы позволяют определять функции как небольшие группы тесно связанных свойств, методов и событий; это уменьшает проблемы совместимости, поскольку вы можете разрабатывать расширенные реализации для своих интерфейсов, не подвергая опасности существующий код. Вы можете добавлять новые функции в любое время с помощью дополнительных интерфейсов и реализаций. Вы можете добавлять новые функции в любое время, разрабатывая дополнительные интерфейсы и реализации.

Далее представлены другие причины, из-за которых вам может потребоваться использовать интерфейс вместо наследования классов. Существует несколько других причин, по которым вы можете захотеть использовать интерфейсы вместо наследования классов:

  • Интерфейсы более удобны в ситуациях, в которых используются различные возможности. Интерфейсы лучше подходят для ситуаций, в которых вашим приложениям требуется много, возможно, несвязанных типов объектов для обеспечения определенных функций.

  • Интерфейсы более гибкие, чем базовые классы, так как вы можете определить одну работу, в которой можно реализовать несколько интерфейсов. Интерфейсы более гибкие, чем базовые классы, потому что вы можете определить одну реализацию, которая может реализовать несколько интерфейсов.

  • Интерфейсы предпочтительнее в случаях, когда нет необходимости наследовать проигрыш базового класса. Интерфейсы лучше использовать в ситуациях, когда вам не нужно наследовать реализацию от базового класса.

  • Интерфейсы полезны, когда невозможно использовать наследование класса. Интерфейсы полезны, когда вы не можете использовать наследование классов. Например, структуры не могут наследовать от классов, но они могут реализовывать интерфейсы.

  • Объявление интерфейсов

Объявление интерфейсов

Определения интерфейса заключаются в операторы Интерфейс и Конечный интерфейс .Определения интерфейсов содержатся в операторах Interface и End Interface . После оператора Интерфейс можно добавить необязательный оператор Наследует , в котором указывается один или несколько наследуемых интерфейсов. Следуя оператору Интерфейс , вы можете добавить необязательный оператор Наследует , который перечисляет один или несколько унаследованных интерфейсов. Операторы Inherits должны предшествовать всем другим операторам в объявлении, за исключением комментариев.Операторы Inherits должны предшествовать всем другим операторам в объявлении, кроме комментариев. Остальными операторами в определении интерфейса должны быть Event , Sub , Function , Property , Interface , Class , Structure и Enum . Остальные операторы в определении интерфейса должны быть Event , Sub , Функция , Свойство , Интерфейс , Class , Structure и Enum инструкции.Интерфейсы не могут содержать код реализаций или операторы, связанные с кодом реализации, такие как End Sub и End Property . Интерфейсы не могут содержать какой-либо код реализации или операторы, связанные с кодом реализации, такие как End Sub или End Property .

«Друг «, но также их можно явно объявить как Общественный или Друг .В пространстве имен операторами интерфейса по умолчанию являются Friend , но они также могут быть явно объявлены как Public или Friend . Интерфейсы, в классах, модулях, интерфейсах и структурах по умолчанию объявлены как Public , но их также можно явно объявить как Public , Friend , Protected и Private . Интерфейсы, определенные внутри классов, модулей, интерфейсов , и структуры — Public по умолчанию, но они также могут быть явно объявлены как Public , Friend , Protected или Private .

Примечание

Ключевое слово

Shadows может применяться ко всем элементам интерфейса. Ключевое слово Shadows может применяться ко всем элементам интерфейса. Ключевое слово Перегрузка слово может быть к операм Sub , Функция , и Свойство , объявленным в определении. Ключевое слово Overloads может быть применено к Sub , Function и Property операторам объявлен в определении интерфейса.Кроме того, операторы Свойство может содержать модификаторы Default , ReadOnly и WriteOnly . Кроме того, операторы Property могут иметь модификаторы Default , ReadOnly или WriteOnly . Другие модификаторы ( Public , Private , Friend , Protected , Shared , Overrides , MustOverride и Overridable ) не разрешены.Ни один из других модификаторов — Public , Private , Friend , Protected , Shared , Override , MustOverride или Overridable — не разрешен. Дополнительные сведения см. в разделе Контексты объявления и уровни доступа по умолчанию. Для получения дополнительной информации см. Контексты объявления и Уровни доступа по умолчанию.

Например, в следующем примере кода используется интерфейс с одной функцией, одним своим действием и одним событием.Например, следующий код определяет интерфейс с одной функцией, одним свойством и одним событием.

  Интерфейс IAsset
    Событие ComistedChange (ByVal Success As Boolean)
    Разделение собственности () как строка
    Функция GetID () как целое число
Конечный интерфейс
  

Реализация интерфейсов Реализация интерфейсов

Зарезервированное слово Visual Basic Implements используется двумя способами. Зарезервированное слово Visual Basic Implements используется двумя способами.Оператор реализует означает, что класс или структура реализуют интерфейс. Реализует оператор означает, что класс или структура реализует интерфейс. Ключевое слово Реализует указывает, что элемент класса или структуры реализует определенный элемент интерфейса. Реализует Ключевое слово означает, что член класса или член структуры реализует определенный член интерфейса.

Оператор ImplementsImplements Заявление

Если класс или структура реализует один или несколько интерфейсов, они должны содержать оператор Реализует сразу после оператора Class или Structure .Если класс или структура реализует один или несколько интерфейсов, он должен включать оператор Implements сразу после оператора Class или Structure . Оператору Реализует требуется разделенный запятыми список интерфейсов, которые должны быть реализованы с помощью класса. Оператору Реализует требуется список интерфейсов, разделенных запятыми, которые должны быть реализованы классом. Структура или класс должны реализовать все элементы интерфейса с помощью ключевого слова Реализует .Класс или структура должны реализовывать все члены интерфейса с использованием ключевого слова Implements .

Ключевое слово ImplementsImplements Ключевое слово

Ключевому слову Implements требуется разделенный запятыми список элементов интерфейса, которые необходимо реализовать. Ключевое слово Implements требует, чтобы был реализован список элементов интерфейса, разделенных запятыми. Как правило, указывается только один элемент интерфейса, но можно указать несколько элементов.Обычно указывается только один член интерфейса, но вы можете указать несколько членов. В спецификации элемента интерфейса должно быть указано, что в операторе реализуется внутри класса, точки и имени реализуемой функции-члена, свойства или события. Спецификация элемента интерфейса состоит из имени интерфейса, которое должно быть указано в операторе реализации. внутри класса; Период; и имя функции-члена, свойства или события, которые необходимо реализовать.Имя члена, реализующий член интерфейса, может использовать любой допустимый идентификатор, и оно не ограничивается InterfaceName_MethodName соглашением, используемым в более ранней версии Visual Basic. Имя члена, реализующего член интерфейса, может использовать любой допустимый идентификатор, но это не так. ограничено соглашением InterfaceName_MethodName , используемым в более ранних версиях Visual Basic.

Например, в следующем примере кода показано, как объявить подпрограмму с именем Sub1 , в которой реализуется метод интерфейса: Например, следующий код показывает, как объявить подпрограмму с именем Sub1 , которая реализует метод интерфейса:

  Класс Класс1
    Реализует interfaceclass.interface2

    Sub Sub1 (ByVal i As Integer) Реализует interfaceclass.interface2.Sub1
    Конец подписки
Конец класса
  

Типы параметров и возвращаемые типы реализующего элемента должны соответствовать свойству интерфейса или объявлению элемента в интерфейсе. Наиболее распространенный способ реализации элемента интерфейса — использование элемента с таким же, как у интерфейса, как показано в предыдущем примере.Самый распространенный способ реализовать элемент интерфейса — использовать член, имя которого совпадает с именем интерфейса, как показано в предыдущем примере.

Для объявления реализации метода интерфейса можно использовать любые атрибуты, которые допустимы в объявлении экземпляра метода, включая Перегрузки , Переопределения , Переопределяемые , Общедоступные , Частные , Защищенные , Защищенные друг , Защищенные друг , MustOverride , По умолчанию и Статический .Чтобы объявить реализацию метода интерфейса, вы можете использовать любые атрибуты, допустимые для объявлений метода экземпляра, включая Overloads , Override , Overridable , Public , Private , Protected , Friend , Защищенный друг , MustOverride , По умолчанию и Статический . Атрибут Общий недопустим, поскольку он определяет класс, а не метод экземпляра.Атрибут Shared недопустим, поскольку он определяет класс, а не метод экземпляра.

С помощью реализует , можно также написать один метод, реализует несколько методов, определенных в интерфейсе, как показано в следующем примере: Используя реализует , вы также можете написать один метод, реализующий несколько методов, определенных в интерфейсе, как в следующий пример:

  Класс Класс2
    Реализует I1, I2

    Защищенный Sub M1 () реализует I1.M1, I1.M2, I2.M3, I2.M4
    Конец подписки
Конец класса
  

Закрытый элемент можно использовать для реализации члена интерфейса. Вы можете использовать закрытый член для реализации члена интерфейса. Если закрытый член реализует член интерфейса, этот элемент становится доступен через интерфейс, хотя он недоступен напрямую через переменные класса. Когда закрытый член реализует член интерфейса, этот элемент становится доступным через интерфейс, даже если он недоступен непосредственно в объектные переменные для класса.

Примеры реализации интерфейса Примеры реализации интерфейса

Классы, реализующие интерфейс, должны реализовать все свойства, методы и события. Классы, реализующие интерфейс, должны реализовывать все его свойства, методы и события.

В примере ниже два интерфейса. В следующем примере определены два интерфейса. Второй интерфейс, Interface2 , наследует Interface1 и определяет дополнительное свойство и метод. Второй интерфейс, Interface2 , наследует Interface1 и определяет дополнительное свойство и метод.

  Интерфейс Интерфейс 1
    Sub sub1 (ByVal i как целое число)
Конечный интерфейс

'Демонстрирует наследование интерфейса.
Интерфейс Интерфейс2
    Наследует Interface1
    Sub M1 (ByVal y как целое число)
    ReadOnly Свойство Num () как целое число
Конечный интерфейс
  

В следующем примере реализуется Интерфейс1 , интерфейс, конкретный пример в следующем примере: В следующем примере реализуется Интерфейс1 , интерфейс, определенный в предыдущем примере:

  Открытый класс ImplementationClass1
    Реализует интерфейс1
    Sub Sub1 (ByVal i As Integer) реализует Interface1.sub1
        'Вставьте сюда код для реализации этого метода.
    Конец подписки
Конец класса
  

В последнем примере реализуется Interface2 , включающий метод, унаследованный от Interface1 : последний пример реализует Interface2 , включая метод, унаследованный от Interface1 :

  Открытый класс ImplementationClass2
    Реализует Interface2
    Dim INum как целое число = 0
    Sub sub1 (ByVal i As Integer) Реализует Interface2.sub1
        'Вставьте сюда код, реализующий этот метод.Конец подписки
    Sub M1 (ByVal x As Integer) Реализует Interface2.M1
        'Вставьте сюда код для реализации этого метода.
    Конец подписки

    ReadOnly Свойство Num () как целое число реализует Interface2.Num
        Получить
            Num = INum
        Конец получить
    Конечная собственность
Конец класса
  

Можно реализовать свойство только для чтения со своим действием, доступным для чтения и записи (т. Е. Не нужно объявлять его своим только для чтения в классе реализации). Вы можете реализовать свойство только для чтения со свойством readwrite (то есть вы не должны объявить его только для чтения в классе реализации).В реализации интерфейса должны быть реализованы элементы, которые объявляются интерфейсом, но можно обеспечить дополнительные возможности, например разрешить свойства записи. Реализация интерфейса обещает реализовать по крайней мере те элементы, которые объявляются интерфейсом, но вы можете предложить дополнительные функции, например разрешение вашей собственности быть доступным для записи.

.

Оператор Интерфейс — Visual Basic

  • Чтение занимает 5 мин

В этой статье

Объявляет имя интерфейса и вводит определения элементов, используютсяся в интерфейсе. Объявляет имя интерфейса и вводит определения элементов, входящих в этот интерфейс.

Синтаксис Синтаксис

  [] [модификатор доступа] [Тени] _
Название интерфейса [(Typelist)]
    [Наследует имена интерфейсов]
    [[модификаторы] Имя члена ресурса]
    [[модификаторы] Имя члена функции]
    [[модификаторы] Имя дополнительного члена]
    [[модификаторы] Имя участника мероприятия]
    [[модификаторы] Имя члена интерфейса]
    [[модификаторы] Имя члена класса]
    [[модификаторы] Имя члена структуры]
Конечный интерфейс
  

КомпонентыParts

ТерминTerm Определение Определение
Атрибутелист Необязательный элемент.Необязательный. См. Список атрибутов. См. Список атрибутов.
модификатор доступа Необязательный элемент.Дополнительно. Может быть одним из следующих типов:

— Закрытый- Публичный
— От- Защищенный
— Объявление-Друг
— Личному- Частный
— Защищенный дружественный- Защищенный друг
— Защищенный защищенный- Частный Защищенный

См. раздел уровня доступа в Visual Basic.См. Уровни доступа в Visual Basic.

Тени Необязательный элемент.Дополнительно. См. раздел Тени. См. Тени.
наименование Обязательный элемент.Требуется. Имя этого интерфейса. Название этого интерфейса. См. раздел Объявленные имена элементов. См. Объявленные имена элементов.
из Необязательный элемент.Дополнительно. Указывает, что это универсальный интерфейс.Указывает, что это универсальный интерфейс.
список Требуется, если используется слово of. Требуется, если вы используете ключевое слово Of. Список параметров типа для этого интерфейса. Список параметров типа для этого интерфейса. При необходимости каждый параметр типа можно объявить как Вариант с помощью In Out модификаторов и. По желанию, каждый параметр типа может быть объявлен как вариант с использованием общих модификаторов In, и Out, .См. См. список типов.
Наследует Необязательный элемент.Дополнительно. Указывает, что этот интерфейс наследует атрибуты и члены другого интерфейса или интерфейсов. Указывает, что этот интерфейс наследует атрибуты и члены другого интерфейса или интерфейсов. См. раздел оператор Inherits. См. Заявление о наследовании.
имена интерфейсов Требуется, если используется Наследует оператор.Требуется, если вы используете оператор Inherits . Имена интерфейсов, из которых наследуется этот интерфейс. Имена интерфейсов, от которых наследуется этот интерфейс.
модификаторы Необязательный элемент.Дополнительно. Соответствующие модификаторы для определяемого элемента интерфейса. Соответствующие модификаторы для определяемого члена интерфейса.
Объект Необязательный элемент.Дополнительно. Определяет свойство, которое является членом интерфейса.Определяет свойство, которое является членом интерфейса.
Функция Необязательный элемент.Дополнительно. Определение Функция , которая является элементом интерфейса. Определяет процедуру Функция , которая является членом интерфейса.
Переходник Необязательный элемент.Дополнительно. Определение Sub , которое является элементом интерфейса. Определяет процедуру Sub , которая является членом интерфейса.
Событие Необязательный элемент.Дополнительно. Определяет событие, которое является членом интерфейса. Определяет событие, которое является членом интерфейса.
Интерфейс Необязательный элемент.Дополнительно. Определяет интерфейс, который является вложенным в этот интерфейс. Определяет интерфейс, вложенный в этот интерфейс. Определение вложенного интерфейса должно завершаться End Interface оператором.Определение вложенного интерфейса должно заканчиваться оператором End Interface .
Класс Необязательный элемент.Дополнительно. Определение класса, который является членом интерфейса. Определяет класс, который является членом интерфейса. Определение класса члена должно завершиться End Class оператором. Определение класса члена должно заканчиваться оператором End Class .
Конструкция Необязательный элемент.Необязательный. Определяет структуру, которая является членом интерфейса. Определяет структуру, которая является членом интерфейса. Определение структуры элемента должно завершиться End Structure оператором. Определение структуры элемента должно заканчиваться оператором End Structure .
член Требуется для каждого свойства, процедуры, события, интерфейса, класса или структуры, определенного как член интерфейса. Требуется для каждого свойства, процедуры, события, интерфейса, класса или структуры, определенных как член интерфейса.Имя элемента — имя участника.
Конечный интерфейс Завершает Интерфейс Определение. Прекращает определение Интерфейс .

Замечания Замечания

Интерфейс определяет набор элементов, таких как свойства и процедуры, которые могут реализовывать классы и структуры. Интерфейс определяет набор членов, таких как свойства и процедуры, которые классы и структуры могут реализовать.Интерфейс определяет только подписи членов, а не их внутреннюю работу. Интерфейс определяет только подписи участников, а не их внутреннюю работу.

Класс или структура реализует интерфейс предложения кода для каждого члена, определенного интерфейса. Класс или структура реализует интерфейс, предоставляя код для каждого члена, определенного интерфейсом. Наконец, когда приложение создает экземпляр из этого класса или создается объект и выполняется в памяти.Наконец, когда приложение создает экземпляр из этого класса или структуры, объект существует и запускается в памяти. Дополнительные сведения см. в разделе объекты и классы и интерфейсы. Для получения дополнительной информации см. Объекты, Классы и Интерфейсы.

Можно использовать Интерфейс только на уровне пространства имен или модуля. Вы можете использовать Интерфейс только на уровне пространства имен или модуля. Это означает, что контекст объявления для интерфейса должен быть исходным пространством имен, классом, структурой, модулем или интерфейсом и не может быть процедурой или блоком.Это означает, что контекст объявления для интерфейса должен быть исходным файлом, пространством имен, классом, структурой, модулем или интерфейсом и не может быть процедурой или блоком. Дополнительные сведения см. в разделе Контексты объявления и уровни доступа по умолчанию. Для получения дополнительной информации см. Контексты объявления и Уровни доступа по умолчанию.

Интерфейсы по умолчанию имеют доступ Друг. Интерфейсы по умолчанию для доступа Друга. Уровни доступа можно изменить с помощью модификаторов доступа. Вы можете настроить их уровни доступа с помощью модификаторов доступа.Дополнительные сведения см. в разделе уровней доступа в Visual Basic. Подробнее см. Уровни доступа в Visual Basic.

Правила

  • Вложенные интерфейсы. Вложенные интерфейсы. Можно определить один интерфейс в другом. Можно определить один интерфейс в другом. Внешний называется встроенный интерфейс , внутренний интерфейс вложенный интерфейс . Внешний интерфейс называется , содержащий интерфейс , а внутренний интерфейс называется вложенным интерфейсом .

  • Объявление члена. Заявление участника. При объявлении свойств или процедур в качестве элемента интерфейса определяется только сигнатура этого свойства или процедуры. Когда вы объявляете свойство или процедуру как член интерфейса, вы определяете только подпись этого свойства или процедуры. Это включает тип элемента (свойство или процедура), его параметры и типы параметров, а также типовые возвращаемые значения.Сюда входит тип элемента (свойство или процедура), его параметры и типы параметров, а также тип возвращаемого значения. В связи с этим определением элемента используются только одну строку кода, такие как End Function или End Property , недопустимы в интерфейсе. Из-за этого в определении элемента используется только одна строка кода и завершающие операторы, такие как как Конечная функция или Конечное свойство недопустимы в интерфейсе.

    Напротив, при определении структуры или вложенного класса или интерфейса необходимо включить их члены.Напротив, когда вы определяете перечисление или структуру, или вложенный класс или интерфейс, необходимо включать их элементы данных.

  • Модификаторы членов. Модификаторы элементов. Нельзя использовать модификаторы доступа при определении модуля, а также нельзя указывать Общие или модификаторы процедур, кроме перегрузок. Вы не можете использовать какие-либо модификаторы доступа при определении членов модуля, а также не можете указать общий или любой модификатор процедуры, кроме перегрузок.Можно объявить любой член с тенями, и можно использовать значение по умолчанию при определении свойств, а также ReadOnly или WriteOnly. Вы можете объявить любой член с тенями, и вы можете использовать Default при определении свойства, а также ReadOnly или WriteOnly.

  • Цепочк. Наследование. Если интерфейс использует инструкцию Inherits, можно указать один или несколько базовых интерфейсов. Если интерфейс использует оператор Inherits, вы можете указать один или несколько базовых интерфейсов.Можно наследовать от двух интерфейсов, даже если каждый из них определяет член с тем же именем. Вы можете наследовать от двух интерфейсов, даже если каждый из них определяет член с тем же именем. В этом случае реализующий код должен использовать уточнение имени, чтобы указать какой член он реализует.Если вы это сделаете, реализующий код должен использовать уточнение имени, чтобы указать, какой член он реализует.

    Интерфейс не может наследовать другой интерфейс с более узким уровнем доступа. Интерфейс не может наследовать от другого интерфейса с более ограниченным уровнем доступа.Например, Public интерфейс не может наследовать от интерфейса Friend . Например, интерфейс Public не может наследовать от интерфейса Friend .

    Интерфейс не может наследовать от вложенного в него интерфейса. Интерфейс не может наследовать от интерфейса, вложенного в него.

  • Реализации. Реализация. Если класс использует оператор реализации для реализации этого интерфейса, он должен реализовать член, определенный в интерфейсе.Когда класс использует оператор Implements для реализации этого интерфейса, он должен реализовывать каждый член, определенный в интерфейсе. Кроме того, каждая сигнатура в коде реализации должна соответствовать определенному в этом интерфейсе сигнатуре. Кроме того, каждая сигнатура в коде реализации должна точно соответствовать соответствующей сигнатуре, определенной в этом интерфейсе. Однако имя члена в коде реализации не обязательно соответствует имени члена, как определено в интерфейсе. Однако имя члена в коде реализации не обязательно должно совпадать с именем члена, как определено в интерфейсе.

    Когда класс реализует условия, он не может обозначать как Shared . Когда класс реализует процедуру, он не может обозначить процедуру как Shared .

  • Свойство по умолчанию. Свойство по умолчанию. Интерфейс может указывать не более одного свойства в качестве свойств по умолчанию , которое можно ссылаться без использования свойств имени. Интерфейс может указывать не более одного свойства в качестве своего свойства по умолчанию , на которое можно ссылаться без использования имени свойства.Вы указываете такое свойство, объявляя его с помощью модификатора по умолчанию. Вы указываете такое свойство, объявляя его с помощью модификатора Default.

    Обратите внимание, что интерфейс может определить свойство по умолчанию только в том случае, если оно наследует None. Обратите внимание, что это означает, что интерфейс может определять свойство по умолчанию, только если он не наследует ничего.

Поведение

Поведение

  • Уровень доступа. Уровень доступа. Все члены интерфейса неявно имеют открытый доступ. Все члены интерфейса неявно имеют открытый доступ. Нельзя использовать модификатор доступа при определении элемента. При определении элемента нельзя использовать модификаторы доступа. Однако класс, реализующий интерфейс, может объявить уровень доступа для каждого реализованного члена. Однако класс, реализующий интерфейс, может объявить уровень доступа для каждого реализованного члена.

    Если экземпляр класса назначается стандартным классом доступа, является ли он типовым базовым интерфейсом или реализующим классом.Если вы назначаете экземпляр класса переменной, уровень доступа его членов может зависеть от того, является ли тип данных переменной базовым интерфейсом или реализующим классом. Это показано в следующем примере.

      Открытый интерфейс IDemo
        Sub DoSomething ()
    Конечный интерфейс
    Открытый класс implementationIDemo
        Реализует IDemo
        Private Sub DoSomething () реализует IDemo.DoSomething
        Конец подписки
    Конец класса
    Dim varAsInterface As IDemo = New implementationIDemo ()
    Dim varAsClass As ImplementIDemo = Новая реализация IDemo ()
      

    При доступе к группе через varAsInterface все они имеют общий доступ.Если вы обращаетесь к членам класса через varAsInterface , все они имеют общий доступ. Однако при доступе к членам есть с помощью varAsClass Sub процедура doSomething закрытый доступ. Однако, если вы получаете доступ к участникам через varAsClass , процедура Sub doSomething имеет частный доступ.

  • Которых. Область применения. Областью действия интерфейса является пространством имен, класс, структура или модуль.Интерфейс находится в области видимости во всем его пространстве имен, классе, структуре или модуле.

    Областью действия каждого члена интерфейса является весь интерфейс. Объем каждого члена интерфейса — это весь интерфейс.

  • Контролиру. Срок службы. Интерфейс сам по себе не имеет времени существования и не выполняет его члены. Интерфейс сам по себе не имеет времени жизни, как и его члены. Когда класс реализует интерфейс и создается как экземпляр этого класса, объект имеет время в приложении, в котором оно выполняется.Когда класс реализует интерфейс и объект создается как экземпляр этого класса, объект имеет время жизни в приложении, в котором он выполняется. Дополнительные сведения см. в разделе «время существования» в операторе Class. Дополнительные сведения см. в разделе «Время существования» в заявлении класса.

Пример Пример

В следующем примере оператор используется Интерфейс для определения интерфейса с именем thisInterface , который должен быть реализован с помощью Свойство оператора и Функция оператора.В следующем примере оператор Interface используется для определения интерфейса с именем thisInterface , который должен быть реализован с помощью оператора Property и оператора Function .

  Открытый интерфейс thisInterface
    Свойство ThisProp (ByVal thisStr As String) As Char
    Функция ThisFunc (ByVal thisInt как целое число) как целое число
Конечный интерфейс
  

Обратите внимание, что Property Function инструкции и не включают блоки, End Property которые заканчиваются и End Function находятся внутри интерфейса.Обратите внимание, что операторы Property и Function не вводят блоки, заканчивающиеся на End Property и End Function в интерфейсе. Интерфейс определяет только сигнатуры его членов. Интерфейс определяет только подписи своих членов. Полные Property блоки и Function появились в классе, реализующем интерфейс thisInterface . Полные блоки Property и Function появляются в классе, который реализует thisInterface .

См. также см. также

.

Создание и реализация интерфейсов — Visual Basic

  • Чтение занимает 3 мин

В этой статье

Интерфейсы описывают характеристики, методы и события, но не содержат сведений о реализации до структур или классов. Интерфейсы описывают характеристики свойств, методов и событий, но оставляют детали реализации на усмотрение структур или классов.

В этом пошаговом приложении показано, как объявить и реализовать интерфейс. В этом пошаговом руководстве показано, как объявить и реализовать интерфейс.

Примечание

В этом пошаговом руководстве не используются сведения о создании пользовательского интерфейса. В этом пошаговом руководстве не содержится информации о том, как создать пользовательский интерфейс.

Примечание

Отображаемые на компьютере имена или расположение некоторых элементов пользовательского интерфейса Visual Studio могут отличаться от указанных в инструкциях.В следующих инструкциях на вашем компьютере могут отображаться разные имена или расположение некоторых элементов пользовательского интерфейса Visual Studio. Это зависит от имеющегося выпуска Visual Studio и используемых параметров. Имеющаяся у вас версия Visual Studio и используемые вами настройки определяют эти элементы. Дополнительные сведения см. в разделе Персонализация среды IDE. Дополнительные сведения см. в разделе Персонализация среды IDE.

Определение интерфейса Определение интерфейса

  1. Откройте новый проект приложения Windows на Visual Basic.Откройте новый проект приложения Windows Visual Basic.

  2. Добавьте в проект новый модуль, выбрав в меню проект пункт Добавьте модуль . Добавьте новый модуль в проект, щелкнув Добавить модуль в меню проекта .

  3. Присвойте новому модулю имя Module1.vb и нажмите кнопку Добавить . Назовите новый модуль Module1.vb и нажмите Добавить . Отобразится код для нового модуля.Отображается код нового модуля.

  4. Определите интерфейс с именем TestInterface в Module1 , введя Интерфейс TestInterface между Module End Module операторами и, а затем приведены ВВОД. Определите интерфейс с именем TestInterface внутри Module1 , набрав Интерфейс TestInterface между операторами Module и End Module , а затем нажмите ENTER. Редактор кода смещает Интерфейс ключевое слово и определитель Конечный интерфейс оператор для формирования блока кода. Редактор кода делает отступ для ключевого слова интерфейса и добавляет оператор Конечный интерфейс для формирования блока кода.

  5. Определите свойство, метод и событие для интерфейса, поместив следующий код между Интерфейс Конечный интерфейс операторами и: Определите свойство, метод и событие для интерфейса, поместив следующий код между Интерфейс и Конечный интерфейс заявления:

      Свойство Prop1 () как целое число
    Sub Method1 (ByVal X как целое число)
    Событие Event1 ()
      

Реализация Реализация

Вы можете заметить, что синтаксис, используемый для объявления членов отличается, отличается от синтаксиса, используемого для объявления членов класса.Вы можете заметить, что синтаксис, используемый для объявления членов интерфейса, отличается от синтаксиса, используемого для объявления членов класса. Это различие отражает тот факт, что интерфейсы не могут содержать код реализации. Это различие отражает тот факт, что интерфейсы не могут содержать код реализации.

Реализация интерфейсаДля реализации интерфейса

  1. Добавьте класс с именем, ImplementationClass добавлен следующий оператор в Module1 , после End Interface оператора, но перед End Module оператором, а существующий ВВОД: Добавьте класс с именем ImplementationClass , добавив следующий оператор для Module1 , после оператора End Interface , но до оператора End Module , а затем нажмите ENTER:

      Класс Реализации Класс
      

    При работе в интегрированной среде разработки Редактор кода обеспечивает соответствующий End Class оператор при клавишах ВВОД.Если вы работаете в интегрированной среде разработки, редактор кода предоставляет соответствующий оператор End Class , когда вы нажимаете ENTER.

  2. Добавьте следующий реализаций оператор в классе реализации , который именует интерфейс, реализуемый класс: Добавьте следующий оператор реализует к классу реализации , который дает имя интерфейсу, который реализует класс:

      Реализует TestInterface
      

    При указании отдельно от других элементов в верхней части класса или структуры Реализует оператор указывает, что класс или структура реализуют интерфейс.При перечислении отдельно от других элементов в верхней части класса или структуры оператор Implements указывает, что класс или структура реализует интерфейс.

    При работе в интегрированной среде разработки Редактор кода реализует члены класса, необходимые TestInterface при нажатии клавиш ВВОД, и вы можете пропустить следующий шаг. Если вы работаете в интегрированной среде разработки, редактор кода реализует членов класса Требуется TestInterface при нажатии ENTER, и вы можете пропустить следующий шаг.

  3. Если вы не работаете в интегрированной среде разработки, необходимо реализовать все члены интерфейса MyInterface . Если вы не работаете в интегрированной среде разработки, вы должны реализовать все члены интерфейса MyInterface . Добавьте следующий код в ImplementationClass для реализации Event1 , Method1 и Prop1 : Добавьте следующий код в ImplementationClass для реализации Event1 , Method1 и Prop1 :

      Событие Event1 () реализует TestInterface.Событие1
    
    Открытый Sub Method1 (ByVal X как целое число) реализует TestInterface.Method1
    Конец подписки
    
    Открытое свойство Prop1 () как целое число реализует TestInterface.Prop1
        Получить
        Конец получить
        Установить (значение ByVal как целое число)
        Конец набора
    Конечная собственность
      

    Реализует Оператор именует интерфейс и член интерфейса, который реализуется. Реализует оператор , именует интерфейс и член интерфейса, который реализуется.

  4. Завершите определение Prop1 , добавленное закрытое поле в класс, который сохранил значение свойства: Завершите определение Prop1 , добавив частное поле к классу, в котором хранится значение свойства:

      'Содержит значение свойства.Частный pval как целое число
      

    Возврат значения pval из метода доступа get свойства. Возвращает значение pval из метода доступа get свойства.

      Возврат pval
      

    Задайте значение pval в методе доступа к набору свойств. Задайте значение pval в методе доступа набора свойств.

      pval = значение
      
  5. Завершите определение Method1 , добавив следующий код.Завершите определение Method1 , добавив следующий код.

      MsgBox ("Параметр X для Method1 равен" & X)
    RaiseEvent Event1 ()
      

Тестирование реализации интерфейса Для тестирования реализации интерфейса

  1. Правая правая кнопка мыши формула запуска проекта в Обозреватель решений и пункт Просмотреть код . Щелкните правой кнопкой мыши форму запуска вашего проекта в Solution Explorer и нажмите Просмотреть код .Редактор отображает класс для начальной формы. Редактор отображает класс для вашей формы запуска. По умолчанию вызывается форма запуска Form1 . По умолчанию форма запуска называется Form1 .

  2. Добавьте в testInstance класс следующее поле Form1 : Добавьте следующее поле testInstance в класс Form1 :

      Dim WithEvents testInstance As TestInterface
      

    Если объявить testInstance как WithEvents , Form1 класс может управлять его событиями.Объявляя testInstance как WithEvents , класс Form1 может обрабатывать свои события.

  3. Добавьте следующий обработчик событий в Form1 класс для обработки событий, вызванных testInstance : Добавьте следующий обработчик событий в класс Form1 для обработки событий, вызванных testInstance :

      Sub EventHandler () Обрабатывает testInstance.Event1
        MsgBox ("Обработчик события перехватил событие.")
    Конец подписки
      
  4. Добавьте подпрограммы с именем Test в Form1 класс для реализации реализации: Добавьте подпрограмму Test в класс Form1 для проверки класса реализации:

      Субтест ()
        'Создайте экземпляр класса.
        Dim T как новый класс реализации
        'Назначьте экземпляр класса интерфейсу.
        'Вызовы к членам интерфейса
        'выполняется через экземпляр класса.testInstance = T
        'Установить собственность.
        testInstance.Prop1 = 9
        «Прочтите собственность.
        MsgBox ("Prop1 был установлен в" & testInstance.Prop1)
        «Протестируйте метод и вызовите событие.
        testInstance.Method1 (5)
    Конец подписки
      

    47 Test Процедура создает экземпляр класса, реализующего MyInterface , присваивает этот экземпляр testInstance полю, устанавливает свойство и запускает метод через интерфейс. Процедура Test создает экземпляр класса, который реализует MyInterface , назначает этот экземпляр в поле testInstance , устанавливает свойство и запускает метод через интерфейс.

  5. Добавьте код для вызова Test процедуры из Form1 Load процедуры запуска: Добавьте код для вызова процедуры Test из Form1 Load процедуры вашей формы запуска:

      Private Sub Form1_Load (ByVal отправитель как System.Object,
                           ByVal e As System.EventArgs) Обрабатывает MyBase.Load
        Test () 'Протестируйте класс.
    Конец подписки
      
  6. Выполните Тест административ, существующий F5.Запустите процедуру Test , нажав F5. Отображается сообщение «Prop1 имело значение 9». Отображается сообщение «Prop1 было установлено на 9». После этого кнопки ОК отображается сообщение «параметр для метода1 равен 5». После нажатия кнопки ОК отображается сообщение «Параметр X для метода1 равен 5». Нажмите кнопку ОК, после чего появится сообщение «обработчик событий захватил событие». Нажмите кнопку ОК, и отобразится сообщение «Обработчик событий поймал событие».

См.также раздел см. также

.

Создание вариативных универсальных интерфейсов — Visual Basic

  • Чтение занимает 4 мин

В этой статье

Параметры универсального типа можно объявить в интерфейсе как ковариантные или контравариантные. Параметры универсального типа в интерфейсах можно объявить как ковариантные или контравариантные. Ковариация позволяет методам интерфейса тип возвращаемого значения, степень наследования достижения больше, чем указано в параметрах универсального типа. Ковариация позволяет интерфейсным методам иметь больше производных возвращаемых типов, чем определено параметрами универсального типа. Контравариантность позволяет методам интерфейса иметь тип аргументов, степень наследования меньше, чем указано в параметрах универсального типа. Contravariance позволяет интерфейсным методам иметь типы аргументов, производные от которых меньше, чем указано в общих параметрах. Универсальный, который имеет ковариантные или контравариантные параметры универсального типа, называется вариантомным .Универсальный интерфейс с ковариантными или контравариантными параметрами универсального типа называется вариантом .

Объявление вариантов универсальных интерфейсов Объявление вариантов универсальных интерфейсов

Вариантные универсальные интерфейсы можно объявить с помощью ключевых слов в и из для параметров универсального типа. Вы можете объявить вариант универсальных интерфейсов, используя ключевые слова в и из для параметров универсального типа.

Важно!

ByRef Параметры Visual Basic не могут быть вариантами. ByRef Параметры в Visual Basic не могут быть вариантами. Типы значений также не вариативность. Типы значений также не поддерживают вариативность.

Для объявления типа ковариантного варианта универсального можно использовать слово out . Вы можете объявить ковариант параметра универсального типа, используя ключевое слово out . Ковариантный тип должен удовлетворять следующие условия: Ковариантный тип должен удовлетворять следующим условиям:

  • Тип используется в качестве аргументов типа значения, возвращаемые методы интерфейса.Тип используется только как тип возвращаемого значения методов интерфейса и не используется как тип аргументов метода. Это показано в следующем примере, в котором тип R объявлен ковариантным. Это проиллюстрировано в следующем примере, в котором тип R объявлен ковариантным.

      Интерфейс ICovariant (Out R)
        Функция GetSomething () как R
        'Следующий оператор вызывает ошибку компилятора.
        'Sub SetSomething (ByVal sampleArg As R)
    Конечный интерфейс
      

    Существует одно исключение из данного правила.Есть одно исключение из этого правила. Если в качестве параметра метода используется контравариантный универсальный делегат, можно использовать этот тип в качестве параметра универсального типа для делегата. Это ниже показано на примере типа R . Это проиллюстрировано на примере типа R в следующем примере. Дополнительные сведения см.в разделе вариативность в делегатах (Visual Basic) и Использование вариативности для универсальных делегатов Func и Action (Visual Basic). Дополнительные сведения см. в разделах Вариативность в делегатах (Visual Basic) и Использование вариативности для универсальных делегатов функций и действий (Visual Basic).

      Интерфейс ICovariant (Out R)
        Sub DoSomething (обратный вызов ByVal как действие (Of R))
    Конечный интерфейс
      
  • Тип не используется в качестве универсального ограничения для методов интерфейса.Тип не используется в качестве общего ограничения для методов интерфейса. Это демонстрируется в следующем примере кода.

      Интерфейс ICovariant (Out R)
        'Следующий оператор вызывает ошибку компилятора
        'потому что вы можете использовать только контравариантные или инвариантные типы
        'в общих ограничениях.
        'Sub DoSomething (Of ​​T As R) ()
    Конечный интерфейс
      

Для объявления контравариантного слова универсального типа можно использовать в .Вы можете объявить контравариант параметра универсального типа, используя ключевое слово in . Контравариантный тип можно использовать только в качестве аргументов метода, но не в качестве типа значения, возвращаемые методы интерфейса. Контравариантный тип может использоваться только как тип аргументов метода, но не как тип возвращаемого значения методов интерфейса. Контравариантный тип можно также использовать для универсальных ограничений. Контравариантный тип также может использоваться для общих ограничений. В следующем примере показано объявление контравариантного интерфейса и использование универсального ограничения для одного из его методов.В следующем коде показано, как объявить контравариантный интерфейс и использовать универсальное ограничение для одного из его методов.

  Интерфейс IC Контравариантный (Of In A)
    Sub SetSomething (ByVal sampleArg As A)
    Sub DoSomething (Of ​​T As A) ()
    'Следующий оператор вызывает ошибку компилятора.
    'Функция GetSomething () As A
Конечный интерфейс
  

Кроме того, можно реализовать поддержку ковариации и контравариации в одном интерфейсе, но для разных типов параметров, как показано в следующем примере кода.Также возможно поддерживать как ковариацию, так и контравариантность в одном интерфейсе, но для разных параметров типа, как показано в следующем примере кода.

  Интерфейс IVariant (Out R, In A)
    Функция GetSomething () как R
    Sub SetSomething (ByVal sampleArg As A)
    Функция GetSetSomething (ByVal sampleArg As A) As R
Конечный интерфейс
  

В Visual Basic нельзя объявлять события в вариативных интерфейсах без указаний типа делегата. В Visual Basic нельзя объявлять события в различных интерфейсах без указания типа делегата.Кроме того, вариантный интерфейс может иметь вложенные классы, перечисление или структуры, но может иметь вложенные интерфейсы. Кроме того, вариантный интерфейс не может иметь вложенных классов, перечислений или структур, но может иметь вложенные интерфейсы. Это демонстрируется в следующем примере кода.

  Интерфейс ICovariant (Out R)
    'Следующий оператор вызывает ошибку компилятора.
    'Событие SampleEvent ()
    'Следующий оператор определяет тип делегата и
    'не вызывает ошибки.Событие AnotherEvent как EventHandler

    'Следующие операторы вызывают ошибки компилятора,
    'потому что вариант интерфейса не может иметь
    'вложенные перечисления, классы или структуры.

    'Enum SampleEnum: test: End Enum
    'Класс SampleClass: Конечный класс
    'Структура SampleStructure: Тусклое значение как целое число: Конечная структура

    'Варианты интерфейсов могут иметь вложенные интерфейсы.
    Вложенный интерфейс: конечный интерфейс
Конечный интерфейс
  

Реализация вариантов универсальных интерфейсов Реализация вариантов универсальных интерфейсов

Для реализации вариантов универсальных интерфейсов в классах используется тот же синтаксис, что и для инвариантных интерфейсов.Вы реализуете вариантные универсальные интерфейсы в классах, используя тот же синтаксис, который используется для инвариантных интерфейсов. В следующем варианте реализации ковариантного интерфейса в универсальном классе. В следующем примере кода показано, как реализовать ковариантный интерфейс в универсальном классе.

  Интерфейс ICovariant (Out R)
    Функция GetSomething () как R
Конечный интерфейс

Класс SampleImplementation (Of R)
    Реализует ICovariant (Of R)
    Открытая функция GetSomething () как R _
    Реализует ICovariant (Of R).Получить что-то
        «Какой-то код.
    Конечная функция
Конец класса
  

Классы, которые реализуют вариантные интерфейсы, являются инвариантными. Классы, реализующие вариантные интерфейсы, инвариантны. Например, рассмотрим следующий код. Например, рассмотрим следующий код.

  Интерфейс ковариантен.
Dim ibutton как ICovariant (Of Button) =
    Новая реализация образца (кнопки)
Dim iobj As ICovariant (Of Object) = ibutton

«Класс инвариантен.
Тусклая кнопка как SampleImplementation (Of Button) =
    Новая реализация образца (кнопки)
'Следующий оператор вызывает ошибку компилятора
'потому что классы инвариантны.'Dim obj As SampleImplementation (Of Object) = кнопка
  

Расширение вариантов универсальных интерфейсов Расширение вариантов универсальных интерфейсов

При расширении вариантов универсальных интерфейсов необходимо использовать ключевые слова в и из для явного указания того, поддерживает ли вариативность производный интерфейс. При расширении варианта универсального интерфейса необходимо использовать ключевые слова в и из для явно указать, поддерживает ли производный интерфейс дисперсию.Компилятор не подразумевает вариативность интерфейса, который расширяется. Компилятор не делает вывод об отклонениях от расширяемого интерфейса. Например, рассмотрим следующие интерфейсы. Например, рассмотрим следующие интерфейсы.

  Интерфейс ICovariant (Out T)
Конечный интерфейс

Интерфейс IInvariant (Of T)
    Наследует ICovariant (Of T)
Конечный интерфейс

Интерфейс IExtCovariant (Of Out T)
    Наследует ICovariant (Of T)
Конечный интерфейс
  

В Invariant (Of T) интерфейс параметр универсального типа T инвариантным, тогда как в IExtCovariant (Of Out T) параметр типа является ковариантным, хотя оба интерфейса расширяют один и тот же интерфейс.В интерфейсе Invariant (Of T) параметр универсального типа T является инвариантным, тогда как в IExtCovariant (Of Out T) параметр типа является ковариантным, хотя оба интерфейса расширяют один и тот же интерфейс. То же правило применяется к контравариантным параметрам универсального типа.

Можно создать интерфейс, расширяет который и интерфейс, в котором используется параметр универсального типа T является ковариантным, и интерфейс, где он является контравариантным, если в расширяемом интерфейсе параметр универсального типа T является инвариантным.Вы можете создать интерфейс, который расширяет как интерфейс, где параметр универсального типа T является ковариантным, так и интерфейс, в котором он является контравариантным, если в расширяемом интерфейсе параметр универсального типа T является инвариантным. Это показано в следующем примере кода. Это показано в следующем примере кода.

  Интерфейс ICovariant (Out T)
Конечный интерфейс

Интерфейс IC Контравариантный (Of In T)
Конечный интерфейс

Интерфейс IInvariant (Of T)
    Наследует ICovariant (Of T), IContravariant (Of T)
Конечный интерфейс
  

Тем не менее, если параметр универсального типа T объявлен ковариантным в одном интерфейсе, его нельзя объявить контравариантным в расширенном интерфейсе и наоборот.Однако, если параметр универсального типа T объявлен ковариантным в одном интерфейсе, вы не можете объявить его контравариантным в расширяющем интерфейсе, или наоборот. Это показано в следующем примере кода. Это показано в следующем примере кода.

  Интерфейс ICovariant (Out T)
Конечный интерфейс

'Следующие операторы вызывают ошибку компилятора.
'Интерфейс ICoContraVariant (Of In T)
'Наследует ICovariant (Of T)
'Конечный интерфейс
  

Недопущение неоднозначности Как избежать неоднозначности

При реализации универсальных интерфейсов вариативность может приводить к неоднозначности.Когда вы реализуете вариантные универсальные интерфейсы, расхождения иногда могут приводить к двусмысленности. Этого следует избегать.

Например, если вы явно реализуете один и тот же вариант универсального интерфейса с разными параметрами универсального типа в одном классе, это может создать неоднозначность. . Компилятор не сообщает об ошибке в данном случае, но и не указывает, какая реализация интерфейса будет выбрана во время выполнения.В этом случае компилятор не выдает ошибки, но не указывается, какая реализация интерфейса будет выбрана во время выполнения. Это может вызвать к возникновению неявных ошибок в коде.Это может привести к незаметным ошибкам в вашем коде. Рассмотрим следующий пример кода: Рассмотрим следующий пример кода.

Примечание

В Option Strict Off Visual Basic создает предупреждение компилятора при возникновении неоднозначной реализации интерфейса. С Option Strict Off Visual Basic генерирует предупреждение компилятора при неоднозначной реализации интерфейса.В Option Strict On Visual Basic создает ошибку компилятора. С Option Strict On Visual Basic генерирует ошибку компилятора.

  'Простая иерархия классов.
Класс Животное
Конец класса

Класс Кот
    Наследует животное
Конец класса

Класс Собака
    Наследует животное
Конец класса

'Этот класс вводит двусмысленность
'потому что IEnumerable (Of Out T) ковариантен.
Классные питомцы
    Реализует IEnumerable (Of Cat), IEnumerable (Of Dog)

    Открытая функция GetEnumerator () как IEnumerator (Of Cat) _
        Реализует IEnumerable (Of Cat).GetEnumerator
        Console.WriteLine ("Кот")
        «Какой-то код.
    Конечная функция

    Открытая функция GetEnumerator1 () как IEnumerator (Of Dog) _
        Реализует IEnumerable (Of Dog) .GetEnumerator.
        Console.WriteLine ("Собака")
        «Какой-то код.
    Конечная функция

    Открытая функция GetEnumerator2 () как IEnumerator _
        Реализует IEnumerable.GetEnumerator
        «Какой-то код.
    Конечная функция
Конец класса

Sub Main ()
    Dim pets As IEnumerable (Of Animal) = Новые питомцы ()
    pets.GetEnumerator ()
Конец подписки
  

В этом примере не указано, каким образом метод pets.GetEnumerator делает выбор между Cat и Dog . В этом примере не указано, как метод pets. GetEnumerator выбирает между Cat и Dog . Это может вызвать проблемы в вашем коде.Это может вызвать проблемы в вашем коде.

См. также раздел см. также

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

2021 © Все права защищены. Карта сайта