Dela via

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

Deklarerar ett gränssnitt. Information om interna gränssnitt finns i __interface.

Alla körningar

Syntax

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

Parameterar

interface_access
Tillgängligheten för ett gränssnitt utanför sammansättningen. Möjliga värden är public och private. private används som standard. Kapslade gränssnitt kan inte ha någon interface_access specificerare.

name
Namnet på gränssnittet.

inherit_access
Tillgängligheten för base_interface. Den enda tillåtna tillgängligheten för ett basgränssnitt är public (standard).

base_interface
(Valfritt) Ett basgränssnitt för gränssnittet name.

Anmärkningar

interface struct motsvarar interface class.

Ett gränssnitt kan innehålla deklarationer för funktioner, händelser och egenskaper. Alla gränssnittsmedlemmar har offentlig tillgänglighet. Ett gränssnitt kan också innehålla statiska datamedlemmar, funktioner, händelser och egenskaper, och dessa statiska medlemmar måste definieras i gränssnittet.

Ett gränssnitt definierar hur en klass kan implementeras. Ett gränssnitt är inte en klass och klasser kan bara implementera gränssnitt. När en klass definierar en funktion som deklarerats i ett gränssnitt implementeras funktionen, inte åsidosättas. Namnsökning innehåller därför inte gränssnittsmedlemmar.

En class eller struct som härleds från ett gränssnitt måste implementera alla medlemmar i gränssnittet. När du implementerar gränssnittet namemåste du även implementera gränssnitten base_interface i listan.

Mer information finns i:

Information om andra CLR-typer finns i Klasser och Structs.

Du kan identifiera vid kompileringstillfället om en typ är ett gränssnitt med __is_interface_class(type). Mer information finns i Kompilatorstöd för typegenskaper.

I utvecklingsmiljön kan du få F1-hjälp med dessa nyckelord genom att markera nyckelordet (till exempel interface class) och trycka på F1.

Windows Runtime

Anmärkningar

(Det finns inga kommentarer för den här språkfunktionen som endast gäller för Windows Runtime.)

Kravspecifikation

Kompilatoralternativ: /ZW

Allmänt språk-runtime

Anmärkningar

(Det finns inga kommentarer för den här språkfunktionen som endast gäller för common language runtime.)

Kravspecifikation

Kompilatoralternativ: /clr

Exempel

Följande kodexempel visar hur ett gränssnitt kan definiera beteendet för en klockfunktion.

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

Följande kodexempel visar två sätt att implementera funktioner med samma signatur deklarerad i flera gränssnitt och var dessa gränssnitt används av en klass.

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

Se även

Komponenttillägg för .NET och UWP