业务对象的持久化实例（AAF2.0）

[aafshzj]

内容太长，这里放不下，我只把代码放在这里：原文见我的博客：http://blog.csdn.net/aafshzj/
数据对象代码：
using System;

using Aaf.Agile;
using Aaf.Agile.Imp;

namespace AafSample
{
// 用户
public class User : AgileObject
{
public string Name;
public string LoginId;
public string Email;
public string CellPhone;
}

// 商品目录
public class Category : AgileObject
{
public string Name;
public string Description;
[Relation(RelationType = typeof(FreeAgileRelation), ChildType = typeof(Category))]
public IAgileRelation SubCats;
}

// 商品
public class Product : AgileObject
{
public string CatId;
public string Name;
public string Description;
public string UnitName;//单位
public decimal Price;
}

// 订单
public class Order : AgileObject
{
[Relation(RelationType = typeof(FreeAgileRelation), ChildType = typeof(OrderItem))]
public IAgileRelation OrderItems;// 订单明细集合
public DateTime CreatedTime = DateTime.Now;

public decimal Sum // 订单总金额
{
get
{
decimal sum = 0;
foreach(OrderItem item in this.OrderItems)
{
sum += item.ItemSum;
}

return sum;
}
}
}

// 订单明细
public class OrderItem : AgileObject
{
public string ProdId;//订购物品编号
public decimal Quantity;//订购数量
public decimal UnitPrice;//单价
public decimal ItemSum;//订单项金额
}

}

[aafshzj]

内容太长，这里放不下，我只把代码放在这里：原文见我的博客：http://blog.csdn.net/aafshzj/
业务服务代码：
using System;

using Aaf.Agile;
using Aaf.Core;
using Aaf.Persistence;

namespace AafSample
{
public class ProductService
{
private const string RootCatId = "27FDA2D79C27429895D7F2479FFA278C";

private static ProductService s_Instance = new ProductService();
private Category _rootCat;

public static ProductService Instance
{
get
{
return s_Instance;
}
}

private static ITypeService TypeService
{
get
{
return (ITypeService)ServiceHub.Instance.GetService(typeof(ITypeService));
}
}

private static IPersister Persister
{
get
{
return (IPersister)ServiceHub.Instance.GetService(typeof(IPersister));
}
}

private ProductService()
{
// 检查是否存在根目录，不存在就创建。
_rootCat = this.GetCategory(RootCatId);
if (_rootCat == null)
{
_rootCat = (Category)TypeService.CreateInstance(typeof(Category));
_rootCat.Id = RootCatId;

this.SaveCategory(_rootCat);
}
}

// 在指定目录Id下创建一个子目录，本方法并不提交保存，外部调用者可以在自己认为恰当的时间保存
// parentId指向的父目录，从而提交本次修改。注意，仅仅保存本方法返回的新目录实例是不够的，
// 因为这样做，只会保存新目录实例，而不会保存父目录与新目录实例之间的关系项。
//
// 实际上，还有一种更高级的做法，可以使得外部只要保存新目录实例就可以保存它与父实例之间的关
// 系，但是这一办法将在“对象的持久化（高级）”一文中论述。
public Category CreateCategory(string parentId, string catName, string catDescription)
{
if (parentId == null)
{
return null;
}

Category parentCat = (Category)Persister.LoadAgileObject(typeof(Category), parentId);

if (parentCat != null)
{
Category cat = (Category)TypeService.CreateInstance(typeof(Category));
cat.Name = catName;
cat.Description = catDescription;
parentCat.SubCats.Add(cat);

return cat;
}

return null;
}

// 挂起一个目录。挂起的具体意义有应用自己决定。我们可以在这里约定挂起的目录不会在界面中显示出来
// 同样的，对象修改后的保存都由外部调用者在恰当的时机显式调用相关保存方法予以保存。原则上，服务
// 方法中不主动保存任何对象（除了一些内置的根节点之外）。其它方法与此类似，以后不再反复说明。
public Category SuspendCategory(string catId)
{
Category cat = (Category)Persister.LoadAgileObject(typeof(Category), catId);

if (cat != null)
{
cat.Suspend();

return cat;
}

return null;
}

// 获取根目录
public Category GetRootCategory()
{
return _rootCat;
}

// 根据指定Id获取一个目录
public Category GetCategory(string catId)
{
Category cat = (Category)Persister.LoadAgileObject(typeof(Category), catId);

if (cat != null)
{
return cat;
}

return null;
}

// 获取一个目录的所有子目录
public Category[] GetSubCategories(string parentId)
{
Category cat = GetCategory(parentId);

if (cat != null)
{
return (Category[])cat.SubCats.CopyTo(typeof(Category), 0);
}

return new Category[0];
}

// 保存一个目录
public void SaveCategory(Category cat)
{
Persister.SaveAgileObject(cat);
}

// 在指定目录下，创建一个商品
public Product CreateProduct(string catId, string prodName, string prodDescription, string unitName, decimal price)
{
Category cat = GetCategory(catId);

if (cat != null)
{
Product prod = (Product)TypeService.CreateInstance(typeof(Product));

prod.CatId = catId;
prod.Name = prodName;
prod.Description = prodDescription;
prod.UnitName = unitName;
prod.Price = price;

return prod;
}

return null;
}

// 获取指定目录下的所有商品。在现实应用中，我们很少一次读取一个目录下的所有商品对象。为了性能，考虑到
// 商品列表页面大量商品同时显示的特点（“大量”和“显示”是关键词，这意味着量很大，但只是看），我们
// 往往会采取数据库段分页前台DataReader生成页面的方式，而绕过大量对象的加载。这一点将在“对象的持久化
// （高级）”一文中讲到。此处为了主题突出，暂且如此。
public Array GetProducts(string catId)
{
return Persister.LoadAgileObject(typeof(Product), new AgileObjectFilter(TypeService.GetObjectTypeDescription(typeof(Product)), "CatId={0}", new object[]{catId}));
}

public Product GetProduct(string prodId)
{
Product prod = (Product)Persister.LoadAgileObject(typeof(Product), prodId);

if (prod != null)
{
return prod;
}

return null;
}

public Product SuspendProduct(string prodId)
{
Product prod = (Product)Persister.LoadAgileObject(typeof(Product), prodId);

if (prod != null)
{
prod.Suspend();

return prod;
}

return null;
}

public void SaveProduct(Product prod)
{
Persister.SaveAgileObject(prod);
}

}

public class UserService
{
private static UserService s_Instance = new UserService();

public static UserService Instance
{
get
{
return s_Instance;
}
}

private static ITypeService TypeService
{
get
{
return (ITypeService)ServiceHub.Instance.GetService(typeof(ITypeService));
}
}

private static IPersister Persister
{
get
{
return (IPersister)ServiceHub.Instance.GetService(typeof(IPersister));
}
}

private UserService()
{
}

// 创建一个用户，我们暂不考虑loginId重复检测、用户密码等问题
public User CreateUser(string name, string loginId)
{
User user = (User)TypeService.CreateInstance(typeof(User));
user.Name = name;
user.LoginId = loginId;

return user;
}

// 根据Id获取一个用户
public User GetUser(string uid)
{
return (User)Persister.LoadAgileObject(typeof(User), uid);
}

// 根据登录名获取一个用户
public User GetUserByLoginId(string loginId)
{
return (User)Persister.LoadAgileObject(typeof(User), new AgileObjectFilter(TypeService.GetObjectTypeDescription(typeof(User)), "LoginId={0}", new object[]{loginId}))[0];
}
}


public class OrderService
{
private static OrderService s_Instance = new OrderService();

public static OrderService Instance
{
get
{
return s_Instance;
}
}

private static ITypeService TypeService
{
get
{
return (ITypeService)ServiceHub.Instance.GetService(typeof(ITypeService));
}
}

private static IPersister Persister
{
get
{
return (IPersister)ServiceHub.Instance.GetService(typeof(IPersister));
}
}

private OrderService()
{
}

// 创建一个用户，我们暂不考虑loginId重复检测、用户密码等问题
public Order CreateOrder(string prodId)
{
Order order = (Order)TypeService.CreateInstance(typeof(Order));

return order;
}

// 为订单创建一个订单项
public OrderItem CreateOrderItem(Order order, string prodId, decimal quantity)
{
if (order != null)
{
Product prod = ProductService.Instance.GetProduct(prodId);

if (prod != null)
{
OrderItem orderItem = (OrderItem)TypeService.CreateInstance(typeof(OrderItem));
orderItem.ProdId = prodId;
orderItem.Quantity = quantity;
orderItem.UnitPrice = prod.Price;
order.OrderItems.Add(orderItem);

return orderItem;
}
}

return null;
}

// 保存订单，订单项无需单独保存，只要保存订单，所属订单项就会自动与订单在同一个事务中被保存
public void SaveOrder(Order order)
{
Persister.SaveAgileObject(order);
}

// 获取一段时间内的所有订单，在西安市系统中的考虑与ProductService的GetProducts方法类似
public Array GetOrders(DateTime from, DateTime to)
{
return Persister.LoadAgileObject(typeof(Order), new AgileObjectFilter(TypeService.GetObjectTypeDescription(typeof(Order)), "CreatedTime>={0} and CreatedTime<{1}", new object[]{from, to}));
}
}
}