Pesquisa personalizada

A orientação a objetos, que agora temos por completo no ambiente do .NET, nos traz muitas possibilidades de criação de bibliotecas que muito nos ajudarão no trabalho com .NET.

Vamos ver um exemplo disso neste artigo, criando uma biblioteca com um fomulário que possa servir de base para outros formulários de nossa aplicação, agregando mais valor aos formulários.

Em nosso formulário base vamos inserir os seguintes recursos :

• Criação de uma coleção de Forms : No VB 6, quando desejavamos manipular todos os forms abertos em uma aplicação, utilizavamos uma coleção pública chamada Forms. No VB.NET essa coleção não existe, temos que controlar os formulários por conta própria. Mas podemos fazer isso em um formulário base, como mostrarei neste exemplo.
• Identificação do usuário do Windows : Podemos criar uma propriedade no form que indique quando o form deve ou não identificar o usuário do windows e guarda-lo para que possamos manipula-lo facilmente.
• Role based security : Podemos criar uma propriedade que ative ou desative a segurança baseada em grupos de usuários. Com a segurança ativada, podemos fazer com que o form avalie automaticamente a segurança de todos os componentes contidos no formulário.

Então vamos lá, vamos começar. Vamos começar criando um projeto de Windows Application e um projeto de Class Library dentro de uma mesma solução. Vamos trocar o nome da Class Library para libBase.

Na libBase, vamos eliminar a classe que normalmente acompanha as class librarys e vamos adicionar um formulário. Vamos também adicionar um módulo.

A coleção que vamos criar, Forms, deverá ser pública, para que seja facilmente acessível em qualquer parte da aplicação. Então vamos cria-la dentro do módulo. Veja como fica :

Public Module Colecoes
           Public Forms As New Collection
End Module

Vamos dar o nome ao nosso form base de frmBase. Precisaremos que este form se adicione automaticamente na coleção quando ele for criado e se retire automaticamente da coleção quando for fechado. Não devemos usar diretamente os eventos do form, pois isso prejudicará quem for criar forms herdados posteriormente.

Prevendo situações como essa os componentes do .NET possuem métodos criados especialmente para serem sobrescritos em um processo de herança. Para cada evento do componente existe um método equivalente, apenas adicionando "On" a frente. Por exemplo, para o evento Load temos o método "OnLoad" e para o evento "Closed" temos o método "OnClosed". Os métodos ocorrem imediatamente antes do evento e são os responsáveis por disparar os respectivos eventos.

Veja como ficaria o método OnLoad :

 Protected Overrides Sub OnLoad(ByVal e As System.EventArgs)
                Forms.Add(Me)
                MyBase.OnLoad(e)
 End Sub

Já o OnClosed é mais complexo devido a necessidade de remover o form da coleção. Para remove-lo precisamos saber o índice dele na coleção. Então a forma mais simples de fazer isso é na verdade guardarmos esse índice a partir do método "OnLoad". Veja como fica :

 Private indice As Integer
 Protected Overrides Sub OnLoad(ByVal e As System.EventArgs)
                    Forms.Add(Me)
                    indice = Forms.Count
                    MyBase.OnLoad(e)
 End Sub
           

 Protected Overrides Sub OnClosed(ByVal e As System.EventArgs)
             Forms.Remove(indice)
             MyBase.OnClosed(e)
 End Sub

Observe a chamada do MyBase em ambos os métodos. Estamos substituindo o método original. O método original é o responsável por disparar os respectivos eventos (Load, Closed). Se não chamassemos o MyBase, os eventos não mais funcionariam.

Pronto, nosso form já consegue se adicionar e remover da coleção, 1a etapa cumprida. Vamos agora fazer a identificação do usuário windows. Como citei anteriormente, podemos criar uma propriedade para determinar se quem está usando este form deseja isso ou não.

Para podermos documentar as propriedades criadas, vamos adicionar um Imports a mais ao arquivo :
         

Imports System.ComponentModel
          

Eis então a nova propriedade :

Private vWindowsUser As Boolean
           

 <Description("Determina se deve ser feita uma identificação do usuário Windows ou não")> _
 Public Property IdentificaUsuario() As Boolean
       Get
           Return (vWindowsUser)
       End Get
       Set(ByVal Value As Boolean)
            vWindowsUser = Value
       End Set
 End Property

O atributo Description será exibido na janela de propriedades, quando o usuário visualizar esta propriedade.

O usuário do Windows que será obtido é identificado como sendo um objeto do tipo WindowsPrincipal (System.Security.Principal.WindowsPrincipal) . Precisaremos de uma propriedade para que os usuários deste form possam acessar esse objeto, e precisará ser uma propriedade readOnly. Veja como fica :

Private vUser As WindowsPrincipal
 <Browsable(False)> _
 Public ReadOnly Property Usuario() As WindowsPrincipal
      Get
            Return (vUser)
      End Get
 End Property

Observe o atributo Browsable, nesta propriedade. Este atributo indica que a propriedade usuario não deverá ser visível na janela de propriedades do Visual Studio.

Agora precisamos implementar a funcionalidade desta propriedade, recuperar a identificação do usuário. Precisaremos de dois passos para isso :

• - Configurar o Application Domain para que recupere a identidade do Windows. Application Domain é, por assim dizer, o espaço de execução da aplicação.
• - Recuperar o usuário da Thread atual

Deveremos fazer isso no momento em que o form é carregado, então mudaremos novamente o método OnLoad. Veja como fica a nova versão do OnLoad :

 Protected Overrides Sub OnLoad(ByVal e As System.EventArgs)
        Forms.Add(Me)
        indice = Forms.Count
        If IdentificaUsuario Then
            AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal)
            vUser = Threading.Thread.CurrentPrincipal
        End If
        MyBase.OnLoad(e)
 End Sub

Pronto, temos a 2a etapa executada. Vamos então para a 3a etapa, validar os componentes para determinar quais estarão ou não acessíveis de acordo com o grupo ao qual o usuário pertence.

Vamos assumir um padrão para isso. Vamos assumir que quem utilizar este form irá preencher na propriedade tag dos componentes do form o nome do grupo do Windows que terá permissão de acessar o componente.

Precisaremos de 2 propriedades :

- Uma propriedade para determinar se a checagem de segurança será realizada ou não
- Outra propriedade para determinar se os objetos que o usuário não tiver permissão de visualizar deverão ser escondidos ou apenas desabilitados

Veja como ficam :

Private vOculta As ocultacmps = 1
 Private vHabilitaSeguranca As Boolean
           

 Public Enum ocultacmps
       Esconder = 1
        Desabilitar = 2
 End Enum
           

 <Description("Determina o que fazer com os componentes, se deverão ser escondidos ou desabilitados")> _
 Public Property OcultaComponentes() As ocultacmps
        Get
              Return (vOculta)
        End Get
        Set(ByVal Value As ocultacmps)
              vOculta = Value
        End Set
 End Property
           

 <Description("Determina se o form deve fazer um teste de segurança nos componentes")> _
 Public Property HabilitaSeguranca() As Boolean
       Get
           Return (vHabilitaSeguranca)
       End Get
       Set(ByVal Value As Boolean)
           If Value Then
               IdentificaUsuario = True
           End If
           vHabilitaSeguranca = Value
      End Set
 End Property

Observe que a propriedade HabilitaSeguranca, quando recebe true, habilita também a identificação do usuário. Isso porque a segurança não pode funcionar sem que a identificação do usuário esteja habilitada.

Note também a utilização de um Enum para facilitar o uso da propriedade OcultaComponentes, que possui apenas 2 valores possíveis.

Vamos então implementar um método que realize esta checagem de segurança. Precisaremos percorrer todos os componentes existentes no formulário para realizar esta checagem, e a checagem em si dependerá da proprieade OcultaComponentes. Veja como fica :

Private Sub Seguranca()
        Dim obj As System.Windows.Forms.Control
        For Each obj In Me.Controls
              If obj.Tag <> "" Then
                   If OcultaComponentes = ocultacmps.Esconder Then
                       obj.Visible = Usuario.IsInRole(obj.Tag)
                   Else
                       obj.Enabled = Usuario.IsInRole(obj.Tag)
                   End If
              End If
        Next
End Sub
         

Observe que utilizamos a propriedade usuário e o método IsInRole. Este método pertence a objetos do tipo WindowsPrincipal. Lembrando que assumimos como padrão que a propriedade Tag esteja preenchida com o nome do grupo que tem permissão de acessar o objeto. Tomamos o cuidado de verificar se o Tag está preenchida, para os casos dos objetos que todos poderão acessar.

Por fim, vamos adicionar uma chamada a este método no OnLoad e vamos ver como fica o código completo :

Public Class frmBase
       Inherits System.Windows.Forms.Form
       Private indice As Integer
       Private vHabilitaSeguranca As Boolean
       Private vWindowsUser As Boolean
       Private vUser As WindowsPrincipal
       Private vOculta As ocultacmps = 1
           

       Public Enum ocultacmps
              Esconder = 1
              Desabilitar = 2
       End Enum

       Protected Overrides Sub OnLoad(ByVal e As System.EventArgs)
                 Forms.Add(Me)
                 indice = Forms.Count
                 If IdentificaUsuario Then
                    AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal)
                    vUser = Threading.Thread.CurrentPrincipal
                    If HabilitaSeguranca Then
                        Seguranca()
                    End If
                 End If
                 MyBase.OnLoad(e)
       End Sub
           

       Protected Overrides Sub OnClosed(ByVal e As System.EventArgs)
              Forms.Remove(indice)
              MyBase.OnClosed(e)
        End Sub
           

        <Description("Determina se o form deve fazer um teste de segurança nos componentes")> _
         Public Property HabilitaSeguranca() As Boolean
               Get
                   Return (vHabilitaSeguranca)
               End Get
               Set(ByVal Value As Boolean)
                    If Value Then
                        IdentificaUsuario = True
                    End If
                    vHabilitaSeguranca = Value
               End Set
         End Property
           

         <Description("Determina se deve ser feita uma identificação do usuário Windows ou não")> _
          Public Property IdentificaUsuario() As Boolean
               Get
                   Return (vWindowsUser)
               End Get
               Set(ByVal Value As Boolean)
                    If Not Value Then
                         HabilitaSeguranca = False
                    End If
                    vWindowsUser = Value
               End Set
         End Property
           

         <Browsable(False)> _
         Public ReadOnly Property Usuario() As WindowsPrincipal
               Get
                  Return (vUser)
               End Get
         End Property
           

         Private Sub Seguranca()
                Dim obj As System.Windows.Forms.Control
                For Each obj In Me.Controls
                     If obj.Tag <> "" Then
                         If OcultaComponentes = ocultacmps.Esconder Then
                              obj.Visible = Usuario.IsInRole(obj.Tag)
                         Else
                               obj.Enabled = Usuario.IsInRole(obj.Tag)
                         End If
                    End If
               Next
         End Sub
           

         <Description("Determina o que fazer com os componentes, se deverão ser escondidos ou desabilitados")> _
          Public Property OcultaComponentes() As ocultacmps
                 Get
                     Return (vOculta)
                 End Get
                 Set(ByVal Value As ocultacmps)
                     vOculta = Value
                 End Set
          End Property
End Class

Observe ainda o detalhe adicional na propriedade IdentificaUsuario. Se a propriedade receber false a propriedade HabilitaSeguranca recebe também False, pois a segurança só pode ser testada se a identificação do usuário for realizada.

Pronto. Temos um form Base que poderemos usar em nossas aplicações. Depois de compilar a libBase podemos testar esse form no projeto Windows Application que criamos, clicando com o botão direito e selecionando a opção "Add Inherited Form". Após darmos Ok no nome do form nos será pedido para selecionar qual o form base, então selecionamos frmBase.

Uma característica interessante para se observar neste formulário é a forma como mantivemos o encapsulamento. Mesmo as propriedades internas do form não fazem acesso direto a variáveis internas (atributos), apenas acessam outras propriedades. Desta forma o código se torna de mais fácil manutenção, pois se desejarmos mudar alguma regra, teremos que aplica-la em um único local.

Isso tudo é apenas o começo. Esse formulário base pode ser muito melhorado, veja :

- A collection pode se tornar uma collection personalizada de forms
- O formulário pode permitir consulta a um banco de dados para identificar as permissões dos componentes
- O formulário pode conter um editor personalizado para editar as permissões dos componentes. Assim como o ToolTip e o ErrorProvider, que ao serem inseridos no form adicionam propriedades aos componentes presentes, podemos criar um componente que também faça isso, permitindo a edição de permissões para cada componente do form.
- E muitas outras idéias !

Por isso criei um Workspace no GotDotNet e publiquei este projeto lá. Com isso todos podem analisar o código deste projeto e contribuir para a melhoria do projeto. Participem através do endereço http://workspaces.gotdotnet.com/formBase

Dennes Torres
MCAD,MCSD,MCSE,MCDBA

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Conheça mais sobre o nosso site :

• Visite nossa área de artigos técnicos
• Conheça nossas dicas técnicas (mais de 300 dicas)
• Conheça nosso fórum de discussões
• Conheça nossa área de download com muitos componentes e códigos úteis
• Conheça nosso treinamento de lógica de programação on-line
• Conheça nossa prova de certificação em VB (oferecemos certificado aos aprovados)

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::