Delen via

interface class (C++/CLI en C++/CX)

Declareert een interface. Zie voor meer informatie over systeemeigen interfaces __interface.

Alle runtimes

Syntaxis

interface_access interface class name : inherit_access base_interface {};
interface_access interface struct name : inherit_access base_interface {};

Parameterwaarden

interface_access
De toegankelijkheid van een interface buiten de assembly. Mogelijke waarden zijn public en private. private is de standaardwaarde. Geneste interfaces kunnen geen aanduiding hebben interface_access .

name
De naam van de interface.

inherit_access
De toegankelijkheid van base_interface. De enige toegestane toegankelijkheid voor een basisinterface is public (de standaardinstelling).

base_interface
(Optioneel) Een basisinterface voor interface name.

Opmerkingen

interface struct is equivalent aan interface class.

Een interface kan declaraties bevatten voor functies, gebeurtenissen en eigenschappen. Alle interfaceleden hebben openbare toegankelijkheid. Een interface kan ook statische gegevensleden, functies, gebeurtenissen en eigenschappen bevatten, en deze statische leden moeten worden gedefinieerd in de interface.

Een interface definieert hoe een klasse kan worden geïmplementeerd. Een interface is geen klasse en klassen kunnen alleen interfaces implementeren. Wanneer een klasse een functie definieert die in een interface is gedeclareerd, wordt de functie geïmplementeerd, niet overschreven. Naamzoekactie bevat daarom geen interfaceleden.

Een class of struct die is afgeleid van een interface, moet alle leden van de interface implementeren. Bij het implementeren van de interface namemoet u ook de interfaces in de base_interface lijst implementeren.

Voor meer informatie, zie:

Zie Klassen en Structs voor meer informatie over andere CLR-typen.

U kunt tijdens het compileren detecteren als een type een interface is met __is_interface_class(type). Zie Compiler-ondersteuning voor typeeigenschappen voor meer informatie.

In de ontwikkelomgeving kunt u F1-hulp krijgen bij deze trefwoorden door het trefwoord (bijvoorbeeld interface class) te markeren en op F1 te drukken.

Windows Runtime

Opmerkingen

(Er zijn geen opmerkingen voor deze taalfunctie die alleen van toepassing zijn op Windows Runtime.)

Behoeften

Compileroptie: /ZW

Gemeenschappelijke Taaluitvoeringsomgeving

Opmerkingen

(Er zijn geen opmerkingen voor deze taalfunctie die alleen van toepassing zijn op de algemene taalruntime.)

Behoeften

Compileroptie: /clr

Voorbeelden

In het volgende codevoorbeeld ziet u hoe een interface het gedrag van een klokfunctie kan definiëren.

// mcppv2_interface_class.cpp
// compile with: /clr
using namespace System;

public delegate void ClickEventHandler(int, double);

// define interface with nested interface
public interface class Interface_A {
   void Function_1();

   interface class Interface_Nested_A {
      void Function_2();
   };
};

// interface with a base interface
public interface class Interface_B : Interface_A {
   property int Property_Block;
   event ClickEventHandler^ OnClick;
   static void Function_3() { Console::WriteLine("in Function_3"); }
};

// implement nested interface
public ref class MyClass : public Interface_A::Interface_Nested_A {
public:
   virtual void Function_2() { Console::WriteLine("in Function_2"); }
};

// implement interface and base interface
public ref class MyClass2 : public Interface_B {
private:
   int MyInt;

public:
   // implement non-static function
   virtual void Function_1() { Console::WriteLine("in Function_1"); }

   // implement property
   property int Property_Block {
      virtual int get() { return MyInt; }
      virtual void set(int value) { MyInt = value; }
   }
   // implement event
   virtual event ClickEventHandler^ OnClick;

   void FireEvents() {
      OnClick(7, 3.14159);
   }
};

// class that defines method called when event occurs
ref class EventReceiver {
public:
   void OnMyClick(int i, double d) {
      Console::WriteLine("OnClick: {0}, {1}", i, d);
   }
};

int main() {
   // call static function in an interface
   Interface_B::Function_3();

   // instantiate class that implements nested interface
   MyClass ^ x = gcnew MyClass;
   x->Function_2();

   // instantiate class that implements interface with base interface
   MyClass2 ^ y = gcnew MyClass2;
   y->Function_1();
   y->Property_Block = 8;
   Console::WriteLine(y->Property_Block);

   EventReceiver^ MyEventReceiver = gcnew EventReceiver();

   // hook handler to event
   y->OnClick += gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);

   // invoke events
   y->FireEvents();

   // unhook handler to event
   y->OnClick -= gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);

   // call implemented function via interface handle
   Interface_A^ hi = gcnew MyClass2();
   hi->Function_1();
}

in Function_3

in Function_2

in Function_1

8

OnClick: 7, 3.14159

in Function_1

In het volgende codevoorbeeld ziet u twee manieren om functies te implementeren met dezelfde handtekening die is gedeclareerd in meerdere interfaces en waar deze interfaces door een klasse worden gebruikt.

// mcppv2_interface_class_2.cpp
// compile with: /clr /c
interface class I {
   void Test();
   void Test2();
};

interface class J : I {
   void Test();
   void Test2();
};

ref struct R : I, J {
   // satisfies the requirement to implement Test in both interfaces
   virtual void Test() {}

   // implement both interface functions with explicit overrides
   virtual void A() = I::Test2 {}
   virtual void B() = J::Test2 {}
};

Zie ook

Onderdeelextensies voor .NET en UWP

  • Last updated on