Criação de uma Camada de Acesso a Dados (VB)

por Scott Mitchell

Baixar PDF

Neste tutorial, começaremos do início e criaremos a Camada de Acesso a Dados (DAL), usando DataSets tipados, para acessar as informações em um banco de dados.

Introdução

Como desenvolvedores web, nossas vidas giram em torno de trabalhar com dados. Criamos bancos de dados para armazenar os dados, código para recuperá-los e modificá-los e páginas da web para coletá-los e resumi-los. Este é o primeiro tutorial de uma longa série que explorará técnicas para implementar esses padrões comuns no ASP.NET 2.0. Começaremos com a criação de uma arquitetura de software composta por uma DAL (Camada de Acesso a Dados) usando DataSets Tipados, uma BLL (Camada de Lógica de Negócios) que impõe regras de negócios personalizadas e uma camada de apresentação composta por ASP.NET páginas que compartilham um layout de página comum. Depois que essa base de back-end for estabelecida, passaremos para os relatórios, mostrando como exibir, resumir, coletar e validar dados de um aplicativo da web. Esses tutoriais são voltados para serem concisos e fornecem instruções passo a passo com muitas capturas de tela para orientá-lo visualmente no processo. Cada tutorial está disponível nas versões C# e Visual Basic e inclui um download do código completo usado. (Este primeiro tutorial é bastante longo, mas o resto é apresentado em partes muito mais digeríveis.)

Para esses tutoriais, usaremos uma versão do Microsoft SQL Server 2005 Express Edition do banco de dados Northwind colocado no App_Data diretório. Além do arquivo do banco de dados, a App_Data pasta também contém os scripts SQL para criar o banco de dados, caso você queira usar uma versão diferente do banco de dados. Se você usar uma versão diferente do SQL Server do banco de dados Northwind, precisará atualizar a NORTHWNDConnectionString configuração no arquivo do Web.config aplicativo. O aplicativo Web foi criado usando o Visual Studio 2005 Professional Edition como um projeto de site baseado em sistema de arquivos. No entanto, todos os tutoriais funcionarão igualmente bem com a versão gratuita do Visual Studio 2005, Visual Web Developer.

Neste tutorial, começaremos do início e criaremos a DAL (Camada de Acesso a Dados), seguida pela criação da BLL (Camada de Lógica de Negócios) no segundo tutorial e trabalharemos no layout e na navegação da página no terceiro. Os tutoriais após o terceiro serão construídos sobre a base estabelecida nos três primeiros. Temos muito o que abordar neste primeiro tutorial, então inicie o Visual Studio e vamos começar!

Etapa 1: Criando um projeto Web e conectando-se ao banco de dados

Antes de podermos criar nossa Camada de Acesso a Dados (DAL), primeiro precisamos criar um site e configurar nosso banco de dados. Comece criando um novo site de ASP.NET baseado em sistema de arquivos. Para fazer isso, vá para o menu Arquivo e escolha Novo Site, exibindo a caixa de diálogo Novo Site. Escolha o modelo ASP.NET Site, defina a lista suspensa Local como Sistema de Arquivos, escolha uma pasta para colocar o site e defina o idioma como Visual Basic.

Figura 1: Criar um novo site baseado no sistema de arquivos (clique para exibir a imagem em tamanho real)

Isso criará um novo site com uma Default.aspx página ASP.NET, uma App_Data pasta e um Web.config arquivo.

Com o site criado, a próxima etapa é adicionar uma referência ao banco de dados no Gerenciador de Servidores do Visual Studio. Ao adicionar um banco de dados ao Gerenciador de Servidores, você pode adicionar tabelas, procedimentos armazenados, exibições e assim por diante, tudo de dentro do Visual Studio. Você também pode exibir dados de tabela ou criar suas próprias consultas manualmente ou graficamente por meio do Construtor de consultas. Além disso, quando criarmos os Conjuntos de Dados Tipados para a DAL, precisaremos apontar o Visual Studio para o banco de dados do qual os Conjuntos de Dados Tipados devem ser construídos. Embora possamos fornecer essas informações de conexão nesse momento, o Visual Studio preenche automaticamente uma lista suspensa dos bancos de dados já registrados no Gerenciador de Servidores.

As etapas para adicionar o banco de dados Northwind ao Gerenciador de Servidores dependem se você deseja usar o banco de dados SQL Server 2005 Express Edition na App_Data pasta ou se você tem uma configuração de servidor de banco de dados do Microsoft SQL Server 2000 ou 2005 que deseja usar.

Usando um banco de dados naApp_Datapasta

Se você não tiver um servidor de banco de dados SQL Server 2000 ou 2005 para se conectar, ou simplesmente quiser evitar a necessidade de adicionar o banco de dados a um servidor de banco de dados, poderá usar a versão SQL Server 2005 Express Edition do banco de dados Northwind que está localizada na pasta do site baixado App_Data (NORTHWND.MDF).

Um banco de dados colocado na App_Data pasta é adicionado automaticamente ao Gerenciador de Servidores. Supondo que você tenha o SQL Server 2005 Express Edition instalado em seu computador, você deverá ver um nó chamado NORTHWND. MDF no Gerenciador de Servidores, que você pode expandir e explorar suas tabelas, exibições, procedimento armazenado e assim por diante (consulte a Figura 2).

A App_Data pasta também pode conter arquivos do Microsoft Access .mdb , que, como seus equivalentes do SQL Server, são adicionados automaticamente ao Gerenciador de Servidores. Se você não quiser usar nenhuma das opções do SQL Server, sempre poderá instalar o banco de dados e os aplicativos da Northwind Traders e soltar no App_Data diretório. No entanto, lembre-se de que os bancos de dados do Access não são tão ricos em recursos quanto o SQL Server e não foram projetados para serem usados em cenários de site. Além disso, alguns dos 35+ tutoriais utilizarão certos recursos no nível do banco de dados que não são suportados pelo Access.

Conectando-se ao banco de dados em um servidor de banco de dados do Microsoft SQL Server 2000 ou 2005

Como alternativa, você pode se conectar a um banco de dados Northwind instalado em um servidor de banco de dados. Se o servidor de banco de dados ainda não tiver o banco de dados Northwind instalado, primeiro você deverá adicioná-lo ao servidor de banco de dados executando o script de instalação incluído no download deste tutorial.

Depois de instalar o banco de dados, vá para o Gerenciador de Servidores no Visual Studio, clique com o botão direito do mouse no nó Conexões de Dados e escolha Adicionar Conexão. Se você não vir o Gerenciador de Servidores, vá para Exibir / Gerenciador de Servidores ou pressione Ctrl+Alt+S. Isso abrirá a caixa de diálogo Adicionar Conexão, onde você pode especificar o servidor ao qual se conectar, as informações de autenticação e o nome do banco de dados. Depois de configurar com êxito as informações de conexão do banco de dados e clicar no botão OK, o banco de dados será adicionado como um nó abaixo do nó Conexões de Dados. Você pode expandir o nó do banco de dados para explorar suas tabelas, exibições, procedimentos armazenados e assim por diante.

Figura 2: Adicionar uma conexão ao banco de dados Northwind do servidor de banco de dados

Etapa 2: Criando a camada de acesso a dados

Ao trabalhar com dados, uma opção é incorporar a lógica específica de dados diretamente na camada de apresentação (em um aplicativo Web, as páginas ASP.NET compõem a camada de apresentação). Isso pode assumir a forma de escrever ADO.NET código na parte de código da página ASP.NET ou usar o controle SqlDataSource da parte de marcação. Em ambos os casos, essa abordagem acopla fortemente a lógica de acesso a dados com a camada de apresentação. A abordagem recomendada, no entanto, é separar a lógica de acesso a dados da camada de apresentação. Essa camada separada é chamada de Camada de Acesso a Dados, DAL para abreviar, e normalmente é implementada como um projeto separado da Biblioteca de Classes. Os benefícios dessa arquitetura em camadas estão bem documentados (consulte a seção "Leituras adicionais" no final deste tutorial para obter informações sobre essas vantagens) e é a abordagem que adotaremos nesta série.

Todo o código específico da fonte de dados subjacente, como criar uma conexão com o banco de dados, emitir SELECTcomandos , INSERT, , UPDATEe DELETE assim por diante, deve estar localizado no DAL. A camada de apresentação não deve conter nenhuma referência a esse código de acesso a dados, mas deve fazer chamadas para a DAL para toda e qualquer solicitação de dados. As Camadas de Acesso a Dados normalmente contêm métodos para acessar os dados do banco de dados subjacente. O banco de dados Northwind, por exemplo, possui Products tabelas e Categories que registram os produtos à venda e as categorias às quais pertencem. Em nosso DAL, teremos métodos como:

• GetCategories(), que retornará informações sobre todas as categorias
• GetProducts(), que retornará informações sobre todos os produtos
• GetProductsByCategoryID(categoryID), que retornará todos os produtos que pertencem a uma categoria especificada
• GetProductByProductID(productID), que retornará informações sobre um determinado produto

Esses métodos, quando invocados, se conectarão ao banco de dados, emitirão a consulta apropriada e retornarão os resultados. A forma como retornamos esses resultados é importante. Esses métodos podem simplesmente retornar um DataSet ou DataReader preenchido pela consulta de banco de dados, mas o ideal é que esses resultados sejam retornados usando objetos fortemente tipados. Um objeto fortemente tipado é aquele cujo esquema é rigidamente definido em tempo de compilação, enquanto o oposto, um objeto de tipo flexível, é aquele cujo esquema não é conhecido até o tempo de execução.

Por exemplo, o DataReader e o DataSet (por padrão) são objetos de tipo flexível, pois seu esquema é definido pelas colunas retornadas pela consulta de banco de dados usada para preenchê-los. Para acessar uma coluna específica de uma DataTable de tipo livre, precisamos usar sintaxe como: DataTable.Rows(index)("columnName"). A digitação flexível do DataTable neste exemplo é exibida pelo fato de que precisamos acessar o nome da coluna usando uma cadeia de caracteres ou índice ordinal. Uma DataTable fortemente tipada, por outro lado, terá cada uma de suas colunas implementadas como propriedades, resultando em um código que se parece com: DataTable.Rows(index).columnName.

Para retornar objetos fortemente tipados, os desenvolvedores podem criar seus próprios objetos de negócios personalizados ou usar Typed DataSets. Um objeto de negócios é implementado pelo desenvolvedor como uma classe cujas propriedades geralmente refletem as colunas da tabela de banco de dados subjacente que o objeto de negócios representa. Um Conjunto de Dados Tipado é uma classe gerada para você pelo Visual Studio com base em um esquema de banco de dados e cujos membros são fortemente tipados de acordo com esse esquema. O próprio Conjunto de Dados Tipado consiste em classes que estendem as classes ADO.NET DataSet, DataTable e DataRow. Além de DataTables fortemente tipados, os DataSets tipados agora também incluem TableAdapters, que são classes com métodos para preencher as DataTables do DataSet e propagar modificações dentro das DataTables de volta para o banco de dados.

Observação

Para obter mais informações sobre as vantagens e desvantagens de usar Conjuntos de Dados Tipados versus objetos de negócios personalizados, consulte Projetando Componentes da Camada de Dados e Passando Dados por Camadas.

Usaremos DataSets fortemente tipados para a arquitetura desses tutoriais. A Figura 3 ilustra o fluxo de trabalho entre as diferentes camadas de um aplicativo que usa Typed DataSets.

Figura 3: Todo o código de acesso a dados é relegado ao DAL (clique para exibir a imagem em tamanho real)

Criando um conjunto de dados tipado e um adaptador de tabela

Para começar a criar nosso DAL, começamos adicionando um Conjunto de Dados Tipado ao nosso projeto. Para fazer isso, clique com o botão direito do mouse no nó do projeto no Gerenciador de Soluções e escolha Adicionar um Novo Item. Selecione a opção DataSet na lista de modelos e nomeie-a Northwind.xsd.

Figura 4: Escolha adicionar um novo conjunto de dados ao seu projeto (clique para exibir a imagem em tamanho real)

Depois de clicar em Adicionar, quando solicitado a adicionar o DataSet à App_Code pasta, escolha Sim. O Designer do Conjunto de Dados Tipado será exibido e o Assistente de Configuração do TableAdapter será iniciado, permitindo que você adicione seu primeiro TableAdapter ao Conjunto de Dados Tipado.

Um conjunto de dados tipado serve como uma coleção de dados fortemente tipada; ele é composto por instâncias DataTable fortemente tipadas, cada uma das quais, por sua vez, é composta por instâncias DataRow fortemente tipadas. Criaremos uma DataTable fortemente tipada para cada uma das tabelas de banco de dados subjacentes com as quais precisamos trabalhar nesta série de tutoriais. Vamos começar criando uma DataTable para a Products tabela.

Lembre-se de que DataTables fortemente tipados não incluem nenhuma informação sobre como acessar dados de sua tabela de banco de dados subjacente. Para recuperar os dados para preencher o DataTable, usamos uma classe TableAdapter, que funciona como nossa camada de acesso a dados. Para nossa Products DataTable, o TableAdapter conterá os métodos GetProducts(), GetProductByCategoryID(categoryID), e assim por diante que invocaremos a partir da camada de apresentação. A função do DataTable é servir como os objetos fortemente tipados usados para passar dados entre as camadas.

O Assistente de Configuração do TableAdapter começa solicitando que você selecione com qual banco de dados trabalhar. A lista suspensa mostra esses bancos de dados no Gerenciador de Servidores. Se você não adicionou o banco de dados Northwind ao Gerenciador de Servidores, poderá clicar no botão Nova Conexão neste momento para fazer isso.

Figura 5: Escolha o banco de dados Northwind na lista suspensa (clique para exibir a imagem em tamanho real)

Depois de selecionar o banco de dados e clicar em Avançar, você será perguntado se deseja salvar a cadeia de conexão no Web.config arquivo. Ao salvar a cadeia de conexão, você evitará que ela seja codificada nas classes TableAdapter, o que simplifica as coisas se as informações da cadeia de conexão forem alteradas no futuro. Se você optar por salvar a cadeia de conexão no arquivo de configuração, ela será colocada na <connectionStrings> seção, que pode ser opcionalmente criptografada para melhorar a segurança ou modificada posteriormente por meio da nova Página de Propriedades do ASP.NET 2.0 na Ferramenta de Administração de GUI do IIS, que é mais ideal para administradores.

Figura 6: Salvar a cadeia de conexão em Web.config (clique para exibir a imagem em tamanho real)

Em seguida, precisamos definir o esquema para o primeiro DataTable fortemente tipado e fornecer o primeiro método para nosso TableAdapter usar ao preencher o DataSet fortemente tipado. Essas duas etapas são realizadas simultaneamente criando uma consulta que retorna as colunas da tabela que queremos refletir em nossa DataTable. No final do assistente, daremos um nome de método a essa consulta. Depois que isso for feito, esse método poderá ser invocado em nossa camada de apresentação. O método executará a consulta definida e preencherá uma DataTable fortemente tipada.

Para começar a definir a consulta SQL, devemos primeiro indicar como queremos que o TableAdapter emita a consulta. Podemos usar uma instrução SQL ad hoc, criar um novo procedimento armazenado ou usar um procedimento armazenado existente. Para esses tutoriais, usaremos instruções SQL ad hoc.

Figura 7: Consultar os dados usando uma instrução SQL ad hoc (clique para exibir a imagem em tamanho real)

Neste ponto, podemos digitar a consulta SQL manualmente. Ao criar o primeiro método no TableAdapter, você normalmente deseja que a consulta retorne as colunas que precisam ser expressas na DataTable correspondente. Podemos fazer isso criando uma consulta que retorna todas as colunas e todas as linhas da Products tabela:

Figura 8: Insira a consulta SQL na caixa de texto (clique para exibir a imagem em tamanho real)

Como alternativa, use o Construtor de Consultas e construa graficamente a consulta, como mostra a Figura 9.

Figura 9: Criar a consulta graficamente, por meio do Editor de Consultas (clique para exibir a imagem em tamanho real)

Depois de criar a consulta, mas antes de passar para a próxima tela, clique no botão Opções Avançadas. Em Projetos de Site, "Gerar instruções Insert, Update e Delete" é a única opção avançada selecionada por padrão; se você executar esse assistente em uma Biblioteca de Classes ou em um Projeto do Windows, a opção "Usar simultaneidade otimista" também será selecionada. Deixe a opção "Usar simultaneidade otimista" desmarcada por enquanto. Examinaremos a simultaneidade otimista em tutoriais futuros.

Figura 10: Selecione apenas a opção Gerar instruções de inserção, atualização e exclusão (clique para exibir a imagem em tamanho real)

Depois de verificar as opções avançadas, clique em Avançar para prosseguir para a tela final. Aqui, somos solicitados a selecionar quais métodos adicionar ao TableAdapter. Há dois padrões para preencher dados:

• Preencher uma DataTable com essa abordagem: é criado um método que usa uma DataTable como parâmetro e a preenche com base nos resultados da consulta. A classe ADO.NET DataAdapter, por exemplo, implementa esse padrão com seu Fill() método.
• Retornar uma DataTable com essa abordagem, o método cria e preenche a DataTable para você e a retorna como o valor de retorno dos métodos.

Você pode fazer com que o TableAdapter implemente um ou ambos os padrões. Você também pode renomear os métodos fornecidos aqui. Vamos deixar as duas caixas de seleção marcadas, embora usemos apenas o último padrão ao longo desses tutoriais. Além disso, vamos renomear o método bastante genérico GetData para GetProducts.

Se marcada, a caixa de seleção final, "GenerateDBDirectMethods", cria Insert(), Update()e métodos Delete() para o TableAdapter. Se você deixar essa opção desmarcada, todas as atualizações precisarão ser feitas por meio do método exclusivo Update() do TableAdapter, que usa o Conjunto de Dados Tipado, um DataTable, um único DataRow ou uma matriz de DataRows. (Se você tiver desmarcado a opção "Generate Insert, Update, and Delete statements" nas propriedades avançadas na Figura 9, a configuração dessa caixa de seleção não terá efeito.) Vamos deixar esta caixa de seleção marcada.

Figura 11: Alterar o nome do método de GetData para GetProducts (clique para exibir a imagem em tamanho real)

Conclua o assistente clicando em Concluir. Depois que o assistente fechar, retornaremos ao DataSet Designer, que mostra a DataTable que acabamos de criar. Você pode ver a lista de colunas na Products DataTable (ProductID, ProductName, e assim por diante), bem como os métodos de ProductsTableAdapter (Fill() e GetProducts()).

Figura 12: A Products DataTable e ProductsTableAdapter foram adicionadas ao conjunto de dados tipado (clique para exibir a imagem em tamanho real)

Neste ponto, temos um Typed DataSet com um único DataTable (Northwind.Products) e uma classe DataAdapter fortemente tipada (NorthwindTableAdapters.ProductsTableAdapter) com um GetProducts() método. Esses objetos podem ser usados para acessar uma lista de todos os produtos de código como:

Dim productsAdapter As New NorthwindTableAdapters.ProductsTableAdapter()
Dim products as Northwind.ProductsDataTable
products = productsAdapter.GetProducts()
For Each productRow As Northwind.ProductsRow In products
    Response.Write("Product: " & productRow.ProductName & "<br />")
Next

Esse código não exigia que escrevêssemos um pouco de código específico de acesso a dados. Não precisávamos instanciar nenhuma classe ADO.NET, não precisávamos nos referir a nenhuma cadeia de conexão, consultas SQL ou procedimentos armazenados. Em vez disso, o TableAdapter fornece o código de acesso a dados de baixo nível para nós.

Cada objeto usado neste exemplo também é fortemente tipado, permitindo que o Visual Studio forneça IntelliSense e verificação de tipo em tempo de compilação. E o melhor de tudo é que as DataTables retornadas pelo TableAdapter podem ser associadas a ASP.NET controles Web de dados, como GridView, DetailsView, DropDownList, CheckBoxList e vários outros. O exemplo a seguir ilustra a associação do DataTable retornado pelo GetProducts() método a um GridView em apenas três linhas de código dentro do Page_Load manipulador de eventos.

AllProducts.aspx

<%@ Page Language="VB" AutoEventWireup="true" CodeFile="AllProducts.aspx.vb"
    Inherits="AllProducts" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>View All Products in a GridView</title>
    <link href="Styles.css" rel="stylesheet" type="text/css" />
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <h1>
            All Products</h1>
        <p>
            <asp:GridView ID="GridView1" runat="server"
             CssClass="DataWebControlStyle">
               <HeaderStyle CssClass="HeaderStyle" />
               <AlternatingRowStyle CssClass="AlternatingRowStyle" />
            </asp:GridView>
             </p>
    </div>
    </form>
</body>
</html>

AllProducts.aspx.vb

Imports NorthwindTableAdapters
Partial Class AllProducts
    Inherits System.Web.UI.Page
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) _
        Handles Me.Load
        Dim productsAdapter As New ProductsTableAdapter
        GridView1.DataSource = productsAdapter.GetProducts()
        GridView1.DataBind()
    End Sub
End Class

Figura 13: A lista de produtos é exibida em um GridView (clique para exibir a imagem em tamanho real)

Embora este exemplo exija que escrevamos três linhas de código no manipulador de Page_Load eventos da nossa página ASP.NET, em tutoriais futuros, examinaremos como usar o ObjectDataSource para recuperar declarativamente os dados do DAL. Com o ObjectDataSource, não precisaremos escrever nenhum código e também teremos suporte para paginação e classificação!

Etapa 3: Adicionando métodos parametrizados à camada de acesso a dados

Neste ponto, nossa ProductsTableAdapter classe tem apenas um método, GetProducts(), que retorna todos os produtos no banco de dados. Embora ser capaz de trabalhar com todos os produtos seja definitivamente útil, há momentos em que queremos recuperar informações sobre um produto específico ou todos os produtos que pertencem a uma categoria específica. Para adicionar essa funcionalidade à nossa Camada de Acesso a Dados, podemos adicionar métodos parametrizados ao TableAdapter.

Vamos adicionar o GetProductsByCategoryID(categoryID) método. Para adicionar um novo método ao DAL, retorne ao DataSet Designer, clique com o botão direito do ProductsTableAdapter mouse na seção e escolha Adicionar consulta.

Figura 14: Clique com o botão direito do mouse no TableAdapter e escolha Adicionar consulta

Primeiro, somos questionados sobre se queremos acessar o banco de dados usando uma instrução SQL ad hoc ou um procedimento armazenado novo ou existente. Vamos optar por usar uma instrução SQL ad-hoc novamente. Em seguida, somos questionados sobre que tipo de consulta SQL gostaríamos de usar. Como queremos retornar todos os produtos que pertencem a uma categoria especificada, queremos escrever uma SELECT instrução que retorne linhas.

Figura 15: Escolha criar uma SELECT instrução que retorna linhas (clique para exibir a imagem em tamanho real)

A próxima etapa é definir a consulta SQL usada para acessar os dados. Como queremos retornar apenas os produtos que pertencem a uma categoria específica, uso a mesma SELECT instrução de GetProducts(), mas adiciono a seguinte WHERE cláusula: WHERE CategoryID = @CategoryID. O @CategoryID parâmetro indica ao assistente TableAdapter que o método que estamos criando exigirá um parâmetro de entrada do tipo correspondente (ou seja, um inteiro anulável).

Figura 16: Insira uma consulta para retornar apenas produtos em uma categoria especificada (clique para exibir a imagem em tamanho real)

Na etapa final, podemos escolher quais padrões de acesso a dados usar, bem como personalizar os nomes dos métodos gerados. Para o padrão Fill, vamos alterar o nome para FillByCategoryID e para retornar um padrão de retorno DataTable (os GetX métodos), vamos usar GetProductsByCategoryID.

Figura 17: Escolher os nomes para os métodos TableAdapter (clique para exibir a imagem em tamanho completo)

Depois de concluir o assistente, o DataSet Designer inclui os novos métodos TableAdapter.

Figura 18: Os produtos agora podem ser consultados por categoria

Reserve um momento para adicionar um GetProductByProductID(productID) método usando a mesma técnica.

Essas consultas parametrizadas podem ser testadas diretamente do DataSet Designer. Clique com o botão direito do mouse no método no TableAdapter e escolha Visualizar dados. Em seguida, insira os valores a serem usados para os parâmetros e clique em Visualizar.

Figura 19: Os produtos pertencentes à categoria Bebidas são mostrados (Clique para visualizar a imagem em tamanho real)

Com o GetProductsByCategoryID(categoryID) método em nosso DAL, agora podemos criar uma página ASP.NET que exibe apenas os produtos em uma categoria especificada. O exemplo a seguir mostra todos os produtos que estão na categoria Bebidas, que têm um CategoryID de 1.

Beverages.aspx

<%@ Page Language="VB" AutoEventWireup="true" CodeFile="Beverages.aspx.vb"
    Inherits="Beverages" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Untitled Page</title>
    <link href="Styles.css" rel="stylesheet" type="text/css" />
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <h1>Beverages</h1>
        <p>
            <asp:GridView ID="GridView1" runat="server"
             CssClass="DataWebControlStyle">
               <HeaderStyle CssClass="HeaderStyle" />
               <AlternatingRowStyle CssClass="AlternatingRowStyle" />
            </asp:GridView>
             </p>
    </div>
    </form>
</body>
</html>

Beverages.aspx.vb

Imports NorthwindTableAdapters
Partial Class Beverages
    Inherits System.Web.UI.Page
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) _
        Handles Me.Load
        Dim productsAdapter As New ProductsTableAdapter
        GridView1.DataSource =
         productsAdapter.GetProductsByCategoryID(1)
        GridView1.DataBind()
    End Sub
End Class

Figura 20: Os produtos da categoria Bebidas são exibidos (clique para exibir a imagem em tamanho real)

Etapa 4: Inserir, atualizar e excluir dados

Há dois padrões comumente usados para inserir, atualizar e excluir dados. O primeiro padrão, que chamarei de padrão direto do banco de dados, envolve a criação de métodos que, quando invocados, emitem um INSERTcomando , UPDATEou DELETE para o banco de dados que opera em um único registro de banco de dados. Esses métodos normalmente são passados em uma série de valores escalares (inteiros, cadeias de caracteres, booleanos, DateTimes e assim por diante) que correspondem aos valores a serem inseridos, atualizados ou excluídos. Por exemplo, com esse padrão para a Products tabela, o método delete receberia um parâmetro inteiro, indicando o ProductID registro a ser excluído, enquanto o método insert usaria uma cadeia de caracteres para o ProductName, um decimal para o UnitPrice, um inteiro para o UnitsOnStock, e assim por diante.

Figura 21: Cada solicitação de inserção, atualização e exclusão é enviada ao banco de dados imediatamente (clique para exibir a imagem em tamanho real)

O outro padrão, ao qual me referirei como padrão de atualização em lote, é atualizar um DataSet, DataTable ou coleção inteira de DataRows em uma chamada de método. Com esse padrão, um desenvolvedor exclui, insere e modifica as DataRows em uma DataTable e, em seguida, passa essas DataRows ou DataTable para um método de atualização. Em seguida, esse método enumera as DataRows passadas, determina se elas foram ou não modificadas, adicionadas ou excluídas (por meio do valor da propriedade RowState da DataRow) e emite a solicitação de banco de dados apropriada para cada registro.

Figura 22: Todas as alterações são sincronizadas com o banco de dados quando o método de atualização é invocado (clique para exibir a imagem em tamanho real)

O TableAdapter usa o padrão de atualização em lote por padrão, mas também dá suporte ao padrão direto do banco de dados. Como selecionamos a opção "Gerar instruções Insert, Update e Delete" nas Propriedades Avançadas ao criar nosso TableAdapter, o ProductsTableAdapter contém um Update() método, que implementa o padrão de atualização em lote. Especificamente, o TableAdapter contém um Update() método que pode ser passado o Typed DataSet, um DataTable fortemente tipado ou um ou mais DataRows. Se você deixou a caixa de seleção "GenerateDBDirectMethods" marcada ao criar o TableAdapter pela primeira vez, o padrão direto do banco de dados também será implementado por meio de Insert(), Update(), e métodos Delete() .

Ambos os padrões de modificação de InsertCommanddados usam as propriedades , UpdateCommand, and e DeleteCommand do TableAdapter para emitir seus INSERTcomandos , UPDATEe para DELETE o banco de dados. Você pode inspecionar e modificar as InsertCommandpropriedades , UpdateCommande DeleteCommand e clicando no TableAdapter no DataSet Designer e, em seguida, indo para a janela Propriedades. (Verifique se você selecionou o TableAdapter e se o ProductsTableAdapter objeto é o selecionado na lista suspensa na janela Propriedades.)

Figura 23: O TableAdapter tem InsertCommand, UpdateCommande Properties DeleteCommand (clique para exibir a imagem em tamanho real)

Para examinar ou modificar qualquer uma dessas propriedades de comando de banco de dados, clique na CommandText subpropriedade, que abrirá o Construtor de Consultas.

Figura 24: Configurar as INSERTinstruções , UPDATEe no DELETE Construtor de Consultas (clique para exibir a imagem em tamanho real)

O exemplo de código a seguir mostra como usar o padrão de atualização em lote para dobrar o preço de todos os produtos que não foram descontinuados e que têm 25 unidades em estoque ou menos:

Dim productsAdapter As New NorthwindTableAdapters.ProductsTableAdapter()
Dim products As Northwind.ProductsDataTable = productsAdapter.GetProducts()
For Each product As Northwind.ProductsRow In products
   If Not product.Discontinued AndAlso product.UnitsInStock <= 25 Then
      product.UnitPrice *= 2
   End if
Next
productsAdapter.Update(products)

O código a seguir ilustra como usar o padrão direto do banco de dados para excluir programaticamente um produto específico, atualizar um e adicionar um novo:

Dim productsAdapter As New NorthwindTableAdapters.ProductsTableAdapter()
productsAdapter.Delete(3)
productsAdapter.Update( _
    "Chai", 1, 1, "10 boxes x 20 bags", 18.0, 39, 15, 10, false, 1)
productsAdapter.Insert( _
    "New Product", 1, 1, "12 tins per carton", 14.95, 15, 0, 10, false)

Criando métodos personalizados de inserção, atualização e exclusão

Os Insert()métodos , Update(), e Delete() criados pelo método direto do banco de dados podem ser um pouco complicados, especialmente para tabelas com muitas colunas. Olhando para o exemplo de código anterior, sem a ajuda do IntelliSense, não fica particularmente claro qual Products coluna da tabela é mapeada para cada parâmetro de entrada para os Update() métodos and Insert() . Pode haver momentos em que queremos atualizar apenas uma ou duas colunas, ou queremos um método personalizado Insert() que, talvez, retorne o valor do campo (incremento IDENTITY automático) do registro recém-inserido.

Para criar esse método personalizado, retorne ao Designer de Conjunto de Dados. Clique com o botão direito do mouse no TableAdapter e escolha Add Query, retornando ao assistente TableAdapter. Na segunda tela podemos indicar o tipo de consulta a ser criada. Vamos criar um método que adiciona um novo produto e, em seguida, retorna o valor do registro ProductID. Portanto, opte por criar uma INSERT consulta.

Figura 25: Criar um método para adicionar uma nova linha à tabela (clique para exibir a Products imagem em tamanho real)

Na próxima tela, o InsertCommand's CommandText aparece. Aumente essa consulta adicionando SELECT SCOPE_IDENTITY() no final da consulta, o que retornará o último valor de identidade inserido em uma IDENTITY coluna no mesmo escopo. (Consulte a documentação técnica para obter mais informações sobre SCOPE_IDENTITY() e por que você provavelmente deseja usar SCOPE_IDENTITY() em vez de @@IDENTITY.) Certifique-se de terminar a instrução com um ponto-e-vírgula INSERT antes de adicioná-la SELECT .

Figura 26: Aumentar a consulta para retornar o valor (clique para exibir a SCOPE_IDENTITY() imagem em tamanho real)

Por fim, nomeie o novo método InsertProduct.

Figura 27: Defina o novo nome do método como InsertProduct (clique para exibir a imagem em tamanho real)

Ao retornar ao DataSet Designer, você verá que o ProductsTableAdapter contém um novo método, InsertProduct. Se esse novo método não tiver um parâmetro para cada coluna na tabela, é provável que você tenha esquecido de encerrar a INSERT instrução com um ponto-e-vírgulaProducts. Configure o InsertProduct método e verifique se você tem um ponto-e-vírgula delimitando as INSERT instruções and SELECT .

Por padrão, os métodos de inserção emitem métodos que não são de consulta, o que significa que eles retornam o número de linhas afetadas. No entanto, queremos que o InsertProduct método retorne o valor retornado pela consulta, não o número de linhas afetadas. Para fazer isso, ajuste a propriedade do InsertProduct ExecuteMode método para Scalar.

Figura 28: Alterar a ExecuteMode propriedade para Scalar (clique para exibir a imagem em tamanho real)

O código a seguir mostra esse novo InsertProduct método em ação:

Dim productsAdapter As New NorthwindTableAdapters.ProductsTableAdapter()
Dim new_productID As Integer = Convert.ToInt32(productsAdapter.InsertProduct( _
    "New Product", 1, 1, "12 tins per carton", 14.95, 10, 0, 10, false))
productsAdapter.Delete(new_productID)

Etapa 5: Concluindo a camada de acesso a dados

Observe que a ProductsTableAdapters classe retorna os CategoryID valores e SupplierID da Products tabela, mas não inclui a CategoryName coluna da Categories tabela ou a CompanyName coluna da Suppliers tabela, embora essas sejam provavelmente as colunas que queremos exibir ao mostrar informações do produto. Podemos aumentar o método inicial do TableAdapter, GetProducts(), para incluir os valores de CategoryName coluna e CompanyName , o que atualizará o DataTable fortemente tipado para incluir essas novas colunas também.

No entanto, isso pode representar um problema, pois os métodos do TableAdapter para inserir, atualizar e excluir dados são baseados nesse método inicial. Felizmente, os métodos gerados automaticamente para inserir, atualizar e excluir não são afetados por subconsultas na SELECT cláusula. Ao ter o cuidado de adicionar nossas consultas a Categories e Suppliers como subconsultas, em vez de JOIN s, evitaremos ter que retrabalhar esses métodos para modificar dados. Clique com o ProductsTableAdapter botão direito do GetProducts() mouse no método e escolha Configurar. Em seguida, ajuste a SELECT cláusula para que ela se pareça com:

SELECT     ProductID, ProductName, SupplierID, CategoryID,
QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder, ReorderLevel, Discontinued,
(SELECT CategoryName FROM Categories
WHERE Categories.CategoryID = Products.CategoryID) as CategoryName,
(SELECT CompanyName FROM Suppliers
WHERE Suppliers.SupplierID = Products.SupplierID) as SupplierName
FROM         Products

Figura 29: Atualizar a SELECT instrução para o método (clique para exibir a GetProducts() imagem em tamanho completo)

Depois de atualizar o GetProducts() método para usar essa nova consulta, o DataTable incluirá duas novas colunas: CategoryName e SupplierName.

Figura 30: A Products DataTable tem duas novas colunas

Reserve um momento para atualizar a SELECT GetProductsByCategoryID(categoryID) cláusula no método também.

Se você atualizar a GetProducts() SELECT sintaxe using JOIN , o DataSet Designer não poderá gerar automaticamente os métodos para inserir, atualizar e excluir dados do banco de dados usando o padrão direto do banco de dados. Em vez disso, você terá que criá-los manualmente, assim como fizemos com o InsertProduct método anteriormente neste tutorial. Além disso, você terá que fornecer manualmente os valores de InsertCommandpropriedade , UpdateCommande DeleteCommand se quiser usar o padrão de atualização em lote.

Adicionando os TableAdapters restantes

Até agora, só vimos como trabalhar com um único TableAdapter para uma única tabela de banco de dados. No entanto, o banco de dados Northwind contém várias tabelas relacionadas com as quais precisaremos trabalhar em nosso aplicativo Web. Um Conjunto de Dados Tipado pode conter várias DataTables relacionadas. Portanto, para concluir nossa DAL, precisamos adicionar DataTables para as outras tabelas que usaremos nesses tutoriais. Para adicionar um novo TableAdapter a um Conjunto de Dados Tipado, abra o Designer de Conjunto de Dados, clique com o botão direito do mouse no Designer e escolha Adicionar/TableAdapter. Isso criará um novo DataTable e TableAdapter e orientará você pelo assistente que examinamos anteriormente neste tutorial.

Reserve alguns minutos para criar os seguintes TableAdapters e métodos usando as consultas a seguir. Observe que as consultas no ProductsTableAdapter incluem as subconsultas para obter a categoria de cada produto e os nomes dos fornecedores. Além disso, se você estiver acompanhando, já adicionou a classe GetProducts() e GetProductsByCategoryID(categoryID) os ProductsTableAdapter métodos.

• ProdutosTableAdapter

  • Obter produtos:

    SELECT     ProductID, ProductName, SupplierID, 
    CategoryID, QuantityPerUnit, UnitPrice, UnitsInStock, 
    UnitsOnOrder, ReorderLevel, Discontinued, 
    (SELECT CategoryName FROM Categories WHERE
    Categories.CategoryID = Products.CategoryID) as 
    CategoryName, (SELECT CompanyName FROM Suppliers
    WHERE Suppliers.SupplierID = Products.SupplierID) 
    as SupplierName
    FROM         Products
    

  • GetProductsByCategoryID:

    SELECT     ProductID, ProductName, SupplierID, CategoryID,
    QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder,
    ReorderLevel, Discontinued, (SELECT CategoryName
    FROM Categories WHERE Categories.CategoryID = 
    Products.CategoryID) as CategoryName,
    (SELECT CompanyName FROM Suppliers WHERE
    Suppliers.SupplierID = Products.SupplierID)
    as SupplierName
    FROM         Products
    WHERE      CategoryID = @CategoryID
    

  • GetProductsBySupplierID:

    SELECT     ProductID, ProductName, SupplierID, CategoryID,
    QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder,
    ReorderLevel, Discontinued, (SELECT CategoryName
    FROM Categories WHERE Categories.CategoryID = 
    Products.CategoryID) as CategoryName, 
    (SELECT CompanyName FROM Suppliers WHERE 
    Suppliers.SupplierID = Products.SupplierID) as SupplierName
    FROM         Products
    WHERE SupplierID = @SupplierID
    

  • GetProductByProductID:

    SELECT     ProductID, ProductName, SupplierID, CategoryID,
    QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder,
    ReorderLevel, Discontinued, (SELECT CategoryName 
    FROM Categories WHERE Categories.CategoryID = 
    Products.CategoryID) as CategoryName, 
    (SELECT CompanyName FROM Suppliers WHERE Suppliers.SupplierID = Products.SupplierID) 
    as SupplierName
    FROM         Products
    WHERE ProductID = @ProductID
    

• CategoriasTabelaAdaptador

  • GetCategories:

    SELECT     CategoryID, CategoryName, Description
    FROM         Categories
    

  • GetCategoryByCategoryID:

    SELECT     CategoryID, CategoryName, Description
    FROM         Categories
    WHERE CategoryID = @CategoryID
    

• SuppliersTableAdapter

  • Obter fornecedores:

    SELECT     SupplierID, CompanyName, Address,
    City, Country, Phone
    FROM         Suppliers
    

  • GetSuppliersByCountry:

    SELECT     SupplierID, CompanyName, Address,
    City, Country, Phone
    FROM         Suppliers
    WHERE Country = @Country
    

  • GetSupplierBySupplierID:

    SELECT     SupplierID, CompanyName, Address,
    City, Country, Phone
    FROM         Suppliers
    WHERE SupplierID = @SupplierID
    

• EmployeesTableAdapter

  • Obter funcionários:

    SELECT     EmployeeID, LastName, FirstName, Title,
    HireDate, ReportsTo, Country
    FROM         Employees
    

  • GetEmployeesByManager:

    SELECT     EmployeeID, LastName, FirstName, Title, 
    HireDate, ReportsTo, Country
    FROM         Employees
    WHERE ReportsTo = @ManagerID
    

  • GetEmployeeByEmployeeID:

    SELECT     EmployeeID, LastName, FirstName, Title,
    HireDate, ReportsTo, Country
    FROM         Employees
    WHERE EmployeeID = @EmployeeID
    

Figura 31: O designer de conjunto de dados após a adição dos quatro TableAdapters (clique para exibir a imagem em tamanho real)

Adicionando código personalizado à DAL

Os TableAdapters e DataTables adicionados ao Conjunto de Dados Tipado são expressos como um arquivo de Definição de Esquema XML (Northwind.xsd). Você pode exibir essas informações de esquema clicando com o botão direito do Northwind.xsd mouse no arquivo no Gerenciador de Soluções e escolhendo Exibir Código.

Figura 32: O arquivo XSD (definição de esquema XML) para o conjunto de dados tipado Northwinds (clique para exibir a imagem em tamanho real)

Essas informações de esquema são convertidas em código C# ou Visual Basic em tempo de design quando compiladas ou em tempo de execução (se necessário), momento em que você pode percorrê-las com o depurador. Para exibir esse código gerado automaticamente, vá para o Modo de Exibição de Classe e faça uma busca detalhada nas classes TableAdapter ou Typed DataSet. Se você não vir a Visualização de Classe na tela, vá para o menu Exibir e selecione-a a partir daí ou pressione Ctrl+Shift+C. No Modo de Exibição de Classe, você pode ver as propriedades, os métodos e os eventos das classes Typed DataSet e TableAdapter. Para exibir o código de um método específico, clique duas vezes no nome do método na Exibição de Classe ou clique com o botão direito do mouse nele e escolha Ir para Definição.

Figura 33: Inspecionar o código gerado automaticamente selecionando Ir para definição na exibição de classe

Embora o código gerado automaticamente possa economizar muito tempo, o código geralmente é muito genérico e precisa ser personalizado para atender às necessidades exclusivas de um aplicativo. O risco de estender o código gerado automaticamente, no entanto, é que a ferramenta que gerou o código pode decidir que é hora de "regenerar" e substituir suas personalizações. Com o novo conceito de classe parcial do .NET 2.0, é fácil dividir uma classe em vários arquivos. Isso nos permite adicionar nossos próprios métodos, propriedades e eventos às classes geradas automaticamente sem ter que nos preocupar com o Visual Studio substituindo nossas personalizações.

Para demonstrar como personalizar o DAL, vamos adicionar um GetProducts() método à SuppliersRow classe. A SuppliersRow classe representa um único registro na Suppliers tabela; cada fornecedor pode fornecer de zero a muitos produtos, portanto GetProducts() , retornará esses produtos do fornecedor especificado. Para fazer isso, crie um novo arquivo de classe na App_Code pasta nomeada SuppliersRow.vb e adicione o seguinte código:

Imports NorthwindTableAdapters
Partial Public Class Northwind
    Partial Public Class SuppliersRow
        Public Function GetProducts() As Northwind.ProductsDataTable
            Dim productsAdapter As New ProductsTableAdapter
            Return productsAdapter.GetProductsBySupplierID(Me.SupplierID)
        End Function
    End Class
End Class

Essa classe parcial instrui o compilador que, ao criar a classe, Northwind.SuppliersRow inclua o GetProducts() método que acabamos de definir. Se você criar seu projeto e retornar ao Modo de Exibição de Classe, verá GetProducts() agora listado como um método de Northwind.SuppliersRow.

Figura 34: O GetProducts() método agora faz parte da Northwind.SuppliersRow classe

O GetProducts() método agora pode ser usado para enumerar o conjunto de produtos para um fornecedor específico, como mostra o código a seguir:

Dim suppliersAdapter As New NorthwindTableAdapters.SuppliersTableAdapter()
Dim suppliers As Northwind.SuppliersDataTable = suppliersAdapter.GetSuppliers()
For Each supplier As Northwind.SuppliersRow In suppliers
    Response.Write("Supplier: " & supplier.CompanyName)
    Response.Write("<ul>")
    Dim products As Northwind.ProductsDataTable = supplier.GetProducts()
    For Each product As Northwind.ProductsRow In products
        Response.Write("<li>" & product.ProductName & "</li>")
    Next
    Response.Write("</ul><p> </p>")
Next

Esses dados também podem ser exibidos em qualquer um dos aplicativos ASP. NET da Web. A página a seguir usa um controle GridView com dois campos:

• Um BoundField que exibe o nome de cada fornecedor e
• Um TemplateField que contém um controle BulletedList que está associado aos resultados retornados pelo GetProducts() método para cada fornecedor.

Examinaremos como exibir esses relatórios de detalhes mestres em tutoriais futuros. Por enquanto, este exemplo foi projetado para ilustrar o uso do método personalizado adicionado à Northwind.SuppliersRow classe.

SuppliersAndProducts.aspx

<%@ Page Language="VB" CodeFile="SuppliersAndProducts.aspx.vb"
    AutoEventWireup="true" Inherits="SuppliersAndProducts" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Untitled Page</title>
    <link href="Styles.css" rel="stylesheet" type="text/css" />
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <h1>
            Suppliers and Their Products</h1>
        <p>
            <asp:GridView ID="GridView1" runat="server"
             AutoGenerateColumns="False"
             CssClass="DataWebControlStyle">
                <HeaderStyle CssClass="HeaderStyle" />
                <AlternatingRowStyle CssClass="AlternatingRowStyle" />
                <Columns>
                    <asp:BoundField DataField="CompanyName"
                      HeaderText="Supplier" />
                    <asp:TemplateField HeaderText="Products">
                        <ItemTemplate>
                            <asp:BulletedList ID="BulletedList1"
                             runat="server" DataSource="<%# CType(CType(Container.DataItem, System.Data.DataRowView).Row, Northwind.SuppliersRow).GetProducts() %>"
                                 DataTextField="ProductName">
                            </asp:BulletedList>
                        </ItemTemplate>
                    </asp:TemplateField>
                </Columns>
            </asp:GridView>
             </p>
    </div>
    </form>
</body>
</html>

SuppliersAndProducts.aspx.vb

Imports NorthwindTableAdapters
Partial Class SuppliersAndProducts
    Inherits System.Web.UI.Page
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) _
        Handles Me.Load
        Dim suppliersAdapter As New SuppliersTableAdapter
        GridView1.DataSource = suppliersAdapter.GetSuppliers()
        GridView1.DataBind()
    End Sub
End Class

Figura 35: O nome da empresa do fornecedor está listado na coluna da esquerda, seus produtos à direita (clique para exibir a imagem em tamanho real)

Resumo

Ao criar um aplicativo da web, a criação da DAL deve ser uma das primeiras etapas, ocorrendo antes de você começar a criar sua camada de apresentação. Com o Visual Studio, criar uma DAL com base em Typed DataSets é uma tarefa que pode ser realizada em 10 a 15 minutos sem escrever uma linha de código. Os tutoriais daqui para frente se basearão neste DAL. No próximo tutorial, definiremos várias regras de negócios e veremos como implementá-las em uma camada lógica de negócios separada.

Boa programação!

Leitura Adicional

Para obter mais informações sobre os tópicos discutidos neste tutorial, consulte os seguintes recursos:

• Criando uma DAL usando TableAdapters e DataTables fortemente tipados no VS 2005 e no ASP.NET 2.0
• Projetando componentes da camada de dados e passando dados entre camadas
• Criptografando informações de configuração em aplicativos ASP.NET 2.0
• Visão geral de TableAdapter
• Trabalhando com um conjunto de dados tipado
• Usando o acesso a dados fortemente tipado no Visual Studio 2005 e no ASP.NET 2.0
• Como estender os métodos do TableAdapter

Treinamento em vídeo sobre tópicos contidos neste tutorial

• Camadas de Acesso a Dados em aplicativos do ASP.NET
• Como associar manualmente um conjunto de dados a uma grade de dados
• Como trabalhar com conjuntos de dados e filtros de um aplicativo ASP

Sobre o autor

Scott Mitchell, autor de sete livros ASP/ASP.NET e fundador da 4GuysFromRolla.com, trabalha com tecnologias da Web da Microsoft desde 1998. Scott trabalha como consultor, instrutor e escritor independente. Seu último livro é Sams Teach Yourself ASP.NET 2.0 em 24 horas. Ele pode ser contatado em mitchell@4GuysFromRolla.com. ou através de seu blog, que pode ser encontrado em http://ScottOnWriting.NET.

Agradecimentos especiais a

Esta série de tutoriais foi revisada por muitos revisores úteis. Os principais revisores deste tutorial foram Ron Green, Hilton Giesenow, Dennis Patterson, Liz Shulok, Abel Gomez e Carlos Santos. Interessado em revisar meus próximos artigos do MSDN? Em caso afirmativo, envie-me uma mensagem para mitchell@4GuysFromRolla.com.

AnteriorAvançar