namespace PetShop.BLL {
/// <summary>
/// This is a synchronous implementation of IOrderStrategy
/// By implementing IOrderStrategy interface, the developer can
/// add a new order insert strategy without re-compiling the whole
/// BLL.
/// </summary>
public class OrderSynchronous : IOrderStrategy {
...
/// <summary>
/// Inserts the order and updates the inventory stock within
/// a transaction.
/// </summary>
/// <param name="order">All information about the order</param>
public void Insert(PetShop.Model.OrderInfo order) {

using (TransactionScope ts = new
TransactionScope(TransactionScopeOption.Required)) {

dal.Insert(order);

// Update the inventory to reflect the current inventory
// after the order submission.
Inventory inventory = new Inventory();
inventory.TakeStock(order.LineItems);

// Calling Complete commits the transaction.
// Excluding this call by the end of TransactionScope's
// scope will rollback the transaction.
ts.Complete();
}
}
}
}

using System;
using System.Collections;
using System.EnterpriseServices;
using System.Runtime.InteropServices;
...
namespace PetShop.BLL {
/// <summary>
/// A business component to manage the creation of orders
/// Creation of an order requires a distributed transaction
/// so the Order class derives from ServicedComponents
/// </summary>
[Transaction(System.EnterpriseServices.TransactionOption.Required)]
[ClassInterface(ClassInterfaceType.AutoDispatch)]
[ObjectPooling(MinPoolSize=4, MaxPoolSize=4)]
[Guid("14E3573D-78C8-4220-9649-BA490DB7B78D")]
public class OrderInsert : ServicedComponent {
...
/// <summary>
/// A method to insert a new order into the system
/// The orderId will be generated within the method and should not
/// be supplied as part of the order creation the inventory will be
/// reduced by the quantity ordered.
/// </summary>
/// <param name="order">All the information about the order</param>
/// <returns>
/// The new orderId is returned in the order object
/// </returns>
[AutoComplete]
public int Insert(OrderInfo order) {

// Get an instance of the Order DAL using the DALFactory
IOrder dal = PetShop.DALFactory.Order.Create();

// Call the insert method in the DAL to insert the header
int orderId = dal.Insert(order);

// Get an instance of the Inventory business component
Inventory inventory = new Inventory();
inventory.TakeStock( order.LineItems);
...

// Set the orderId so that it can be returned to the caller
return orderId;
}
}
}

/// <summary>
/// A method to retrieve products by category name
/// </summary>
/// <param name="order">The category name to search by</param>
/// <returns>A Generic List of ProductInfo</returns>
public IList<ProductInfo>GetProductsByCategory(string category) {

// Return new if the string is empty
if (string.IsNullOrEmpty(category))
return new List<ProductInfo>();

// Run a search against the data store
return dal.GetProductsByCategory(category);
}

以下是 Pet Shop 3 中的等效代码，它返回一个 IList：

清单 4. Product.cs (Pet Shop 3)

/// <summary>
/// A method to retrieve products by category name
/// </summary>
/// <param name="order">The category name to search by</param>
/// <returns>
/// An interface to an arraylist of the search results
/// </returns>
public IList GetProductsByCategory(string category) {

// Return null if the string is empty
if (category.Trim() == string.Empty)
return null;

// Get an instance of the Product DAL using the DALFactory
IProduct dal = PetShop.DALFactory.Product.Create();

// Run a search against the data store
return dal.GetProductsByCategory(category);
}

<membership defaultProvider="SQLMembershipProvider">
<providers>
<add name="SQLMembershipProvider"
type="System.Web.Security.SqlMembershipProvider"
connectionStringName="SQLMembershipConnString"
applicationName=".NET Pet Shop 4.0"
enablePasswordRetrieval="false"
enablePasswordReset="true"
requiresQuestionAndAnswer="false"
requiresUniqueEmail="false"
passwordFormat="Hashed"/>
</providers>
</membership>

using System;
using System.Configuration.Provider;

namespace PetShop.Membership {
class OracleMembershipProvider : MembershipProvider {


string password, string email, string passwordQuestion,
string passwordAnswer, bool isApproved, object userId,
out MembershipCreateStatus status) {

// create connection
OracleConnection connection =
new OracleConnection(OracleHelper.ConnectionStringMembership);
connection.Open();
OracleTransaction transaction =
connection.BeginTransaction(IsolationLevel.ReadCommitted);

try {
DateTime dt = DateTime.Now;
bool isUserNew = true;

// Step 1: Check if the user exists in the Users
// table: Create if not
int uid = GetUserID(transaction, applicationId, username, true,
false, dt, out isUserNew);
if (uid == 0) { // User not created successfully!
status = MembershipCreateStatus.ProviderError;
return null;
}

// Step 2: Check if the user exists in the Membership table: Error
// if yes
if (IsUserInMembership(transaction, uid)) {
status = MembershipCreateStatus.DuplicateUserName;
return null;
}

// Step 3: Check if Email is duplicate
if (IsEmailInMembership(transaction, email, applicationId)) {
status = MembershipCreateStatus.DuplicateEmail;
return null;
}

// Step 4: Create user in Membership table
int pFormat = (int)passwordFormat;
if (!InsertUser(transaction, uid, email, pass, pFormat, salt, "",
"", isApproved, dt)) {
status = MembershipCreateStatus.ProviderError;
return null;
}

// Step 5: Update activity date if user is not new
if(!isUserNew) {
if(!UpdateLastActivityDate(transaction, uid, dt)) {
status = MembershipCreateStatus.ProviderError;
return null;
}
}

status = MembershipCreateStatus.Success;

return new MembershipUser(this.Name, username, uid, email,
passwordQuestion, null, isApproved,
false, dt, dt, dt, dt, DateTime.MinValue);
}
catch(Exception) {
if(status == MembershipCreateStatus.Success)
status = MembershipCreateStatus.ProviderError;
throw;
}
finally {
if(status == MembershipCreateStatus.Success)
transaction.Commit();
else
transaction.Rollback();

connection.Close();
connection.Dispose();
}
}

// Carry over profile property values from an anonymous to an
// authenticated state
void Profile_MigrateAnonymous(Object sender, ProfileMigrateEventArgs e) {
ProfileCommon anonProfile = Profile.GetProfile(e.AnonymousID);

// Merge anonymous shopping cart items to the authenticated
// shopping cart items
foreach (CartItemInfo cartItem in
anonProfile.ShoppingCart.CartItems)
Profile.ShoppingCart.Add(cartItem);

// Merge anonymous wishlist items to the authenticated wishlist
// items
foreach (CartItemInfo cartItem in anonProfile.WishList.CartItems)
Profile.WishList.Add(cartItem);

// Clean up anonymous profile
ProfileManager.DeleteProfile(e.AnonymousID);
AnonymousIdentificationModule.ClearAnonymousIdentifier();

// Save profile
Profile.Save();
}

using System;
using System.Collections.Generic;
using PetShop.Model;

namespace PetShop.BLL {

/// <summary>
/// An object to represent a customer's shopping cart.
/// This class is also used to keep track of customer's wish list.
/// </summary>
[Serializable]
public class Cart {

// Internal storage for a cart
private Dictionary cartItems =
new Dictionary();

/// <summary>
/// Calculate the total for all the cartItems in the Cart
/// </summary>
public decimal Total {
get {
decimal total = 0;
foreach (CartItemInfo item in cartItems.Values)
total += item.Price * item.Quantity;
return total;
}
}

/// <summary>
/// Update the quantity for item that exists in the cart
/// </summary>
/// Item Id
/// Quantity
public void SetQuantity(string itemId, int qty) {
cartItems[itemId].Quantity = qty;
}

/// <summary>
/// Return the number of unique items in cart
/// </summary>
public int Count {
get { return cartItems.Count; }
}

/// <summary>
/// Add an item to the cart.
/// When ItemId to be added has already existed, this method
/// will update the quantity instead.
/// </summary>
/// Item Id of item to add
public void Add(string itemId) {
CartItemInfo cartItem;
if (!cartItems.TryGetValue(itemId, out cartItem)) {
Item item = new Item();
ItemInfo data = item.GetItem(itemId);
if (data != null) {
CartItemInfo newItem = new CartItemInfo(itemId,
data.ProductName, 1, (decimal)data.Price,
data.Name, data.CategoryId, data.ProductId);
cartItems.Add(itemId, newItem);
}
}
else
cartItem.Quantity++;
}

/// <summary>
/// Add an item to the cart.
/// When ItemId to be added has already existed, this method
/// will update the quantity instead.
/// </summary>
/// Item to add
public void Add(CartItemInfo item) {
CartItemInfo cartItem;
if (!cartItems.TryGetValue(item.ItemId, out cartItem))
cartItems.Add(item.ItemId, item);
else
cartItem.Quantity += item.Quantity;
}

/// <summary>
/// Remove item from the cart based on itemId
/// </summary>
/// ItemId of item to remove
public void Remove(string itemId) {
cartItems.Remove(itemId);
}

/// <summary>
/// Returns all items in the cart. Useful for looping through
/// the cart.
/// </summary>
/// Collection of CartItemInfo
public ICollection CartItems {
get { return cartItems.Values; }
}

/// <summary>
/// Method to convert all cart items to order line items
/// </summary>
/// A new array of order line items
public LineItemInfo[] GetOrderLineItems() {

LineItemInfo[] orderLineItems =
new LineItemInfo[cartItems.Count];
int lineNum = 0;

foreach (CartItemInfo item in cartItems.Values)
orderLineItems[lineNum] = new LineItemInfo(item.ItemId,
item.Name, ++lineNum, item.Quantity, item.Price);

return orderLineItems;
}

/// <summary>
/// Clear the cart
/// </summary>
public void Clear() {
cartItems.Clear();
}
}
}