Utilizando CACHE do ASP.NET com MS ACCESS, em C#
Desempenho de software é um assunto que sempre desperta o meu interesse, e foi graças a isso que acabei descobrindo um dos recursos mais fantásticos disponíveis no ASP.NET, o Cache.
Todo desenvolvedor de software sabe que uma das partes mais lentas de uma aplicação é o acesso ao disco rígido, isso porque ainda trabalhamos com um modelo de disco rígido baseado em cabeça mecânica de leitura de dados e outras características que não vem ao caso. O problema é que muitas operações costumeiras durante o desenvolvimento de um software estão diretamente ligadas ao acesso a disco, como leitura e gravação de arquivos, acesso a banco de dados, etc. E foi graças a esse tipo de “gargalo” da computação que um ser iluminado do passado pensou em um recurso que ficou conhecido como Cache. Três vivas para o inventor do Cache: IoI IoI IoI.
A palavra Cache, na computação, diz respeito a uma quantidade de memória utilizada para armazenar dados temporariamente, de modo a fornecê-los rapidamente quando solicitados pelo processador sem a necessidade de acessar sua origem (muitas vezes localizada no disco rígido, que é cerca de dez vezes mais lento que a memória principal).
O Cache do ASP.NET não é diferente, é um recurso que tem como função armazenar objetos na memória principal do computador. Adicionalmente, o Cache permite a adição de dependências ao objeto guardado, de forma que se a dependência sofrer alguma alteração, o objeto contido no Cache é automaticamente destruído para que não se torne inconsistente.
Com ele, podemos criar aplicações mais rápidas, principalmente se tais aplicações necessitam de muitos acessos a um banco de dados, por exemplo.
Para explicar como funciona tudo isso, vou mostrar como desenvolver uma aplicação que carrega um banco de dados MS Access na memória principal do computador, de modo que não seja necessário acessar o disco rígido para ler as informações contidas nele caso já tenha sido carregado para o Cache. Adicionalmente esta aplicação deve manter a consistência dos dados, ou seja, se o banco de dados for atualizado pela própria aplicação ou por terceiros, o sistema deverá reconhecer automaticamente e atualizar também o Cache.
Para esta aplicação utilizei um banco de dados bem simples, criado no MS Access 2007, que consiste em uma única tabela onde será gravado o primeiro e o último nome de algumas pessoas.
Obs.: Nomeie o banco de dados como “database.accdb” e adicione-o à pasta “App_Data” do seu projeto, no Visual Studio, pois o código fonte foi desenvolvido partindo do princípio que o nosso banco está localizado lá dentro.
Primeiramente, vamos criar um método que acessa o banco de dados MS Access 2007 e retorna um DataSet já carregado com as informações que desejamos:
private System.Data.DataSet GetData(string accessFileName, string query)
{
System.Text.StringBuilder connectionString;
System.Data.DataSet dataSet;
//Initializes System.Text.StringBuilder.
connectionString = new System.Text.StringBuilder();
//Creates connection string based on file name.
connectionString.AppendFormat(@"Provider=Microsoft.ACE.OLEDB.12.0;");
connectionString.AppendFormat(@"Data Source= {0};", accessFileName);
using (System.Data.OleDb.OleDbConnection connection = new System.Data.OleDb.OleDbConnection(connectionString.ToString()))
{
//Creates System.Data.OleDb.OleDbCommand.
System.Data.OleDb.OleDbCommand command = new System.Data.OleDb.OleDbCommand(query, connection);
//Creates System.Data.OleDb.OleDbDataAdapter.
System.Data.OleDb.OleDbDataAdapter adapter = new System.Data.OleDb.OleDbDataAdapter(command);
//Initializes DataSet.
dataSet = new System.Data.DataSet();
//Fills DataSet.
adapter.Fill(dataSet);
}
//Returns data.
return dataSet;
}
Agora vem a mágica: Um método que recebe e adiciona à memória principal o objeto que será armazenado em Cache, uma chave identificadora e o arquivo físico ao qual o objeto está ligado em uma relação de dependência:
private void SetCache(string cacheKey, object item, string fileNameDependency)
{
System.Web.Caching.CacheDependency dependency;
//Creates dependency based on received file name.
dependency = new System.Web.Caching.CacheDependency(fileNameDependency);
//Stores data in the ASP.NET Cache.
Cache.Insert(cacheKey, item, dependency);
}
E finalmente, vamos interligar tudo no manipulador do evento Page_Load da nossa aplicação Web:
protected void Page_Load(object sender, EventArgs e)
{
const string cFileName = @"~/App_Data/database.accdb";
const string cQuery = @"SELECT [ID], [UserName], [LastName] FROM [User]";
const string cCacheKey = @"User";
System.Data.DataSet dsUser;
//Gets data from the ASP.NET Cache.
dsUser = (System.Data.DataSet)Cache.Get(cCacheKey);
//If data are not present...
if (dsUser == null)
{
//Gets data from database.
dsUser = this.GetData(Server.MapPath(cFileName), cQuery);
//Saves data in the ASP.NET Cache.
this.SetCache(cCacheKey, dsUser, Server.MapPath(cFileName));
}
//Shows data.
GridView1.DataSource = dsUser;
GridView1.DataBind();
}
Reparem que para simplificar a aplicação, foram criadas três constantes, sendo a primeira o caminho do arquivo de banco de dados, a segunda a query que será executada e a terceira uma chave única para identificar o nosso objeto no Cache do ASP.NET.
Para visualizar o resultado na tela, também foi adicionado um GridView à página, com o ID “GridView1”, onde serão exibidas as informações do banco.
Se preferir, clique aqui para baixar a solução completa (código fonte e banco de dados).
Para testar o funcionamento, insira um breakpoint no início do método Page_Load e rode a aplicação. Executando linha a linha, repare que inicialmente o nosso objeto ainda não existe no Cache e, por isso, retornará um DataSet nulo. Desta forma, a aplicação terá que acessar o banco de dados e trazer, pela primeira vez, as informações para o Cache.
Depois da primeira execução, dê um reload no navegador e o método Page_Load será executado novamente. Desta vez, o objeto estará presente no Cache e não será necessário acessar o banco de dados para exibir as informações na tela.
Depois da segunda execução, insira um novo registro no banco de dados (lembre-se de salvar e fechar a tabela aberta, caso faça a inserção diretamente pelo MS Access 2007). Dê um reload no navegador e note que ao procurar o nosso objeto no Cache ele não existe mais. Isso porque o ASP.NET detectou que o arquivo sofreu alteração e removeu da memória as informações armazenadas. Neste caso, a aplicação irá retornar ao banco de dados para recarregar os dados na memória.
Fantástico, não?!
Essa tecnologia pode ser aplicada a qualquer tipo de banco de dados baseado em arquivo, como Firebird, SQLite ou mesmo XML, arquivos MS Excel ou de texto. Existe também a possibilidade de utilizar este recurso em conjunto com o SQL Server 2005 ou superior, mas isso eu mostro em outro artigo… ;)
Baixar o código fonte completo.
