classe di interfaccia (Estensioni del componente C++)

Dichiara un'interfaccia.Per informazioni sulle interfacce native, vedere __interface.

Tutti i runtime

Sintassi

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

Parametri

• interface_access
  L'accessibilità di un'interfaccia l'assembly.i valori possibili sono public e private.private è l'impostazione predefinita.Le interfacce annidate non possono avere un identificatore di interface_access .

• name
  Nome dell'interfaccia.

• inherit_access
  l'accessibilità di base_interface.L'unica accessibilità valida per un'interfaccia di base è public (impostazione predefinita).

• base_interface (facoltativo)
  Un'interfaccia di base per l'interfaccia nome.

Note

interface struct equivale a interface class.

Un'interfaccia può contenere dichiarazioni per le funzioni, eventi e proprietà.Tutti i membri di interfaccia dispongono di accessibilità pubblica.Un'interfaccia può inoltre contenere i membri dati statici, funzioni, gli eventi e le proprietà e i membri statici devono essere definiti nell'interfaccia.

Un'interfaccia definisce come una classe può essere distribuita.Un'interfaccia non è una classe e le classi possono implementare solo le interfacce.Quando una classe definita una funzione dichiarata in un'interfaccia, la funzione viene distribuita, non si esegue l'override di.Di conseguenza, la ricerca del nome non include i membri di interfaccia.

Una classe o uno struct che derivano da un'interfaccia deve implementare tutti i membri di interfaccia.Quando si implementa il nome dell'interfaccia è inoltre necessario implementare le interfacce in base_interface elenco.

Per ulteriori informazioni, vedere:

• Costruttore statico dell'interfaccia

• Interfacce generiche (Visual C++)

Per informazioni su altri tipi CLR, vedere Classi e strutture.

È possibile rilevare in fase di compilazione se un tipo è un'interfaccia con __is_interface_class(type).Per ulteriori informazioni, vedere Supporto del compilatore per tratti di tipo (Estensioni del componente C++).

Nell'ambiente di sviluppo, è possibile ottenere la Guida su queste parole chiave evidenziando la parola chiave, (interface class, ad esempio) e premendo F1.

Windows Runtime

Note

(Non esistono commenti della funzionalità del linguaggio che si applicano solo alle finestre runtime).

Requisiti

Opzione del compilatore: /ZW

Common Language Runtime

Note

(Non esistono commenti della funzionalità del linguaggio che si applicano solo a Common Language Runtime).

Requisiti

Opzione del compilatore: /clr

Esempi

Esempio

Nell'esempio di codice seguente viene illustrato come un'interfaccia può definire il comportamento di una funzione di temporizzazione.

// 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();
}

Output

Esempio

Nell'esempio di codice seguente vengono illustrati due modi per implementare le funzioni con la stessa firma dichiarata in più interfacce e in cui tali interfacce utilizzate da una classe.

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

Vedere anche

Concetti

Estensioni componenti per le piattaforme runtime