A idéia básica do conceito de Code Behind é fazer a separação entre o código responsável pela lógica de processamento da página ASP.NET e o código responsável pela apresentação da página. A apresentação é o que o usuário recebe de volta no seu navegador. Para que os resultados estejam corretos, é necessário que a lógica da página tenha sido implementada corretamente. Esta lógica pode ser implementada na própria página, na seção de código ou em um arquivo separado, quando então estamos utilizando o conceito de Code Behind. Para ter acesso ao código gravado em um arquivo separado, fazemos uma referência ao arquivo, nas páginas onde iremos utilizálo.

O arquivo com o código responsável pela lógica, pode ser criado com qualquer linguagem habilitada ao .NET. Por exemplo, pode ser um arquivo com a extensão .vb, criado com o VB.NET ou um arquivo com a extensão .cs, criado com o C#. Na página, onde o arquivo .vb ou .cs deve ser utilizado, devemos incluir uma referência ao mesmo, utilizando as cláusulas Inherits e Src, na diretiva @Page, conforme exemplo a seguir:

<%  @Page Language=”C#” Inherits=”NomeDaClasse” Src=”Caminho para o arquivo” %>

Considere o exemplo:

<% @Page Language=”C#” Inherits=”Conecta”  Src=”Conecta.cs” %>

Vamos a um exemplo prático, onde colocaremos o código responsável por fazer a conexão com o banco de dados NorthWind.mdb em um arquivo chamado conecta.cs. Neste arquivo criaremos uma classe chamada Conecta. Em seguida criaremos uma página ASP.NET que faz uso do código contido no arquivo conecta.cs.

Na Listagem 15.4 temos o código para o arquivo conecta.cs.

Listagem 15.4 – Arquivo com o código de conexão.

using System;
                   using System.Data;
                   using System.Data.OleDb;
                   using System.Web.UI;
                   using System.Web.UI.WebControls;

public class Conecta : Page
     
                   {

//  Variável pública que faz referência ao controle DataGrid.

public  DataGrid MinhaGrade1;

 public  void Page_Load(Object Src, EventArgs E ) 
     
      {

      String DefineConexão=  "PROVIDER=MICROSOFT.JET.OLEDB.4.0;" +
                                          "DATA SOURCE=c:\\meus  documentos\\NorthWind.mdb";

      OleDbConnection  MinhaConexão = new OleDbConnection(DefineConexão);

       String auxSQL1;
          String auxSQL2;
          String auxSQL3;
          String ComandoSQL;
         
         auxSQL1= "SELECT  CódigoDoCliente,NomeDaEmpresa,Endereço,Telefone,País";
         auxSQL2= " FROM Clientes Where  País='Brasil'";
         auxSQL3= " Order By  NomeDaEmpresa";
         
         ComandoSQL= auxSQL1+auxSQL2+auxSQL3;
         
         OleDbDataAdapter MeuComando = new  OleDbDataAdapter(ComandoSQL, MinhaConexão);

      DataSet ds = new  DataSet();
         MeuComando.Fill(ds,"Clientes");

      DataView source = new  DataView(ds.Tables[0]);
         
          MinhaGrade1.DataSource = source ;
         MinhaGrade1.DataBind();
         
      }
}

O mecanismo de Code Behind é baseado na idéia de herança. Observe, pelo código da Listagem 15.4 que criamos uma nova classe chamada Conecta. A classe Conecta é baseada na classe Page. Isto é feito, porque a classe Conecta será herdade pelas páginas ASP.NET onde a classe for utilizada. Como será herdada por páginas ASP.NET, a classe Conecta é definida como do tipo Page, que é a classe básica para todas as páginas ASP.NET. Além disso utilizamos uma série de diretivas using, para fazer referência aos namespaces utilizados pela classe:

using System;
using System.Data;
using System.Data.OleDb;
using System.Web.UI;
using System.Web.UI.WebControls;

public class Conecta : Page

Em seguida declaramos uma variável pública do tipo DataGrid. A declaração desta variável é necessária para que possamos fazer a ligação dos dados do objeto DataView, criado no procedimento Page_Load, com o controle DataGrid, da página que irá utilizar o código da classe Conecta.

public DataGrid MinhaGrade1;

Em seguida criamos um procedimento para o evento Page_Load. O código deste procedimento simplesmente faz a conexão com o banco de dados NorthWind.mdb e retorna alguns campos da tabela Clientes. Em seguida estes dados são exibidos em um controle DataGrid.

Agora vamos criar uma página ASP.NET que utiliza o código da classe Conecta, contido no arquivo conecta.cs. Considere o código da Listagem 15.5.

Listagem 15.5 – Utilizando a classe Conecta.

<%@ Page Language="C#"  Inherits="Conecta" Src="conecta.cs" %>

<html>
<body>
       <HR>
      <B> Exemplo de  utilização de "Code Behind".</B>
      <HR>
      <ASP:DataGrid 
               id="MinhaGrade1" 
               runat="server"
               Width="500"
               BackColor="#c0c0c0" 
               BorderColor="black"
               ShowFooter="false" 
               CellPadding=3 
               CellSpacing="0"
               Font-Name="Verdana"
               Font-Bold="True"
               Font-Size="7pt"
               HeaderStyle-BackColor="#aaaadd"
               MaintainState="false"
      />
      
       <HR>

</body>
</html>

Digite o código da Listagem 15.5 e salve o mesmo em um arquivo chamado chap15ex4.aspx, na pasta chap15, dentro da pasta wwwroot, conforme descrito no item: “Check List para acompanhar os exemplos deste livro”, no Capítulo 6.

Para acessar esta página utilize o seguinte endereço:

http://localhost/chap12/chap15ex4.aspx

Ao carregar a página você obtém o resultado indicado na Figura 15.9.

Figura 15.9 Utilizando Code Behind.

Para acessarmos a classe Conecta, utilizamos a diretiva @Page, conforme indicado a seguir:

<%@ Page Language="C#"  Inherits="Conecta" Src="conecta.cs" %>

Como o arquivo conecta.cs está na mesma pasta da página Chap15ex4.aspx, informamos somente o nome do arquivo. Caso o arquivo .cs estivesse em uma subpasta, digamos Codigos, da pasta onde está a página .aspx, teríamos que informar o caminho completo, conforme indicado no exemplo a seguir:

<%@  Page Language="C#" Inherits="Conecta"  Src="Codigos\conecta.cs" %>

A utilização de Code Behind traz inúmeras vantagens, dentre as quais podemos destacar:

• Separação entre a lógica e a apresentação da página.
• Reaproveitamento de código, através do mecanismo de herança.
• Facilidade de manutenção. Podemos codificar uma funcionalidade, que será utilizada por diversas páginas, em um arquivo de código separado, como no nosso exemplo, criamos a classe Conecta, definida no arquivo conecta.cs. Quando uma página ASP.NET precisa utilizar a lógica contida na classe Conecta, basta fazer referência ao arquivo conecta.cs, utilizando a diretiva @Page, conforme exemplificado anteriormente. Quando forem necessárias alterações na lógica da classe Conecta, basta que façamos as alterações no arquivo conecta.cs e, todas as páginas que utilizam a classe Conecta, passarão a acessar a versão modificada. Se tivéssemos colocado o código da classe Conecta, na seção de código de cada página, no momento de fazer alterações teríamos que fazê-las em cada uma das páginas, o que tornaria o processo de manutenção e atualização bem mais complexo e oneroso.

O mecanismo de Code Behind demonstra, mais uma vez, o fato de os conceitos de Orientação a Objetos estarem presentes em todos os aspectos do Framework .NET. A possibilidade de codificar a lógica em uma classe separada e poder utilizar esta lógica em uma ou mais páginas ASP.NET nada mais é do que a implementação prática do conceito de reaproveitamento de código em aplicações Web.