ASP.NET: Schichtentrennung – Implementierung
Comments(2) Das Schicke an der Schichtentrennung und den damit verbundenen Konzepten, ist, dass die Implementierung später gegen eine andere Implementierung ausgetauscht werden kann. Genau diesen Ansatz macht man sich zu Nutze, wenn man schnell Ergebnisse erzielen möchte, indem man zunächst eine einfache Implementierung erstellt und eben erst später die echte, große, datenbankgestützte Version bereit stellt.
Das vorausgeschickt, ist die folgende Implementierung nur als ein erster Ansatz zu sehen, den Sie durch eine Version ersetzen können, der Ihren eigenen Anforderungen besser entspricht. Die hier vorgestellte Implementierung nutzt nur den Speicher, um die angelegten Kunden vorzuhalten. Technisch macht sie nix anderes, als eine Liste von Kunden im Speicher zu halten. Einfach, aber für einen Test und einen ersten Prototypen sicherlich ausreichen.
Wichtig: Diese Komponente liegt in einem eigenen Projekt mit dem Namen MemoryCustomerManager (genau so wird der Name der Assemblierung heißen).
Der Code ist ziemlich selbsterklärend – hier werden schließlich nur Operationen auf einer Liste von Kunden vorgenommen. Damit alles später zusammen funktioniert, muss diese Implementierung somit lediglich von der Basisklasse CustomerManager erben und die benötigten Methoden implementieren:
using System;
using System.Collections.Generic;
using System.Text;
using BusinessLayer;
namespace MemoryCustomerManager
{
///
///
public class MemoryCustomerManager : CustomerManager
{
private static List
new List
///
///
private static List
{
get { return _customers; }
}
///
///
public override List
{
// Sort
Sort(CustomersList);
// Return the customers
return CustomersList;
}
///
///
public override Customer GetCustomer(Guid id)
{
// Check all customers
foreach (Customer cust in CustomersList)
{
// Compare the id
if (cust.Id.Equals(id))
{
// Found it!
return cust;
}
}
// Found nothing
return null;
}
///
///
public override List
FindCustomersByName(string name)
{
List
new List
string nameLower = name.ToLower();
// Check every customer
foreach (Customer cust in CustomersList)
{
if (cust.LastName.ToLower()
.Equals(nameLower))
{
customers.Add(cust);
}
}
// Sort the customers
Sort(customers);
// Done
return customers;
}
///
///
public override List
FindCustomersByEMail(string email)
{
List
new List
string emailLower = email.ToLower();
// Check every customer
foreach (Customer cust in CustomersList)
{
if (cust.EMail.ToLower().Equals(emailLower))
{
customers.Add(cust);
}
}
// Sort the list
Sort(customers);
// Return the customers
return customers;
}
///
///
public override Customer
UpdateCustomer(Customer customer)
{
// Delete an existing customer
DeleteCustomer(customer);
// Add the customer
CustomersList.Add(customer);
return customer;
}
///
///
public override bool
DeleteCustomer(Customer customer)
{
// Check, whether the customer
// exists in the list
Customer existing = null;
foreach (Customer cust in CustomersList)
{
if (cust.Id.Equals(customer.Id))
{
existing = cust;
break;
}
}
// Replace the old customer
if (null != existing)
{
CustomersList.Remove(existing);
return true;
}
return false;
}
///
///
private void Sort(List
{
customers.Sort(new CustomerSorter());
}
}
}
Innerhalb der Klasse wird Bezug auf eine Klasse CustomerSorter genommen. Diese hat die Aufgabe, die Liste der Kunden stets alphabetisch sortiert zu halten. Wir implementieren dies mit Hilfe des Interfaces IComparer
- Zahl größer als 0: Der Wert der Instanz, auf der verglichen worden ist, ist größer.
- 0: Beide Werte sind gleich.
- Zahl kleiner als 0: Der Wert der Instanz, mit der verglichen worden ist, ist größer.
Dementsprechend kann das natürlich auch umgedreht werden, wenn man am Ende des Tages eine absteigende Sortierung wünscht. Wenn die Nachnamen gleich sind, werden die Vornamen miteinander verglichen. Sind auch die gleich, kommen die E-Mail-Adressen an die Reihe.
Lange Rede, kurzer Sinn: Dies ist der Code der CustomerSorter-Klasse:
using System;
using System.Collections.Generic;
using System.Text;
using BusinessLayer;
namespace MemoryCustomerManager public int Compare(Customer x, Customer y) // Compare the emails when neccessary return result;
{
public class CustomerSorter : IComparer
{
///
///
{
int result = x.LastName.CompareTo(y.LastName);
// Compare the first names when neccessary
if (result == 0)
{
result = x.FirstName.CompareTo(y.FirstName);
}
if (result == 0)
{
result = x.EMail.CompareTo(y.EMail);
}
}
}
}
Damit ist die Implementierung komplett. Im nächsten Teil unserer Serie widmen wir uns dann der Nutzung dieser ganzen Komponenten im Web-Umfeld.