The DAO Framework provides a well-architected way to access databases. For every table in a database, the following items can be generated:

The most important of these objects is listed below.

At its most basic, the architecture is composed of one Data Access Object (DAO) and one Entity object per table. The DAO object is a MarshalByRef object, allowing for remote invocation. The Entity object is Serializable, allowing for transfer between remote applications.

Figure 1. DAO Framework Class Diagram (Basic)

Class Diagram

If the full power of the framework is generated, several classes are created addressing different aspects of the architecture. The class diagram below shows the relationship between the various generated classes.

Figure 2. DAO Framework Class Diagram

Northwind Employees Example

The class diagram below shows a specific implementation for the Northwind Employees table

Figure 3. DAO Framework - Northwind Employees Example

Component Diagram

Depending on the options you select, Codus will generate multiple assemblies. Below is the component diagram for a typical project

Figure 4. DAO Framework Component Diagram

The Entity Object is an object representation of a table row, with some added features.

For every table or view, an Entity will be created in the form of XXXEntity. For example, the Northwind database contains an Employees table. An EmployeesEntity will be created to store information from that table.

Child Properties

If you have foreign keys defined in your database tables, Codus will automatically create child properties in your XXXEntity. For example, the Northwind database contains the Employees table. The Orders table stores the EmployeeId for the Employee that created that order. Since the link from Employee-EmployeeId to Orders-EmployeeId is a foreign key relationship, Codus will automatically create a property called OrdersByEmployeeId

// Retrieve the orders placed by Employee #22
EmployeesDAO dao = new EmployeesDAO();
EmployeeEntity employee = dao.SelectOne(22) as EmployeeEntity ; // SelectOne uses the primary key value as the parameter
foreach(OrdersEntity order in employee.OrdersByEmployeeID)
{
   Console.WriteLine(order.OrderDate); // Display the date of the order
}

Serialization

All Entity Objects are Serializable, which means they can be transferred between remote applications, and/or stored to a file, etc.

The following code shows an example of serializing an Entity Object (using a Northwind database example):

CustomersDAO dao = new CustomersDAO();
CustomersEntity customer = dao.SelectOne("ANTON") as CustomersEntity;

// Serialize using Adapdev.Serialization.Serializer...a utility class.
Console.WriteLine(Adapdev.Serialization.Serializer.SerializeToXml(customer));

This produces the following output:

<?xml version="1.0"?>
<CustomersEntity xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <Address>Mataderos  2312</Address>
  <City>Mexico D.F.</City>
  <CompanyName>Antonio Moreno TaquerC-a</CompanyName>
  <ContactName>Antonio Moreno</ContactName>
  <ContactTitle>Owner</ContactTitle>
  <Country>Mexico</Country>
  <CustomerID>ANTON</CustomerID>
  <Phone>(5) 555-3932</Phone>
  <PostalCode>05023</PostalCode>
</CustomersEntity>

ToString

All Entity Objects also override the ToString() method, and will create a string printout of all the objects property names, their object types and values. This is useful for debugging purposes. Below is an example (using a Northwind database):

// Call the ToString method
EmployeesDAO dao = new EmployeesDAO();
EmployeesEntity employee = dao.SelectOne(9) as EmployeesEntity;
Console.WriteLine(employee);

This produces the following output:

Properties for: EmployeesEntity
	Address(System.String): 7 Houndstooth Rd.
	BirthDate(System.DateTime): 1/27/1966 12:00:00 AM
	City(System.String): London
	Country(System.String): UK
	EmployeeID(System.Int32): 9
	Extension(System.String): 452
	FirstName(System.String): Anne
	HireDate(System.DateTime): 11/15/1994 12:00:00 AM
	HomePhone(System.String): (71) 555-4444
	LastName(System.String): Dodsworth
	Notes(System.String): Anne has a BA degree in English from St. Lawrence College.  She is fluent in French and German.
	Photo(System.Byte[]): System.Byte[]
	PhotoPath(System.String): http://accweb/emmployees/davolio.bmp
	PostalCode(System.String): WG2 7LT
	Region(System.String): 
	ReportsTo(System.Int32): 5
	Title(System.String): Sales Representative
	TitleOfCourtesy(System.String): Ms.

The bulk of the DAO Framework capability lies in the Data Access Object (DAO). The DAO inherits from the Adapdev.Data.AbstractDAO class, which is part of the free and open-source Adapdev.NET project.

For every table in a database, a corresponding DAO class is generated.

Below are examples of common uses. These examples use code that's generated for the Northwind Employees table:

EmployeesDAO dao = new EmployeesDAO();
int count = dao.GetCount();

// Using IList
EmployeesDAO dao = new EmployeesDAO();
IList employees = dao.SelectAll();
foreach(EmployeesEntity e in employees){
   Console.WriteLine(e.FirstName);
}

// Populate an ArrayList
EmployeesDAO dao = new EmployeesDAO();
ArrayList employees = dao.SelectAll() as ArrayList;
foreach(EmployeesEntity e in employees){
   Console.WriteLine(e.FirstName);
}

// Populate a strongly-typed collection
EmployeesDAO dao = new EmployeesDAO();
EmployeesEntityCollection employees = new EmployeesEntityCollection(dao.SelectAll());
foreach(EmployeesEntity e in employees){
   Console.WriteLine(e.FirstName);
}

// Populate an ArrayList
EmployeesDAO dao = new EmployeesDAO();
IList employees = dao.SelectAllWithLimit(10);
foreach(EmployeesEntity e in employees){
   Console.WriteLine(e.FirstName);
}

// Populate a strongly-typed collection
EmployeesDAO dao = new EmployeesDAO();
EmployeesEntityCollection employees = new EmployeesEntityCollection(dao.SelectAllWithLimit(10));
foreach(EmployeesEntity e in employees){
   Console.WriteLine(e.FirstName);
}

// Populate a DataSet
EmployeesDAO dao = new EmployeesDAO();
DataSet employeesDS = dao.SelectAllDS();

// Retrieve employee record 22
EmployeesDAO dao = new EmployeesDAO();
EmployeeEntity employee = dao.SelectOne(22) as EmployeesEntity; // SelectOne uses the primary key value as the parameter

// Retrieve employee record 22
EmployeesDAO dao = new EmployeesDAO();
DataSet employeeDS = dao.SelectOneDS(22); // SelectOneDS uses the primary key value as the parameter

// Get records using a custom sql statement
EmployeesDAO dao = new EmployeesDAO();
ArrayList al = new ArrayList(dao.Select("SELECT * FROM Employees WHERE FirstName LIKE 'm%'"));

// Get records using a custom sql statement
EmployeesDAO dao = new EmployeesDAO();
DataSet ds = dao.SelectDS("SELECT * FROM Employees WHERE FirstName LIKE 'm%'");

// Get records that contain a specified foreign key
// Codus generates SelectAllByXXX methods for each foreign key in a table
EmployeesDAO dao = new EmployeesDAO();
ArrayList al = new ArrayList(dao.SelectAllByReportsTo(2));
foreach(EmployeesEntity employee in al){
   Console.WriteLine(employee.FirstName);
}

// Create a new record
EmployeesEntity employee = new EmployeesEntity();
employee.FirstName = "Joe";
employee.LastName = "Schmoe";
// ...etc.

EmployeesDAO dao = new EmployeesDAO();
dao.Save(employee);

EmployeesDAO dao = new EmployeesDAO();

// Grab employee 22 and update who they report to
EmployeesEntity employee = dao.SelectOne(22) as EmployeesEntity;
employee.ReportsTo = 5;

dao.Update(employee);

EmployeesDAO dao = new EmployeesDAO();
dao.Delete(22); // Delete using the primary key

// Connection is created and destroyed behind the scenes
EmployeesDAO dao = new EmployeesDAO();
dao.Delete(22); // Delete using the primary key

EmployeesDAO dao = new EmployeesDAO();

// The using directive automatically closes the connection.  
// See MS.NET documentation for details.
// If you don't use the "using" directive, then you'll need to explicitly
// open and close the connection.
using(IDbConnection connection = dao.CreateConnection()){
   // open the connection
   connection.Open();

   // get an existing record
   EmployeesEntity employee = dao.SelectOne(8, connection) as EmployeesEntity;
   employee.LastName = "Hilton";

   // update it
   dao.Update(employee, connection);

   // delete another record
   dao.Delete(22);
}

string sql = String.Format("SELECT {0}, {1}, {2} FROM {3} WHERE {4} LIKE 'm%'",
							EmployeesDAO.COLUMN_FIRSTNAME,
							EmployeesDAO.COLUMN_LASTNAME,
							EmployeesDAO.COLUMN_EMPLOYEEID,
							EmployeesDAO.TABLE_NAME,
							EmployeesDAO.COLUMN_FIRSTNAME);

string sql = String.Format("SELECT [{0}] FROM {3} WHERE [{4}] LIKE 'm%'",
							EmployeesDAO.COLUMN_FIRSTNAME,
							EmployeesDAO.TABLE_NAME,
							EmployeesDAO.COLUMN_FIRSTNAME);

SELECT [First Name] FROM Employees WHERE [First Name] LIKE 'm%'

EmployeesDAO dao = new EmployeesDAO();
dao.ExecuteNonQuery("UPDATE FirstName SET FirstName = 'John' WHERE EmployeeID = 5");

VS.NET 2003

The DAO Framework allows for generation directly into VS.NET 2003. Since the DAO Framework can generate hundreds of files, it is recommended that you use this capability.

NAnt

You can select NAnt generation, and a .build file will be placed in the output directory. You can launch the build by clicking on the runbuild.bat in the output directory, which will launch NAnt and build the generated output.

Manual

If you choose not to NAnt or VS.NET 2003, all of the binaries necessary are located in the [Codus Install Location]\shared directory. Here are the necessary references:

The framework uses the Velocity template language for all code generation, provided via modified version of NVelocity. The following options are available for making modifications: