After a great presentation by Jason Sheehan at MDC about RestSharp, I decided to implement it.
RestSharp is a .Net framework for consuming restful
data sources via either Json or XML.
My first step was to put together a Restful
data source for RestSharp to consume. Staying entirely withing .Net, I decided to use Microsoft's oData implementation, built on System.
Data.Services.DataServices. Natively, these support Json, or atom+pub xml. (XML with a few bells and whistles added on)
There are three main steps for creating an oData
data source:
1) override CreateDSPMetaData
This is where the metadata
data is returned. The meta
data defines the structure of the
data to return. The structure contains the relationships between
data objects, along with what properties the objects expose. The meta
data can and should be somehow cached so that the structure is not rebuild with every
data request.
2) override CreateDataSource
The context contains the
data the
data source will publish. This method is the conduit which will populate the metadata objects to be returned to the requestor.
3) implement static InitializeService
At this point we can set
up security, along with setting
up properties of the web service (versioning, etc)
Here is a web service which publishes stock prices for various Products (stocks) in various Categories.
namespace RestService
{
public class RestServiceImpl : DSPDataService<DSPContext>
{
private static DSPContext _context;
private static DSPMetadata _metadata;
/// <summary>
/// Populate traversable
data source
/// </summary>
/// <returns></returns>
protected override DSPContext CreateDataSource()
{
if (_context == null)
{
_context = new DSPContext();
Category utilities = new Category(0);
utilities.Name = "Electric";
Category financials = new Category(1);
financials.Name = "Financial";
IList products = _context.GetResourceSetEntities("Products");
Product electric = new Product(0, utilities);
electric.Name = "ABC Electric";
electric.Description = "Electric Utility";
electric.Price = 3.5;
products.Add(electric);
Product water = new Product(1, utilities);
water.Name = "XYZ Water";
water.Description = "Water Utility";
water.Price = 2.4;
products.Add(water);
Product banks = new Product(2, financials);
banks.Name = "FatCat Bank";
banks.Description = "A bank that's almost too big";
banks.Price = 19.9; // This will never get to the client
products.Add(banks);
IList categories = _context.GetResourceSetEntities("Categories");
categories.Add(utilities);
categories.Add(financials);
utilities.Products.Add(electric);
utilities.Products.Add(electric);
financials.Products.Add(banks);
}
return _context;
}
/// <summary>
/// Setup rules describing published
data structure - relationships between
data,
/// key field, other searchable fields, etc.
/// </summary>
/// <returns></returns>
protected override DSPMetadata CreateDSPMetadata()
{
if (_metadata == null)
{
_metadata = new DSPMetadata("DemoService", "DataServiceProviderDemo");
// Define entity type product
ResourceType product = _metadata.AddEntityType(typeof(Product), "Product");
_metadata.AddKeyProperty(product, "ProductID");
// Only add properties we wish to share with end users
_metadata.AddPrimitiveProperty(product, "Name");
_metadata.AddPrimitiveProperty(product, "Description");
EntityPropertyMappingAttribute att = new EntityPropertyMappingAttribute("Name",
SyndicationItemProperty.Title, SyndicationTextContentKind.Plaintext, true);
product.AddEntityPropertyMappingAttribute(att);
att = new EntityPropertyMappingAttribute("Description",
SyndicationItemProperty.Summary, SyndicationTextContentKind.Plaintext, true);
product.AddEntityPropertyMappingAttribute(att);
// Define products as a set of product entities
ResourceSet products = _metadata.AddResourceSet("Products", product);
// Define entity type category
ResourceType category = _metadata.AddEntityType(typeof(Category), "Category");
_metadata.AddKeyProperty(category, "CategoryID");
_metadata.AddPrimitiveProperty(category, "Name");
_metadata.AddPrimitiveProperty(category, "Description");
// Define categories as a set of category entities
ResourceSet categories = _metadata.AddResourceSet("Categories", category);
att = new EntityPropertyMappingAttribute("Name",
SyndicationItemProperty.Title, SyndicationTextContentKind.Plaintext, true);
category.AddEntityPropertyMappingAttribute(att);
att = new EntityPropertyMappingAttribute("Description",
SyndicationItemProperty.Summary, SyndicationTextContentKind.Plaintext, true);
category.AddEntityPropertyMappingAttribute(att);
// A product has a category, a category has products
_metadata.AddResourceReferenceProperty(product, "Category", categories);
_metadata.AddResourceSetReferenceProperty(category, "Products", products);
}
return _metadata;
}
/// <summary>
/// Based on the requesting user, can set
up permissions to Read, Write, etc.
/// </summary>
/// <param name="config"></param>
public static void InitializeService(DataServiceConfiguration config)
{
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
config.DataServiceBehavior.AcceptProjectionRequests = true;
}
}
}
The objects prefixed with DSP come from the samples on the oData site: http://www.odata.org/developers
The products and categories objects are POCO business objects with no special modifiers.
Three main options are available for defining the MetaData of
data sources in .Net:
1) Generate Entity
Data model (Potentially directly from SQL Server database). This requires the least amount of manual interaction, and uses the edmx WYSIWYG editor to generate a
data model. This can be directly tied to the SQL Server database and generated from the database if you want a
data access layer tightly coupled with your database.
2) Object model decorations. If you already have a POCO
data layer, you can decorate your objects with properties to statically inform the compiler how the objects are related. The disadvantage is there are now tags strewn about your business layer that need to be updated as the business rules change.
3) Programmatically construct metadata object. This is the object illustrated above in CreateDSPMetaData. This puts all relationship information into one central programmatic location. Here business rules are constructed when the DSPMetaData response object is returned.
Once you have your service
up and running, RestSharp is designed for XML / Json, along with the native Microsoft library. There are currently some differences between how Jason made RestSharp expect XML with how atom+pub works, so I found better results currently with the Json implementation - modifying the RestSharp XML parser to make an atom+pub parser is fairly trivial though, so use what implementation works best for you.
I put together a sample console app which calls the RestSvcImpl.svc service defined above (and assumes it to be running on port 2000). I used both RestSharp as a client, and also the default Microsoft oData client tools.
namespace RestConsole
{
class Program
{
private static DataServiceContext _ctx;
private enum DemoType
{
Xml,
Json
}
static void Main(string[] args)
{
// Microsoft implementation
_ctx = new DataServiceContext(new System.Uri("http://localhost:2000/RestServiceImpl.svc"));
var msProducts = RunQuery<Product>("Products").ToList();
var msCategory = RunQuery<Category>("/Products(0)/Category").AsEnumerable().Single();
var msFilteredProducts = RunQuery<Product>("/Products?$filter=length(Name) ge 4").ToList();
// RestSharp implementation
DemoType demoType = DemoType.Json;
var client = new RestClient("http://localhost:2000/RestServiceImpl.svc");
client.ClearHandlers(); // Remove all available handlers
// Set
up handler depending on what situation dictates
if (demoType == DemoType.Json)
client.AddHandler("application/json", new RestSharp.Deserializers.JsonDeserializer());
else if (demoType == DemoType.Xml)
{
client.AddHandler("application/atom+xml", new RestSharp.Deserializers.XmlDeserializer());
}
var request = new RestRequest();
if (demoType == DemoType.Json)
request.RootElement = "d"; // service root element for json
else if (demoType == DemoType.Xml)
{
request.XmlNamespace = "http://www.w3.org/2005/Atom";
}
// Return all products
request.Resource = "/Products?$orderby=Name";
RestResponse<List<Product>> productsResp = client.Execute<List<Product>>(request);
List<Product> products = productsResp.Data;
// Find category for product with ProductID = 1
request.Resource = string.Format("/Products(1)/Category");
RestResponse<Category> categoryResp = client.Execute<Category>(request);
Category category = categoryResp.Data;
// Specialized queries
request.Resource = string.Format("/Products?$filter=ProductID eq {0}", 1);
RestResponse<Product> productResp = client.Execute<Product>(request);
Product product = productResp.Data;
request.Resource = string.Format("/Products?$filter=Name eq '{0}'", "XYZ Water");
productResp = client.Execute<Product>(request);
product = productResp.Data;
}
private static IEnumerable<TElement> RunQuery<TElement>(string queryUri)
{
try
{
return _ctx.Execute<TElement>(new Uri(queryUri, UriKind.Relative));
}
catch (Exception ex)
{
throw ex;
}
}
}
}
Feel free to step through the code a few times and to attach a debugger to the service as well to see how and where the context and metadata objects are constructed and returned. Pay special attention to the response object being returned by the oData service - There are several properties of the RestRequest that can be used to help troubleshoot when the structure of the response is not exactly what would be expected.
