Objetos empresariales

Objetos empresariales
Hasta ahora las aplicaciones han sido creadas de dos niveles. (interfaz de usuario y datos finales).
Para aplicaciones comerciales es recomendable utilizar n-niveles en donde exista una capa de lógica empresarial
central con el objeto de separar la recuperación de datos de la base de datos, de la manipulación (y validación) de
dichos datos antes de su presentación.
Un ejemplo de objeto empresarial de nivel medio sería crear una clase sin estado para encapsular lógica empresarial y
una clase modelo que pueda cargar y almacenar datos de la base de datos.

Implementación de Modelo Vista Controlador (MVC) de n niveles

Crearemos una clase empresarial sin estado CustomerBusinessLogic y un modelo de la case Customer llamado
NorthWind customer.
Vincularemos un ObjectDataSource a la clase de lógica empresarial sin estado, que usará la clase Model para obtener
y recuperar datos sobre los clientes de la bd NorthWind.

Creamos una nueva aplicación Web llamada Objetoempresarial.

Agregamos un GridView y usamos la etiqueta inteligente y las propiedades para establecer las columnas de la tabla
Customer que queremos mostrar.

En el archivo Default.aspx de Objetoempresarial tendremos

Asp:Gridview ID=”GridView1” runat=”server” DataSourceID=”ObjectDataSource1” permitir paginación, no generar

columnas ,
<columns>
<asp:BoundField DataField=”CompanyName” HeaderText=”Company” />
también agregamos ContactName, ContactTitle, Address, City, Region, PostalCode, Phone, Fax
Podemos utilizar la etiqueta inteligente de Editar Columnas. Recuerda agregar BoundField y configurar sus
propiedades.

Lo más importante de esta declaración es que hemos asignado a DataSourceID el valor ObjectDataSource1. debemos
declarar entonces este objeto y así en el código HTML
<asp:ObjectDataSource ID=”ObjectDataSource1” runat=”server” SelectMethod=”GetAllCustomers”
TypeName=”CustomerBusinessLogic” />
el atributo SelectMethod indica a ObjectDataSource qué método debe invocar en su objeto empresarial para
responder a la petición de selección del DataGrid (para rellenar la rejilla) y el atributo TypeName indica al
ObjectDataSource qué clase tendrá ese método.

Vemos que la clase de lógica empresarial sin estado se llamará CustomerBusinessLogic y tendrán un método estático
llamado GetAllCustomers.

Para crear esta clase hacemos clic con botón derecho del ratón en el proyecto en el Explorador de Soluciones y
agregamos una nueva clase llamada CustomerBusinessLogic.cs. (colocamos el archivo en el directorio App_Code).

La clase Business Logic está declarada para ser estática porque todos sus miembros serán estáticos. Los métodos
miembros representan las posibilidades de la clase de lógica empresarial:
GetAllCustomers: responde al método seleccionado
UpdateCustomerInformation: Responde al método Update
GetCustomer: obtiene una instancias de cliente individual tras recibir un CustomerID

El archivo de código oculto sería:

Using System (Data – Data.Sqlclient – Collections – Collection.Specialized – Configuration – Text – Web –
Web.Security – Web.UI – Web.UI.WebControls – Web.UI.WebControls.webParts – Web.UI.HtmlControls –

Public static class CustomerBusinessLogic {

//los métodos se crean dentro de la clase
public static Icollection GetAllCustomers() {
ArrayList allCustomers = new ArrayList ();
String connectionString= la cadena de conexión;
String selectCommand = “select CustomerID from Customers”;
SqlDataSource dataSource = new SqlDataSource (connectionString, selectCommand);

Try {
//seleccion sin argumentos
IEnumerable CustomersIDs= dataSource.Select (DataSourceSelectArguments.Empty);
Ienumerator enumerator = CustomerIDs.GetEnumerator ();

ADO.NET Objetos empresariales 1/3

 While (enumarator.MoveNext()) {
DataRowView drv =enumerator.Current as DataRowView;
If (drv !=null) {
String customerID=drv[“CustomerID”].ToString();
NorthWindCustomer cust = new NorthWindCustomer (customerID);
Allcustomers.Add(cust);
}// final si no es nulo
}// final mientras se enumera
}//finaliza el bloque try
finally {
dataSource.Dispose();
}
return.AllCustomers;
}
------------
public static void UpdateCustomerInformation (NorthWindCustomer customer) {
bool returnValue = customer.Save();
if (returnValue==false) {
throw new ApplicationException (“no se puede actualizar el cliente”);
}
}
------------
public static NortWindCustomer GetCustomer(string custID) {
return new NorthWindCustomer (custID);
}
}

El método devuelve un ICollection al que pueda vincularse la rejilla.

Lo hacemos creando una instancia de SqlDataSource inicializada con la cadena de conexión y una instrucción de
selección que obtiene todos los CustomerId de la tabla Customers. Lo que recibimos al invocar a dataSource.Select
(sin pasar argumentos) es una colección de DataRowViews.
Enumeramos la colección, extrayendo cada DataRowView y a partir de ella, extraemos el CustomerID. Empleando
este CustomerID, instanciamos un objeto NorthWindCustomer (que definiremos después) que añadimos a nuestro
ArrayList.
Cuando se haya creado una instancia del NorthWindCustomer para cada ID de la base de datos, es colección se usa
como origen de datos para el GridView.
Este proceso nos permite manipular el objeto de datos (NorthWindCustomer) para añadir lógica empresarial a
cualquiera o a todas sus propiedades.
En este ejemplo, el objeto NorthWindCustomer sólo almacena los datos para un cliente de una tabla Customers, pero
podemos realizar operaciones en esos datos o ampliando la definición de un cliente más allá de una sola tabla.

La definición de NorthWindCustomer se implementa en CustomerBusinessLogic.cs

Public class NorthWindCustomer {

Private objetct customerID;

Private string companyName:

Public string CompanyName {
Get { return companyName; }
Set { companyName = value; }}

Private string contactName;

Public string ContactName {
Get {return contactName; }
Set {contactName=value;}}

Igual para contactTitle – address – city – region – postalCods – country – phone – fax –

Public bool Save () {

Return true;
}
//contructor predeterminado
public NorthWindCustomer() {
this.customerID=DBNull.Value;
this.companyName=stirng.Empty;
así...todos... como string.Empty;

ADO.NET Objetos empresariales 2/3

 }

//objeto empresarial que representa a un Customer de la base de datos NorthWind

public NorthWindCustomer (string customerID) {
string connectionString = cadena de conexión ;
StringBuilder sb = new StringBuilder (“select CompanyName, ContactName, ContacTitle,”);
Sb.Append(“ Address, City, Region, PostaCode, Country, Phone, “);
Sb.Append(“ fax from Customers “);
Sb.Append(“ where CustomerID=@customerID”);
//crea el objeto de conexión y se inicializa conn
Sqlconnection connection = new Sqlconnection(connectionString);
//declara el objeto de comando para las instrucciones SQL
SqlCommand command = new SqlCommand(sb.ToString(), connection);
SqlParameter param = command.Parameters.AddWithValue (“@customerID”, customerID);
Param.DbType = DbType.String;
Param.Direction = ParameterDirection.Input;
SqlDataReader dataReader = null;
Try {
Connection.Open();
DataReader = command.ExecuteReader ();
If (dataReader !=null && dataReader.Read()) {
This.companyName = dataReader [“companyName”].ToString();
Igual contactName – contactTitle – address – city – region – postalCode – country – phone – fax
–
}
else {
throw new ApplicationException (“los datos no se han encontrado del cliente” + customerID);
}
}
finally {
try{
if (dataReader ! = null) {
dataReader.Close();
}
connection.Close();
}
catch (SqlException) {
//aquí controlamos la excepción
throw;
}
}
}//finaliza el constructor
} // finaliza la clase

este código extrae información sobre un determinado cliente (basándonos en CustomerID) de la base de datos y crea
datos de instancia a partir de esos datos vinculados ala base de datos. Comienza creando una instrucción de la
selección con parámetros (@CustomerID) que extrae los campos necesarios para crear el objeto
empresarial...utilizamos un constructor...stringBuilder
el código crea un objeto de conexión y de comando como siempre y añade el parámetro con customerID como
valor... param....
en el bloque try se abre la conexión y se invoca a un DataReader basado en la instrucción de selección con
parámetros...dataReader=command.ExecuteReader()
si recibimos datos de vuelta (si no es así, se produce una excepción) rellenaremos los campos del objeto empresarial a
partir de las columnas del dataReader...this.companyName=dataReader [“companyName”].toString();
tras cerrar el dataReader y la conexión, el objeto se instancia completamente y puede usarse para vincular datos en el
GridView.
En nuestro caso, se mostrarán los datos de la base de datos que tiene la misma estructura que los campos del objeto
empresarial, pero en una aplicación real, el objeto empresarial del cliente podría ser más grande, más pequeño o más
complejo que los datos almacenos en una sola tabla de base de datos.
Cuando se ejecuta la aplicación el GridView está vinculado al ObjectDataSource, al igual que antes utilizábamos
GridView vinculados a SqlDataSource, y los datos se muestran correctamente basándonos en las columnas
vinculados que escogimos anteriormente.

ADO.NET Objetos empresariales 3/3