Partilhar via


Como: Implementar uma arquitetura de componentes de plug-in usando a reflexão

Os exemplos de código a seguir demonstram o uso da reflexão para implementar um simples "plug-in" arquitetura. A primeira lista é o aplicativo e o segundo é o plug-in. O aplicativo é um formulário de documento de várias que preenche a mesma usando as classes de baseado em formulário encontradas na DLL de plug-in fornecido como um argumento de linha de comando.

O aplicativo tenta carregar o assembly fornecido usando o Assembly.Load método. Se bem-sucedida, os tipos de assembly são enumerados usando o Assembly.GetTypes método. Cada tipo, em seguida, é verificado para compatibilidade com o Type.IsAssignableFrom método. Neste exemplo, classes encontradas no assembly fornecido devem ser derivados de Form classe para qualificar-se como um plug-in.

Classes compatíveis são então instanciados com o Activator.CreateInstance método, que aceita um Type como um argumento e retorna um ponteiro para uma nova instância. Em seguida, cada nova instância é anexada ao formulário e exibida.

Observe que o Load método não aceita nomes de assembly, que incluem a extensão de arquivo. A função principal do aplicativo apara quaisquer extensões fornecidas, portanto, o exemplo de código a seguir funciona em ambos os casos.

Exemplo

O código a seguir define o aplicativo que aceita o plug-ins. O nome do assembly deve ser fornecido como o primeiro argumento. Este assembly deve conter pelo menos um público Form derivado do tipo.

// plugin_application.cpp
// compile with: /clr /c
#using <system.dll>
#using <system.drawing.dll>
#using <system.windows.forms.dll>

using namespace System;
using namespace System::Windows::Forms;
using namespace System::Reflection;

ref class PluggableForm : public Form  {
public:
   PluggableForm() {}
   PluggableForm(Assembly^ plugAssembly) {
      Text = "plug-in example";
      Size = Drawing::Size(400, 400);
      IsMdiContainer = true;

      array<Type^>^ types = plugAssembly->GetTypes( );
      Type^ formType = Form::typeid;

      for (int i = 0 ; i < types->Length ; i++) {
         if (formType->IsAssignableFrom(types[i])) {
            // Create an instance given the type description.
            Form^ f = dynamic_cast<Form^> (Activator::CreateInstance(types[i]));
            if (f) {
               f->Text = types[i]->ToString();
               f->MdiParent = this;
               f->Show();
            }
         }
      }
   }
};

int main() {
   Assembly^ a = Assembly::LoadFrom("plugin_application.exe");
   Application::Run(gcnew PluggableForm(a));
}

O código a seguir define três classes derivadas de Form. Quando o nome do assembly resultante é passado para o executável da listagem anterior, cada uma dessas três classes será descoberta e instanciada, apesar do fato de que eram todos desconhecidos para o aplicativo de hospedagem em tempo de compilação.

// plugin_assembly.cpp
// compile with: /clr /LD
#using <system.dll>
#using <system.drawing.dll>
#using <system.windows.forms.dll>

using namespace System;
using namespace System::Windows::Forms;
using namespace System::Reflection;
using namespace System::Drawing;

public ref class BlueForm : public Form {
public:
   BlueForm() {
      BackColor = Color::Blue;
   }
};

public ref class CircleForm : public Form {
protected:
   virtual void OnPaint(PaintEventArgs^ args) override {
      args->Graphics->FillEllipse(Brushes::Green, ClientRectangle);
   }
};

public ref class StarburstForm : public Form {
public:
   StarburstForm(){
      BackColor = Color::Black;
   }
protected:
   virtual void OnPaint(PaintEventArgs^ args) override {
      Pen^ p = gcnew Pen(Color::Red, 2);
      Random^ r = gcnew Random( );
      Int32 w = ClientSize.Width;
      Int32 h = ClientSize.Height;
      for (int i=0; i<100; i++) {
         float x1 = w / 2;
         float y1 = h / 2;
         float x2 = r->Next(w);
         float y2 = r->Next(h);
         args->Graphics->DrawLine(p, x1, y1, x2, y2);
      }
   }
};

Consulte também

Referência

Reflexão em C++