Criação de uma camada de lógica de negócios (VB)
por Scott Mitchell
Neste tutorial, veremos como centralizar suas regras de negócios em uma BLL (Camada lógica de negócios) que serve como um intermediário para a troca de dados entre a camada de apresentação e o DAL.
Introdução
A DAL (Camada de Acesso a Dados) criada no primeiro tutorial separa de forma limpa a lógica de acesso a dados da lógica de apresentação. No entanto, embora o DAL separe de forma limpa os detalhes de acesso a dados da camada de apresentação, ele não impõe nenhuma regra de negócios que possa ser aplicada. Por exemplo, para nosso aplicativo, talvez queiramos não permitir que os CategoryID campos ou SupplierID da Products tabela sejam modificados quando o Discontinued campo estiver definido como 1, ou talvez queiramos impor regras de antiguidade, proibindo situações em que um funcionário é gerenciado por alguém que foi contratado depois deles. Outro cenário comum é a autorização talvez apenas os usuários em uma função específica possam excluir produtos ou alterar o UnitPrice valor.
Neste tutorial, veremos como centralizar essas regras de negócios em uma BLL (Camada lógica de negócios) que serve como um intermediário para a troca de dados entre a camada de apresentação e o DAL. Em um aplicativo do mundo real, a BLL deve ser implementada como um projeto separado da Biblioteca de Classes; no entanto, para esses tutoriais, implementaremos a BLL como uma série de classes em nossa App_Code pasta para simplificar a estrutura do projeto. A Figura 1 ilustra as relações arquitetônicas entre a camada de apresentação, a BLL e a DAL.
Figura 1: A BLL separa a camada de apresentação da camada de acesso a dados e impõe regras de negócios
Em vez de criar classes separadas para implementar nossa lógica de negócios, poderíamos, como alternativa, colocar essa lógica diretamente no Conjunto de Dados Digitado com classes parciais. Para obter um exemplo de criação e extensão de um Conjunto de Dados Tipado, consulte o primeiro tutorial.
Etapa 1: Criando as classes BLL
Nossa BLL será composta por quatro classes, uma para cada TableAdapter no DAL; cada uma dessas classes BLL terá métodos para recuperar, inserir, atualizar e excluir do respectivo TableAdapter no DAL, aplicando as regras de negócios apropriadas.
Para separar de forma mais limpa as classes relacionadas a DAL e BLL, vamos criar duas subpastas na App_Code pasta DAL e BLL. Basta clicar com o botão direito do App_Code mouse na pasta no Gerenciador de Soluções e escolher Nova Pasta. Depois de criar essas duas pastas, mova o Conjunto de Dados Digitado criado no primeiro tutorial para a DAL subpasta.
Em seguida, crie os quatro arquivos de classe BLL na BLL subpasta. Para fazer isso, clique com o botão direito do BLL mouse na subpasta, escolha Adicionar um Novo Item e escolha o modelo Classe. Nomeie as quatro classes ProductsBLL, CategoriesBLL, SuppliersBLLe EmployeesBLL.
Figura 2: Adicionar quatro novas classes à App_Code pasta
Em seguida, vamos adicionar métodos a cada uma das classes para simplesmente encapsular os métodos definidos para o TableAdapters do primeiro tutorial. Por enquanto, esses métodos chamarão diretamente para o DAL; retornaremos mais tarde para adicionar qualquer lógica de negócios necessária.
Observação
Se você estiver usando o Visual Studio Standard Edition ou superior (ou seja, não está usando o Visual Web Developer), opcionalmente, poderá projetar suas classes visualmente usando a Designer classe. Consulte o Blog de Designer de Classe para obter mais informações sobre esse novo recurso no Visual Studio.
Para a ProductsBLL classe, precisamos adicionar um total de sete métodos:
GetProducts()retorna todos os produtosGetProductByProductID(productID)retorna o produto com a ID do produto especificadaGetProductsByCategoryID(categoryID)retorna todos os produtos da categoria especificadaGetProductsBySupplier(supplierID)retorna todos os produtos do fornecedor especificadoAddProduct(productName, supplierID, categoryID, quantityPerUnit, unitPrice, unitsInStock, unitsOnOrder, reorderLevel, discontinued)insere um novo produto no banco de dados usando os valores passados; retorna oProductIDvalor do registro recém-inseridoUpdateProduct(productName, supplierID, categoryID, quantityPerUnit, unitPrice, unitsInStock, unitsOnOrder, reorderLevel, discontinued, productID)atualiza um produto existente no banco de dados usando os valores passados; retornaráTruese precisamente uma linha tiver sido atualizada, caso contrário,FalseDeleteProduct(productID)exclui o produto especificado do banco de dados
ProductsBLL.vb
Imports NorthwindTableAdapters
<System.ComponentModel.DataObject()> _
Public Class ProductsBLL
Private _productsAdapter As ProductsTableAdapter = Nothing
Protected ReadOnly Property Adapter() As ProductsTableAdapter
Get
If _productsAdapter Is Nothing Then
_productsAdapter = New ProductsTableAdapter()
End If
Return _productsAdapter
End Get
End Property
<System.ComponentModel.DataObjectMethodAttribute _
(System.ComponentModel.DataObjectMethodType.Select, True)> _
Public Function GetProducts() As Northwind.ProductsDataTable
Return Adapter.GetProducts()
End Function
<System.ComponentModel.DataObjectMethodAttribute _
(System.ComponentModel.DataObjectMethodType.Select, False)> _
Public Function GetProductByProductID(ByVal productID As Integer) _
As Northwind.ProductsDataTable
Return Adapter.GetProductByProductID(productID)
End Function
<System.ComponentModel.DataObjectMethodAttribute _
(System.ComponentModel.DataObjectMethodType.Select, False)> _
Public Function GetProductsByCategoryID(ByVal categoryID As Integer) _
As Northwind.ProductsDataTable
Return Adapter.GetProductsByCategoryID(categoryID)
End Function
<System.ComponentModel.DataObjectMethodAttribute _
(System.ComponentModel.DataObjectMethodType.Select, False)> _
Public Function GetProductsBySupplierID(ByVal supplierID As Integer) _
As Northwind.ProductsDataTable
Return Adapter.GetProductsBySupplierID(supplierID)
End Function
<System.ComponentModel.DataObjectMethodAttribute _
(System.ComponentModel.DataObjectMethodType.Insert, True)> _
Public Function AddProduct( _
productName As String, supplierID As Nullable(Of Integer), _
categoryID As Nullable(Of Integer), quantityPerUnit As String, _
unitPrice As Nullable(Of Decimal), unitsInStock As Nullable(Of Short), _
unitsOnOrder As Nullable(Of Short), reorderLevel As Nullable(Of Short), _
discontinued As Boolean) _
As Boolean
Dim products As New Northwind.ProductsDataTable()
Dim product As Northwind.ProductsRow = products.NewProductsRow()
product.ProductName = productName
If Not supplierID.HasValue Then
product.SetSupplierIDNull()
Else
product.SupplierID = supplierID.Value
End If
If Not categoryID.HasValue Then
product.SetCategoryIDNull()
Else
product.CategoryID = categoryID.Value
End If
If quantityPerUnit Is Nothing Then
product.SetQuantityPerUnitNull()
Else
product.QuantityPerUnit = quantityPerUnit
End If
If Not unitPrice.HasValue Then
product.SetUnitPriceNull()
Else
product.UnitPrice = unitPrice.Value
End If
If Not unitsInStock.HasValue Then
product.SetUnitsInStockNull()
Else
product.UnitsInStock = unitsInStock.Value
End If
If Not unitsOnOrder.HasValue Then
product.SetUnitsOnOrderNull()
Else
product.UnitsOnOrder = unitsOnOrder.Value
End If
If Not reorderLevel.HasValue Then
product.SetReorderLevelNull()
Else
product.ReorderLevel = reorderLevel.Value
End If
product.Discontinued = discontinued
products.AddProductsRow(product)
Dim rowsAffected As Integer = Adapter.Update(products)
Return rowsAffected = 1
End Function
<System.ComponentModel.DataObjectMethodAttribute _
(System.ComponentModel.DataObjectMethodType.Update, True)> _
Public Function UpdateProduct(_
productName As String, supplierID As Nullable(Of Integer), _
categoryID As Nullable(Of Integer), quantityPerUnit As String, _
unitPrice As Nullable(Of Decimal), unitsInStock As Nullable(Of Short), _
unitsOnOrder As Nullable(Of Short), reorderLevel As Nullable(Of Short), _
discontinued As Boolean, productID As Integer) _
As Boolean
Dim products As Northwind.ProductsDataTable = _
Adapter.GetProductByProductID(productID)
If products.Count = 0 Then
Return False
End If
Dim product as Northwind.ProductsRow = products(0)
product.ProductName = productName
If Not supplierID.HasValue Then
product.SetSupplierIDNull()
Else
product.SupplierID = supplierID.Value
End If
If Not categoryID.HasValue Then
product.SetCategoryIDNull()
Else
product.CategoryID = categoryID.Value
End If
If quantityPerUnit Is Nothing Then
product.SetQuantityPerUnitNull()
Else
product.QuantityPerUnit = quantityPerUnit
End If
If Not unitPrice.HasValue Then
product.SetUnitPriceNull()
Else
product.UnitPrice = unitPrice.Value
End If
If Not unitsInStock.HasValue Then
product.SetUnitsInStockNull()
Else
product.UnitsInStock = unitsInStock.Value
End If
If Not unitsOnOrder.HasValue Then
product.SetUnitsOnOrderNull()
Else
product.UnitsOnOrder = unitsOnOrder.Value
End If
If Not reorderLevel.HasValue Then
product.SetReorderLevelNull()
Else
product.ReorderLevel = reorderLevel.Value
End If
product.Discontinued = discontinued
Dim rowsAffected As Integer = Adapter.Update(product)
Return rowsAffected = 1
End Function
<System.ComponentModel.DataObjectMethodAttribute _
(System.ComponentModel.DataObjectMethodType.Delete, True)> _
Public Function DeleteProduct(ByVal productID As Integer) As Boolean
Dim rowsAffected As Integer = Adapter.Delete(productID)
Return rowsAffected = 1
End Function
End Class
Os métodos que simplesmente retornam dados GetProducts, GetProductByProductID, GetProductsByCategoryIDe GetProductBySuppliersID são bastante simples, pois simplesmente são chamados para baixo no DAL. Embora em alguns cenários possa haver regras de negócios que precisam ser implementadas nesse nível (como regras de autorização com base no usuário conectado no momento ou na função à qual o usuário pertence), simplesmente deixaremos esses métodos no estado em que se encontra. Para esses métodos, a BLL serve apenas como um proxy por meio do qual a camada de apresentação acessa os dados subjacentes da Camada de Acesso a Dados.
Os AddProduct métodos e UpdateProduct assumem como parâmetros os valores dos vários campos de produto e adicionam um novo produto ou atualizam um existente, respectivamente. Como muitas das Product colunas da tabela podem aceitar NULL valores (CategoryID, SupplierID, e UnitPrice, para citar alguns), esses parâmetros de entrada para AddProduct e UpdateProduct que são mapeados para essas colunas usam tipos anuláveis. Tipos anuláveis são novos no .NET 2.0 e fornecem uma técnica para indicar se um tipo de valor deve, em vez disso, ser Nothing. Consulte a entrada de blog de Paul VickThe Truth About Nullable Types and VB e a documentação técnica da estrutura anulável para obter mais informações.
Todos os três métodos retornam um valor booliano que indica se uma linha foi inserida, atualizada ou excluída, pois a operação pode não resultar em uma linha afetada. Por exemplo, se o desenvolvedor da página chamar DeleteProduct passando um para um ProductID produto inexistente, a DELETE instrução emitida para o banco de dados não terá nenhum efeito e, portanto, o DeleteProduct método retornará False.
Observe que, ao adicionar um novo produto ou atualizar um existente, usamos os valores de campo do produto novo ou modificado como uma lista de escalares em vez de aceitar uma ProductsRow instância. Essa abordagem foi escolhida porque a ProductsRow classe deriva da classe ADO.NET DataRow , que não tem um construtor sem parâmetros padrão. Para criar uma nova ProductsRow instância, devemos primeiro criar uma ProductsDataTable instância e, em seguida, invocar seu NewProductRow() método (o que fazemos em AddProduct). Essa deficiência levanta a cabeça quando recorremos à inserção e atualização de produtos usando o ObjectDataSource. Em suma, o ObjectDataSource tentará criar uma instância dos parâmetros de entrada. Se o método BLL espera uma ProductsRow instância, o ObjectDataSource tentará criar uma, mas falhará devido à falta de um construtor sem parâmetros padrão. Para obter mais informações sobre esse problema, consulte as duas postagens dos Fóruns ASP.NET a seguir: Atualizando ObjectDataSources com Strongly-Typed DataSets e Problema com ObjectDataSource e Strongly-Typed DataSet.
Em seguida, no AddProduct e UpdateProductno , o código cria uma ProductsRow instância e a preenche com os valores passados. Ao atribuir valores a DataColumns de um DataRow, várias verificações de validação no nível do campo podem ocorrer. Portanto, colocar manualmente os valores passados de volta em um DataRow ajuda a garantir a validade dos dados que estão sendo passados para o método BLL. Infelizmente, as classes DataRow fortemente tipados geradas pelo Visual Studio não usam tipos anuláveis. Em vez disso, para indicar que um DataColumn específico em um DataRow deve corresponder a um NULL valor de banco de dados, devemos usar o SetColumnNameNull() método .
Em UpdateProduct , primeiro, carregamos no produto para atualizar usando GetProductByProductID(productID). Embora isso possa parecer uma viagem desnecessária ao banco de dados, essa viagem extra será útil em tutoriais futuros que exploram a simultaneidade otimista. A simultaneidade otimista é uma técnica para garantir que dois usuários que estão trabalhando simultaneamente nos mesmos dados não substituam acidentalmente as alterações uns dos outros. A captura de todo o registro também facilita a criação de métodos de atualização na BLL que modificam apenas um subconjunto das colunas do DataRow. Quando explorarmos a SuppliersBLL classe, veremos esse exemplo.
Por fim, observe que a ProductsBLL classe tem o atributo DataObject aplicado a ela (a [System.ComponentModel.DataObject] sintaxe logo antes da instrução de classe próxima à parte superior do arquivo) e os métodos têm atributos DataObjectMethodAttribute. O DataObject atributo marca a classe como sendo um objeto adequado para associação a um controle ObjectDataSource, enquanto o indica a DataObjectMethodAttribute finalidade do método. Como veremos em tutoriais futuros, o ObjectDataSource do ASP.NET 2.0 facilita o acesso declarativo a dados de uma classe. Para ajudar a filtrar a lista de classes possíveis a serem associadas no assistente do ObjectDataSource, por padrão, somente as classes marcadas como DataObjects são mostradas na lista suspensa do assistente. A ProductsBLL classe funcionará tão bem sem esses atributos, mas adicioná-los facilita o trabalho no assistente do ObjectDataSource.
Adicionando as outras classes
Com a ProductsBLL classe concluída, ainda precisamos adicionar as classes para trabalhar com categorias, fornecedores e funcionários. Reserve um momento para criar as seguintes classes e métodos usando os conceitos do exemplo acima:
CategoriesBLL.cs
GetCategories()GetCategoryByCategoryID(categoryID)
SuppliersBLL.cs
GetSuppliers()GetSupplierBySupplierID(supplierID)GetSuppliersByCountry(country)UpdateSupplierAddress(supplierID, address, city, country)
EmployeesBLL.cs
GetEmployees()GetEmployeeByEmployeeID(employeeID)GetEmployeesByManager(managerID)
O único método que vale a pena observar é o SuppliersBLL método da UpdateSupplierAddress classe. Esse método fornece uma interface para atualizar apenas as informações de endereço do fornecedor. Internamente, esse método lê no SupplierDataRow objeto para o especificado supplierID (usando GetSupplierBySupplierID), define suas propriedades relacionadas ao endereço e, em seguida, chama para baixo no SupplierDataTablemétodo 's Update . O UpdateSupplierAddress método segue:
<System.ComponentModel.DataObjectMethodAttribute _
(System.ComponentModel.DataObjectMethodType.Update, True)> _
Public Function UpdateSupplierAddress(ByVal supplierID As Integer, _
ByVal address As String, ByVal city As String, ByVal country As String) _
As Boolean
Dim suppliers As Northwind.SuppliersDataTable = _
Adapter.GetSupplierBySupplierID(supplierID)
If suppliers.Count = 0 Then
Return False
Else
Dim supplier As Northwind.SuppliersRow = suppliers(0)
If address Is Nothing Then
supplier.SetAddressNull()
Else
supplier.Address = address
End If
If city Is Nothing Then
supplier.SetCityNull()
Else
supplier.City = city
End If
If country Is Nothing Then
supplier.SetCountryNull()
Else
supplier.Country = country
End If
Dim rowsAffected As Integer = Adapter.Update(supplier)
Return rowsAffected = 1
End If
End Function
Consulte o download deste artigo para ver a implementação completa das classes BLL.
Etapa 2: Acessar os Conjuntos de Dados Tipado por meio das classes BLL
No primeiro tutorial, vimos exemplos de como trabalhar diretamente com o Conjunto de Dados Tipado programaticamente, mas com a adição de nossas classes BLL, a camada de apresentação deve funcionar na BLL. AllProducts.aspx No exemplo do primeiro tutorial, o ProductsTableAdapter foi usado para associar a lista de produtos a um GridView, conforme mostrado no código a seguir:
Dim productsAdapter As New ProductsTableAdapter()
GridView1.DataSource = productsAdapter.GetProducts()
GridView1.DataBind()
Para usar as novas classes BLL, tudo o que precisa ser alterado é a primeira linha de código simplesmente substituir o ProductsTableAdapter objeto por um ProductBLL objeto:
Dim productLogic As New ProductsBLL()
GridView1.DataSource = productLogic.GetProducts()
GridView1.DataBind()
As classes BLL também podem ser acessadas declarativamente (assim como o Conjunto de Dados Digitado) usando ObjectDataSource. Discutiremos o ObjectDataSource com mais detalhes nos tutoriais a seguir.
Figura 3: a lista de produtos é exibida em um GridView (clique para exibir a imagem em tamanho real)
Etapa 3: adicionando Field-Level validação às classes DataRow
A validação em nível de campo são verificações que pertencem aos valores de propriedade dos objetos de negócios ao inserir ou atualizar. Algumas regras de validação de nível de campo para produtos incluem:
- O
ProductNamecampo deve ter 40 caracteres ou menos de comprimento - O
QuantityPerUnitcampo deve ter 20 caracteres ou menos de comprimento - Os
ProductIDcampos ,ProductNameeDiscontinuedsão necessários, mas todos os outros campos são opcionais - Os
UnitPricecampos ,UnitsInStock,UnitsOnOrdereReorderLeveldevem ser maiores ou iguais a zero
Essas regras podem e devem ser expressas no nível do banco de dados. O limite de caracteres nos ProductName campos e QuantityPerUnit são capturados pelos tipos de dados dessas colunas na Products tabela (nvarchar(40) e nvarchar(20), respectivamente). Se os campos são obrigatórios e opcionais são expressos por se a coluna da tabela de banco de NULL dados permite s. Existem quatro marcar restrições que garantem que apenas valores maiores ou iguais a zero possam torná-lo nas UnitPricecolunas , UnitsInStockUnitsOnOrder, ou ReorderLevel .
Além de impor essas regras no banco de dados, elas também devem ser impostas no nível do DataSet. Na verdade, o comprimento do campo e se um valor é obrigatório ou opcional já são capturados para o conjunto de DataColumns de cada DataTable. Para ver a validação de nível de campo existente fornecida automaticamente, vá para a Designer DataSet, selecione um campo de uma das DataTables e vá para o janela Propriedades. Como mostra a Figura 4, o QuantityPerUnit DataColumn no ProductsDataTable tem um comprimento máximo de 20 caracteres e permite NULL valores. Se tentarmos definir a ProductsDataRowpropriedade de como um valor de QuantityPerUnit cadeia de caracteres maior que 20 caracteres, um ArgumentException será gerado.
Figura 4: o DataColumn fornece validação básica de Field-Level (clique para exibir a imagem em tamanho real)
Infelizmente, não é possível especificar verificações de limites, como o UnitPrice valor deve ser maior ou igual a zero, por meio do janela Propriedades. Para fornecer esse tipo de validação em nível de campo, precisamos criar um manipulador de eventos para o evento ColumnChanging da DataTable. Conforme mencionado no tutorial anterior, os objetos DataSet, DataTables e DataRow criados pelo Typed DataSet podem ser estendidos por meio do uso de classes parciais. Usando essa técnica, podemos criar um ColumnChanging manipulador de eventos para a ProductsDataTable classe . Comece criando uma classe na App_Code pasta chamada ProductsDataTable.ColumnChanging.vb.
Figura 5: Adicionar uma nova classe à App_Code pasta (clique para exibir a imagem em tamanho real)
Em seguida, crie um manipulador de eventos para o ColumnChanging evento que garante que os UnitPricevalores de coluna , UnitsInStock, UnitsOnOrdere ReorderLevel (se não NULL) sejam maiores ou iguais a zero. Se qualquer coluna desse tipo estiver fora do intervalo, gere um ArgumentException.
ProductsDataTable.ColumnChanging.vb
Imports System.data
Partial Public Class Northwind
Partial Public Class ProductsDataTable
Public Overrides Sub BeginInit()
AddHandler Me.ColumnChanging, AddressOf ValidateColumn
End Sub
Sub ValidateColumn(sender As Object, e As DataColumnChangeEventArgs)
If e.Column.Equals(Me.UnitPriceColumn) Then
If Not Convert.IsDBNull(e.ProposedValue) AndAlso _
CType(e.ProposedValue, Decimal) < 0 Then
Throw New ArgumentException( _
"UnitPrice cannot be less than zero", "UnitPrice")
End If
ElseIf e.Column.Equals(Me.UnitsInStockColumn) OrElse _
e.Column.Equals(Me.UnitsOnOrderColumn) OrElse _
e.Column.Equals(Me.ReorderLevelColumn) Then
If Not Convert.IsDBNull(e.ProposedValue) AndAlso _
CType(e.ProposedValue, Short) < 0 Then
Throw New ArgumentException(String.Format( _
"{0} cannot be less than zero", e.Column.ColumnName), _
e.Column.ColumnName)
End If
End If
End Sub
End Class
End Class
Etapa 4: Adicionar regras de negócios personalizadas às classes da BLL
Além da validação de nível de campo, pode haver regras de negócios personalizadas de alto nível que envolvem diferentes entidades ou conceitos não expressíveis no nível de coluna única, como:
- Se um produto for descontinuado, ele
UnitPricenão poderá ser atualizado - O país de residência de um funcionário deve ser o mesmo que o país de residência de seu gerente
- Um produto não poderá ser descontinuado se for o único produto fornecido pelo fornecedor
As classes BLL devem conter verificações para garantir a adesão às regras de negócios do aplicativo. Essas verificações podem ser adicionadas diretamente aos métodos aos quais se aplicam.
Imagine que nossas regras de negócios determinam que um produto não poderia ser marcado como descontinuado se fosse o único produto de um determinado fornecedor. Ou seja, se o produto X fosse o único produto que compramos do fornecedor Y, não poderíamos marcar X como descontinuado; se, no entanto, o fornecedor Y nos forneceu três produtos, A, B e C, então poderíamos marcar qualquer e todos eles como descontinuados. Uma regra de negócios estranha, mas as regras de negócios e o bom senso nem sempre estão alinhados!
Para impor essa regra de negócios no UpdateProducts método , começaríamos verificando se Discontinued foi definido True como e, nesse caso, chamaríamos GetProductsBySupplierID para determinar quantos produtos compramos do fornecedor deste produto. Se apenas um produto for comprado deste fornecedor, lançaremos um ApplicationException.
<System.ComponentModel.DataObjectMethodAttribute_
(System.ComponentModel.DataObjectMethodType.Update, True)> _
Public Function UpdateProduct( _
productName As String, supplierID As Nullable(Of Integer), _
categoryID As Nullable(Of Integer), quantityPerUnit As String, _
unitPrice As Nullable(Of Decimal), unitsInStock As Nullable(Of Short), _
unitsOnOrder As Nullable(Of Short), reorderLevel As Nullable(Of Short), _
discontinued As Boolean, productID As Integer) _
As Boolean
Dim products As Northwind.ProductsDataTable = _
Adapter.GetProductByProductID(productID)
If products.Count = 0 Then
Return False
End If
Dim product As Northwind.ProductsRow = products(0)
If discontinued Then
Dim productsBySupplier As Northwind.ProductsDataTable = _
Adapter.GetProductsBySupplierID(product.SupplierID)
If productsBySupplier.Count = 1 Then
Throw New ApplicationException( _
"You cannot mark a product as discontinued if it is " & _
"the only product purchased from a supplier")
End If
End If
product.ProductName = productName
If Not supplierID.HasValue Then
product.SetSupplierIDNull()
Else
product.SupplierID = supplierID.Value
End If
If Not categoryID.HasValue Then
product.SetCategoryIDNull()
Else
product.CategoryID = categoryID.Value
End If
If quantityPerUnit Is Nothing Then
product.SetQuantityPerUnitNull()
Else
product.QuantityPerUnit = quantityPerUnit
End If
If Not unitPrice.HasValue Then
product.SetUnitPriceNull()
Else
product.UnitPrice = unitPrice.Value
End If
If Not unitsInStock.HasValue Then
product.SetUnitsInStockNull()
Else
product.UnitsInStock = unitsInStock.Value
End If
If Not unitsOnOrder.HasValue Then
product.SetUnitsOnOrderNull()
Else
product.UnitsOnOrder = unitsOnOrder.Value
End If
If Not reorderLevel.HasValue Then
product.SetReorderLevelNull()
Else
product.ReorderLevel = reorderLevel.Value
End If
product.Discontinued = discontinued
Dim rowsAffected As Integer = Adapter.Update(product)
Return rowsAffected = 1
End Function
Respondendo a erros de validação na camada de apresentação
Ao chamar a BLL da camada de apresentação, podemos decidir se deseja lidar com exceções que possam ser geradas ou deixá-las surgir até ASP.NET (o que gerará o HttpApplicationevento do Error ). Para lidar com uma exceção ao trabalhar com a BLL programaticamente, podemos usar um Try... Bloco Catch , como mostra o exemplo a seguir:
Dim productLogic As New ProductsBLL()
Try
productLogic.UpdateProduct("Scotts Tea", 1, 1, Nothing, _
-14, 10, Nothing, Nothing, False, 1)
Catch ae As ArgumentException
Response.Write("There was a problem: " & ae.Message)
End Try
Como veremos em tutoriais futuros, o tratamento de exceções que surgirem da BLL ao usar um controle da Web de dados para inserir, atualizar ou excluir dados pode ser tratado diretamente em um manipulador de eventos, em vez de ter que encapsular código em Try...Catch blocos.
Resumo
Um aplicativo bem projetado é criado em camadas distintas, cada uma encapsulando uma função específica. No primeiro tutorial desta série de artigos, criamos uma Camada de Acesso a Dados usando Conjuntos de Dados Tipado; neste tutorial, criamos uma Camada de Lógica de Negócios como uma série de classes na pasta do App_Code nosso aplicativo que fazem chamadas para nosso DAL. A BLL implementa a lógica de nível de campo e de nível de negócios para nosso aplicativo. Além de criar uma BLL separada, como fizemos neste tutorial, outra opção é estender os métodos de TableAdapters por meio do uso de classes parciais. No entanto, o uso dessa técnica não nos permite substituir os métodos existentes nem separa nosso DAL e nossa BLL de forma tão limpa quanto a abordagem que adotamos neste artigo.
Com a DAL e a BLL concluídas, estamos prontos para começar em nossa camada de apresentação. No próximo tutorial , faremos um breve desvio dos tópicos de acesso a dados e definiremos um layout de página consistente para uso em todos os tutoriais.
Programação feliz!
Sobre o autor
Scott Mitchell, autor de sete livros do ASP/ASP.NET e fundador da 4GuysFromRolla.com, trabalha com tecnologias da Microsoft Web desde 1998. Scott trabalha como consultor independente, treinador e escritor. 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
Esta série de tutoriais foi revisada por muitos revisores úteis. Os principais revisores deste tutorial foram Liz Shulok, Dennis Patterson, Carlos Santos e Hilton Giesenow. Interessado em revisar meus próximos artigos do MSDN? Nesse caso, deixe-me uma linha em mitchell@4GuysFromRolla.com.
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de