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

  • Artikel

Deklariert eine Schnittstelle. Informationen zu systemeigenen Schnittstellen finden Sie unter __interface.

Alle Laufzeiten

Syntax

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

Parameter

interface_access
Die Möglichkeit des Zugriffs auf eine Schnittstelle außerhalb der Assembly. Mögliche Werte sind public und private. private ist die Standardoption. Geschachtelte Schnittstellen können keinen Bezeichner haben interface_access .

name
Der Name der Schnittstelle.

inherit_access
Die Barrierefreiheit von base_interface. Die einzige zulässige Barrierefreiheit für eine Basisschnittstelle ist public (standard).

base_interface
(Optional) Eine Basisschnittstelle für die Schnittstelle name.

Hinweise

interface struct entspricht interface class.

Eine Schnittstelle kann Deklarationen für Funktionen, Ereignisse und Eigenschaften enthalten. Auf alle Schnittstellenmember kann öffentlich zugegriffen werden. Eine Schnittstelle kann auch statische Datenelemente, Funktionen, Ereignisse und Eigenschaften enthalten, und diese statischen Member müssen in der Schnittstelle definiert werden.

Eine Schnittstelle definiert, wie eine Klasse implementiert werden kann. Eine Schnittstelle ist keine Klasse, und Klassen können nur Schnittstellen implementieren. Wenn eine Klasse eine Funktion definiert, die in einer Schnittstelle deklariert wird, wird die Funktion implementiert, nicht überschrieben. Daher enthält die Namenssuche keine Schnittstellenmber.

A class oder struct das von einer Schnittstelle abgeleitet wird, muss alle Member der Schnittstelle implementieren. Bei der Implementierung der Schnittstelle namemüssen Sie auch die Schnittstellen in der base_interface Liste implementieren.

Weitere Informationen finden Sie unter:

Informationen zu anderen CLR-Typen finden Sie unter Klassen und Strukturen.

Sie können mit __is_interface_class(type) zum Zeitpunkt der Kompilierung ermitteln, ob ein Typ eine Schnittstelle ist. Weitere Informationen finden Sie unter Compilerunterstützung für Typmerkmale.

In der Entwicklungsumgebung können Sie F1-Hilfe zu diesen Schlüsselwort (keyword) erhalten, indem Sie die Schlüsselwort (keyword) (zinterface class. B. ) hervorheben und F1 drücken.

Windows-Runtime

Hinweise

(Es gibt keine Hinweise für diese Sprachfunktion, die nur für Windows-Runtime gelten.)

Anforderungen

Compileroption: /ZW

Übersicht: Common Language Runtime (CLR)

Hinweise

(Es gibt keine Hinweise für diese Sprachfunktion, die nur für Common Language Runtime gelten.)

Anforderungen

Compileroption: /clr

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie eine Schnittstelle das Verhalten einer Klickfunktion definieren kann.

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

Das folgende Codebeispiel zeigt zwei Möglichkeiten zum Implementieren von Funktionen mit derselben, in mehreren Schnittstellen deklarierten Signatur, und wo diese Schnittstellen von einer Klasse verwendet werden.

// 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 {}
};

Siehe auch

Komponentenerweiterungen für .NET und UWP