Classe versus versus controle do componente

Este tópico define componente e controle; discussão apresentada aqui deve ajudá-decidir quando implementar uma classe que é um componente ou um controle.

A lista a seguir fornece diretrizes amplas para implementadores.

• Se sua classe usa recursos externos, mas não será usada em uma área de design, implementação System.IDisposable, ou derivar de uma classe que direta ou indiretamente implementa IDisposable.

• Se sua classe será usada em uma área de design (sistema autônomo o Windows Forms ou Web Forms designer), implemente System.ComponentModel.IComponent, ou derivar de uma classe que direta ou indiretamente implementa IComponent. Observe que IComponent amplia IDisposable, para que um IComponent tipo é sempre um IDisposable Digite. An IComponent tipo tem um desempenho pequeno sobrecarga sobre um IDisposable tipo que não é um IComponent, mas isso geralmente é compensado pela capacidade de site um IComponent no design e time em time de execução. (Localizando é explicado neste tópico.)

• Se você desejar que uma classe que é projetáveis (usado em uma área de design) e é empacotada por referência, você pode derivar a partir de System.ComponentModel.Component. Component é a implementação da base de um IComponent tipo é empacotado por referência.

• Se você desejar que uma classe projetáveis é empacotada por valor, você pode derivar a partir de System.ComponentModel.MarshalByValueComponent. MarshalByValueComponent é a implementação da base de um IComponent tipo é empacotado por valor.

• Se você quiser apresentar um IComponent Digite na sua hierarquia do modelo de objeto e não pode derivar de uma implementação básica, sistema autônomo Component ou MarshalByValueComponent devido a herança única, implemente IComponent.

• Se você desejar que uma classe projetáveis que fornece uma interface de usuário, sua classe é um controle.Um controle deve derivar direta ou indiretamente de uma das classes de controle base: System.Windows.Forms.Control ou System.Web.UI.Control.

  Observação:
  Se sua classe não é projetáveis nem possui recursos externos, você não precisa de um IComponent ou um IDisposable Digite.

Execute as definições de componente, controle, contêiner e site.

Componente

No .NET Framework, um componente é uma classe que implementa o System.ComponentModel.IComponent interface ou que deriva direta ou indiretamente de uma classe que implementa IComponent. Em programação, o termo componente geralmente é usado para um objeto que é reutilizável e pode interagir com outros objetos.A .NET Framework componente satisfaz sistema autônomo requisitos Geral e Além disso, fornece recursos sistema autônomo controle sobre recursos externos e suporte em time de design.

Controle sobre recursos externos

The IComponent interface estende o IDisposable interface, que tem um método chamado Dispose em seu contrato. Em sua implementação do Dispose método, um componente necessário versão recursos externos explicitamente. Isso fornece uma maneira determinista disponível recursos, em comparação com a limpeza não determinísticas padrão que ocorre por meio da coleta de lixo.Developers must propagate Disposethroughout a containment hierarchy to ensure that children of a component also free resources.Além disso, um componente derivado deve chamar o Dispose método de sua classe base.

Observação:
Mesmo quando você fornecer controle explícito sobre os recursos por meio de Dispose, você deve sempre fornecer limpeza implícita pelo finalizador (destruidor) para impedir que recursos permanentemente vazando se um usuário não conseguir chamar Dispose em seu componente.

O exemplo a seguir mostra o padrão para a implementação de Dispose em um componente base e no componente derivado.

public class BaseComponent : IComponent {

   // IComponent extends IDisposable.
   public void Dispose() {
        Dispose(true);
     GC.SuppressFinalize(this); 
      }

   protected virtual void Dispose(bool disposing) {
      if (disposing) {
          // Free other state (managed objects).
      }
      // Free your own state (unmanaged objects).
   }

   // Simply call Dispose(false).
      ~BaseComponent(){
      Dispose (false);
   }
}
   
// Derived component.
public class DerivedComponent : BaseComponent {
   
   protected override void Dispose(bool disposing) {
      if (disposing) {
      // Free other state.
      }
      // You must invoke the Dispose method of the base class.
      base.Dispose(disposing);
      // Free your own state.
      ...
   }
   // No finalizer/destructor.
   // No Dispose() method.
}

   

' Design pattern for a base class.
Public Class BaseComponent
   Implements IComponent
   ' Implement IDisposable
   Public Overloads Sub Dispose() 
      Dispose(True)
      GC.SuppressFinalize(Me)
   End Sub

   Protected Overloads Overridable Sub Dispose(disposing As Boolean)
      If disposing Then
         ' Free other state (managed objects).
      End If
      ' Free your own state (unmanaged objects).
      ' Set large fields to null.
   End Sub

   Protected Overrides Sub Finalize()
      ' Simply call Dispose(False).
      Dispose (False)
   End Sub
End Class

' Design pattern for a derived component.
Public Class DerivedComponent
   Inherits BaseComponent

   Protected Overloads Overrides Sub Dispose(disposing As Boolean) 
      If disposing Then 
         ' Release managed resources.
      End If
      ' Release unmanaged resources.
      ' Set large fields to null.
      ' Call Dispose on your base class.
      Mybase.Dispose(disposing)
   End Sub
   ' The derived class does not have a Finalize method
   ' or a Dispose method with parameters because it inherits
   ' them from the base class.
End Class

Em time de design

Um recurso importante de componentes no .NET Framework é que eles são projetáveis, o que significa que uma classe que é um componente pode ser usada em um ambiente de desenvolvimento (RAD) rápido de aplicativos, sistema autônomo Visual Studio. Um componente pode ser adicionado à caixa de ferramentas de Visual Studio, pode ser arrastado e solto sobre um formulário e pode ser manipulado em uma área de design. Observe que suporte em time de design básico de IComponent tipos é incorporada ao .NET Framework; um desenvolvedor de componentes não precisa fazer qualquer trabalho adicional para usufruir a funcionalidade básica em time de design.

Para obter mais informações sobre suporte em tempo de design, consulte Atributos de time de design para componentes e Estendendo suporte em tempo de design.

Hospedando um componente

Um componente pode ser localizado (hospedada) em um contêiner (definido mais adiante neste tópico).Quando um componente é localizado, ele interage com o contêiner através de seu site (definida mais adiante neste tópico) e tem a capacidade de consulta e obter serviços de seu contêiner através do site.Para garantir que recursos são liberados quando um recipiente é subdividido, um contêiner deve implementar o IDisposable interface. Em sua implementação do Dispose método, um contêiner deve liberar todos os recursos que ele contém e invocar o Dispose método de cada um de seus componentes contidos.

Confinamento é lógico e não precisa ter uma representação visual.Um contêiner de camada intermediária que componentes de banco de dados de sites é um exemplo de confinamento não visuais.Confinamento Visual é visto no designer do Windows Forms e Web Forms designer no Visual Studio. A área de design visual é um contêiner que hospeda o componente de formulário (no Web Forms, o componente de página).

Um componente de marshaling

Componentes podem ser remoto ou nonremotable.Componentes remoto são empacotados por referência ou por valor.marshaling envolve o envio de objetos em limites, sistema autônomo domínios de aplicativo (processos leves), processos e até mesmo máquinas.Quando um objeto é empacotado por referência, é criado um proxy que faz chamadas remotas para o objeto.Quando um objeto é empacotado por valor, uma cópia serializada do objeto é enviada por limite relevante.

Remoto componentes que encapsulam sistema autônomo recursos do sistema, que são grandes ou que existe sistema autônomo instâncias isoladas devem ser empacotadas por referência.A classe base para componentes empacotado por referência é System.ComponentModel.Component. Essa classe base implementa IComponent e deriva de MarshalByRefObject. Muitos componentes no .NET Framework biblioteca de classes derivado Component, incluindo System.Windows.Forms.Control (a classe base para controles Windows Forms) System.Web.Services.WebService (a classe base para Serviços Web XML criados usando ASP.NET), e System.Timers.Timer (uma classe que gera eventos recorrentes).

Componentes remoto que simplesmente armazenar o estado devem ser empacotados por valor.A classe base para componentes empacotado por valor é System.ComponentModel.MarshalByValueComponent. Essa classe base implementa IComponent e deriva de Object. Somente alguns componentes no .NET Framework biblioteca de classes derivado MarshalByValueComponent. Todos esses componentes estão no System.Data () espaço para nomeDataColumn, DataSet, DataTable, DataView, e DataViewManager).

Observação:
As classes base para objetos que são empacotadas pelo valor e por referência são Object e MarshalByRefObject, respectivamente, mas as classes derivadas correspondentes são nomeadas MarshalByValueComponent e Component. A lógica por trás o esquema de nomeação é que o tipo mais usado tem o nome mais simples.

Se um componente não será remoto, não derivar das implementações básicas para Component; em vez disso, implementar IComponent diretamente.

Para obter mais informações sobre a comunicação remota do objeto, consulte Visão geral do .NET remoting.

Controle

Um controle é um componente que fornece recursos de interface de usuário (UI) (ou permite).The .NET Framework fornece duas classes base para controles: uma para controles Windows Forms de cliente e Outros para ASP.NET controles de servidor. Esses são System.Windows.Forms.Control e System.Web.UI.Control. Todos os controles no .NET Framework biblioteca de classes derivam direta ou indiretamente essas duas classes. System.Windows.Forms.Control deriva da Component e próprio fornece recursos de interface do usuário. System.Web.UI.Control implementa IComponent e fornece a infra-estrutura em que é fácil adicionar funcionalidade da interface do usuário.

Observação:
Todos os controles é um componente, mas o inverso não é verdade.

contêiner e o site

Se você estiver desenvolvendo componentes e controles para Windows Forms ou para páginas de Web Forms (ASP.NET páginas), não é necessário implementar contêineres ou sites. Os designers para Windows Forms e Web Forms são recipientes para Windows Forms e ASP.NET controles de servidor. Contêineres fornecem serviços de componentes e controles localizados dentro deles.No time de design, controles localizados no designer e obter serviços do designer.Para completude, as definições de um contêiner e um site são fornecidas a seguir.

• Container
  Um contêiner é uma classe que implementa o System.ComponentModel.IContainer interface ou deriva de uma classe que implementa essa interface. Um recipiente logicamente contém um ou mais componentes que são chamados do contêiner filho componentes.

• Site
  Um site é uma classe que implementa o System.ComponentModel.ISite interface ou deriva de uma classe que implementa essa interface. Sites são fornecidos por um contêiner para gerenciar e comunicar-se com seus componentes filhos.Normalmente, um contêiner e um site são implementadas sistema autônomo uma unidade.

Consulte também

Conceitos

Visão geral de propriedades

Atributos de time de design para componentes

Outros recursos

Desenvolver controles Personalizars Windows Forms com o .NET Framework

Desenvolvendo Controles Personalizados ASP.NET Server

Estendendo suporte em tempo de design