48 Deleting and Updating an Entity in a Single Cloud Data Storage Table Below are some concepts we should be aware of before we move to the exercise for deleting and updating data from
Trang 148
Deleting and Updating an Entity in a Single Cloud Data
Storage Table
Below are some concepts we should be aware of before we move to the exercise for deleting and updating data from cloud table storage Essentially, the class DataServiceContext plays a core role for all cloud table storage I/O, including the data retrieving action we have been using so far If you go back to look at the project we created, the base class ofAddressTableContext is in a hierarchical relationship with DataServiceContext;you can trace down like this:AddressTableContext ➤ TableContext ➤ TableStorageDataServiceContext ➤ DataServiceContext
• For each entity table in Azure cloud table storage there is an internal property
called tracked that is assigned when a table is created This is for the DataServiceContext to track the concurrency of the data table The options for the value for this property are AppendOnly, OverwriteChanges, PreserveChanges, and NoTracking It is mandatory to assign a value to this property before the data I/O actions, such as updating, inserting, and deleting How to determine the selection
of this attribute should be analyzed on a case-by-case basis
• The default setting is AppendOnly This option means the server will not load the entity instance if the instance is already presented in the caches
When this option is selected and the entity is already tracked by a previous retrieve call, the DataServiceContext object will not update There is a chance the update will fail unless the application has very good information about the previous action's updating call
• If the OverwriteChanges option is selected, the DataServiceContext always loads the entity instance from the server and keeps it up to date and overwrites the previously tracked entity
• If PreserveChanges is selected, any property changes made to the entity object DataServiceContext are preserved This should be a good choice when recovering from concurrency errors is required Using PreserveChanges is the best way to ensure that the data is updated, because the server always loads the entity prior to update The price to pay is less efficient performance
• If NoTracking is selected, the AttachTo() method must be called prior to updating the data
• Use LINQ to put data into the DataServiceContextobject,and use a C# class as a
data container object to hold the values to be updated
• Add the C# object back to the same DataServiceContextobject for update by
calling the AttachTo() method and use the same object to perform update actions
• Call the method SaveChanges() using the instance of DataServiceContext classto
send the update request to the server
Next we go back to the main topic of this exercise In order to reuse the code in the next exercise
we are going to abstract our object architecture based on the previous exercise to introduce three interfaces—ICloudEntity, ITableContext, and ICloudTableStorageService—and three new classes—
Trang 249
TableContext, DataTableService, and CloudTableServiceFactory This will allow us to reuse the code to handle multiple data entities in our future development Figure 2-14 shows the definition of properties and methods for the three interfaces in detail
Figure 2-14 Interfaces definition for cloud entity, cloud table storage service, and cloud table context
■ Note The code for this example is in the exercise 2-2 bundle from the code download
The interface definition for ICloudEntity is shown in Listing 2-16 This interface exposes four
methods: GetPartitionKey(), GetRowKey(), GetDependencyEntity(), and SetDependencyEntity()
Listing 2-16 Interface ICloudEntity Definition
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CloudTableStorageService WebRole.CloudTableStrorageDataEntity
{
using Microsoft.Samples.ServiceHosting.StorageClient;
public interface ICloudEntity
{
string GetPartitionKey();
string GetRowKey();
ICloudEntity GetDepenencyEntity();
void SetDependencyEntity(ICloudEntity entity);
List<ICloudEntity> DependencyType();
}
}
Trang 350
The interface definition for ICloudTableStorageService is shown in Listing 2-17 This interface expose four methods One method is called TableContext() with return type of TableContext (we are going to define this new base class after the interfaces definitions), and the remaining three are basic data table I/O methods: Insert(), Update(), and Delete() These three data table I/O functions accept the ICloudEntity type parameter A class that implements the interface ICloudTableStorageService is used as the I/O service to expose the cloud table data It is also responsible for resolving dependency issues (the relation between parent or child entity objects) during data table access in order to keep the integrity of the entire data structure
Listing 2-17 Interface ICloudTableStorageService Definition
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CloudTableStorageService WebRole.CloudTableStorageDataService
{
using Microsoft.Samples.ServiceHosting.StorageClient;
using CloudTableStorageService WebRole.CloudTableStrorageDataEntity;
using CloudTableStorageService WebRole.CloudTableStorageDataContext;
public interface ICloudTableStorageService
{
bool Insert(ICloudEntity entity);
bool Update(ICloudEntity entity);
bool Delete(ICloudEntity entity);
TableContext TableContext();
}
}
The interface definition for ITableContext is shown Listing 2-18 This interface defines one property TableName with a get/set accessing pair and two methods, QueryEntitiesByPartitionKey() and
QueryEntitiesByRowKey() The return type for these two methods is ICloudEntity, and the input
parameter is PartitionKey and RowKey respectively ITableContext is the facade class of a cloud data storage table that is responsible for retrieving URL endpoint information during the table context construction This interface defines the basic query function for retrieving the cloud storage table
Listing 2-18 Interface ITableContext Definition
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CloudTableStorageService WebRole.CloudTableStorageDataContext
{
using CloudTableStorageService WebRole.CloudTableStrorageDataEntity;
public interface ITableContext
{
Trang 451
string TableName { get; set; }
ICloudEntity QueryEntitiesByPartionKey(string partitionKey);
ICloudEntity QueryEntitiesByRowKey(string rowKey);
}
}
As Listing 2-19 shows, a new abstract base class TableContext is defined to implement the interface ITableContext This base class inherits from the class TableStorageDataServiceContext of StorageClient implemented in the Azure SDK This class has one property access function, TableName, and two abstract methods, QueryEntitiesByPartitionKey() and QueryEntitiesByRowKey()
Listing 2-19 Abstract Base Class
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace CloudTableStorageService WebRole.CloudTableStorageDataContext
{
using Microsoft.Samples.ServiceHosting.StorageClient;
using CloudTableStorageService WebRole.CloudTableStrorageDataEntity;
abstract public class TableContext : TableStorageDataServiceContext, ITableContext
{
public string TableName { get; set; }
public TableContext(StorageAccountInfo accountInfo)
: base(accountInfo)
{
}
abstract public ICloudEntity QueryEntitiesByPartionKey(string partitionKey);
abstract public ICloudEntity QueryEntitiesByRowKey(string rowKey);
}
}
The class CloudTableServiceFactory is a utility class that implements the factory method design
pattern using.NET Reflection to dynamically instantiate the concrete cloud table entity subclasses The implementation of this class is shown in Listing 2-20
Listing 2-20 The Class CloudTableServiceFactory Implements the Factory Method Design Pattern Used
to Dynamically Create a Concrete Cloud Table Class
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Reflection;
Trang 552
namespace CloudTableStorageService WebRole.CloudTableStorageDataService
{
using CloudTableStorageService WebRole.CloudTableStrorageDataEntity;
public class CloudTableServiceFactory
{
public CloudTableServiceFactory()
{
}
public ICloudTableStorageService FactoryCloudTableService(ICloudEntity entity) {
ICloudTableStorageService cloudTableStorageService = null;
try
{
Assembly assembly = Assembly.GetExecutingAssembly();
string typeName =
string.Format(
"{0}.{1}TableService", this.GetType().Namespace,
entity.GetType().Name);
cloudTableStorageService =
Activator.CreateInstance(assembly.GetType(typeName), new object[] { })
as ICloudTableStorageService;
}
catch (Exception ex)
{
}
return cloudTableStorageService;
}
}
}
As Listing 2-21 shows, we have re-engineered the class DataTableService to implement the interface ICloudTableStorageService A new member variable with type of CloudTableServiceFactory is defined
in this class and has been instantiated in the constructor The major modification to the cloud table data I/O methods, such as Insert(), Update(), and Delete(), from the versions used in the previous exercise
is looping through the dependency tables to apply the data I/O actions The instances of the data table service for all dependency data tables are dynamically created using the class names The dependency table collection list of a data entity table is populated in the data entity table class constructor by calling the method Initialization()
Listing 2-21 Re-engineering the Class DataTableService to Implement the Interface
ICloudTableStorageService
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.Services.Client;