Sean McAlinden's Blog

Windows Phone 7 Database Rapid Repository V2.0 Caching

SeanMcAlinden — Sun, 19 Dec 2010 00:16:00 GMT

Rapid Repository is a Windows Phone 7 Database and Silverlight Isolated Storage Database.

Download Rapid Repository from Microsoft Codeplex

Blog Tutorials

All entities used at runtime are put into a cache by default.

If you are likely to be getting all of the entities out of the database each time the application runs you can eager load the cache for much improved performance.

The eager load runs on a separate thread so as not to affect the application page rendering.

You call eager load for each entity type at application start up or in the main page constructor.

Eager Load
 public MainPage()
{
    InitializeComponent();
 
    EntityCache.EagerLoad<Customer>();
}
 

If you need to turn off caching, you can set NoCache for each entity type you wish to be excluded at start up.

No Cache
 public MainPage()
{
    InitializeComponent();
 
    EntityCache.NoCache<Customer>();
}
 

Summary

If you are eager loading to perform queries against the entities within the database faster, consider using Views and Filters instead as this will be much quicker that loading and querying the full list of entities.

I hope you find this useful.

Sean McAlinden.

Windows Phone 7 Database Rapid Repository V2.0 File Helper

SeanMcAlinden — Sun, 19 Dec 2010 00:16:00 GMT

Rapid Repository is a Windows Phone 7 Database and Silverlight Isolated Storage Database.

Download Rapid Repository from Microsoft Codeplex

Blog Tutorials

I have added some methods for saving, retrieving and deleting files which are not entities.

If you have a large amount of data such as the byte array of an image, storing the byte array directly in the entity could cause a significant performance problem as converting the byte[] to json can take quite a long time on a phone.

A better solution would be to store the byte array as a separate file and just hold a pointer to the file on the entity.

For example:

User Profile
 public class Profile : IRapidEntity
{
    public string UserName { get; set; }
    public Guid Photo { get; set; }
}
 

Using the above class, you could store a link to an image stored as a byte array string within the file system.

Save User Profile
 public void SavePhoto(string userName, Byte[] photo)
{
    RapidRepository<Profile> repository = new RapidRepository<Profile>();
 
    // convert the byte array to a string.
    string photoString = Encoding.UTF8.GetString(photo, 0, photo.Length);
 
    Profile profile = new Profile();
    profile.UserName = userName;
    profile.Photo = RapidRepository.File.Save(photoString);
 
    repository.Add(profile);
    RapidContext.CurrentContext.SaveChanges();    
}
 

You can load the file back using the value stored in the entity.

Load Photo
 public byte[] LoadPhoto(Profile userProfile)
{
    string photoString = RapidRepository.File.Load(userProfile.Photo);
    return Encoding.UTF8.GetBytes(photoString);
}
 

You can also delete the file using the same Guid value.

Delete Photo
 public void DeletePhoto(Profile userProfile)
{
    RapidRepository.File.Delete(userProfile.Photo);
}
 

Summary

I hope you find these helper methods useful.

Sean McAlinden.

Windows Phone 7 Database Rapid Repository V2.0 Examining Operation Requests

SeanMcAlinden — Sun, 19 Dec 2010 00:16:00 GMT

Rapid Repository is a Windows Phone 7 Database and Silverlight Isolated Storage Database.

Download Rapid Repository from Microsoft Codeplex

Blog Tutorials

Release Overview
Creating and saving entities
Create, read, update and delete operations
Querying with views and filters
Caching
File Helper
Examining Operation Requests

If you need to examine the pending operation requests or even remove pending requests before calling SaveChanges() you can access them through the following property:

Examine Operation Requests
 public void ExamineOperationRequests()
{
    List<OperationRequest> requests = RapidContext.CurrentContext.OperationRequests;
}
 

If you need to delete a request or all off the requests you can use the following methods:

Operation Request Methods
 public void ExamineOperationRequests()
{
    List<OperationRequest> requests = RapidContext.CurrentContext.OperationRequests;
 
    RapidContext.CurrentContext.DeleteOperationRequest(requests.First());
 
    RapidContext.CurrentContext.DeleteAllOperationRequests();
}
 

The operation request class has the following properties you can use for examination:

Operation Requests Properties
 /// <summary>
/// Gets or sets the entity id.
/// </summary>
/// <value>The entity id.</value>
public Guid EntityId { get; private set; }
 
/// <summary>
/// Gets or sets the entity.
/// </summary>
/// <value>The entity.</value>
public object Entity { get; private set; }
 
/// <summary>
/// Gets or sets the type of the entity.
/// </summary>
/// <value>The type of the entity.</value>
public Type EntityType { get; private set; }
 
/// <summary>
/// Gets or sets the type of the operation.
/// </summary>
/// <value>The type of the operation.</value>
public OperationRequestType OperationRequestType { get; private set; }
 

Summary

Although I don’t imagine this will be used often, it’s a feature that is there just in case, i imagine it will mostly be used in cases where compensation for transactions is required.

In the next version of Rapid Repository, there will be transactional support which should further remove the need for this feature, it will stay in though.

Sean McAlinden.

Windows Phone 7 Database Rapid Repository V2.0 Create Read Update and Delete

SeanMcAlinden — Sun, 19 Dec 2010 00:15:00 GMT

Rapid Repository is a Windows Phone 7 Database and Silverlight Isolated Storage Database.

Download Rapid Repository from Microsoft Codeplex

Blog Tutorials

Release Overview
Creating and saving entities
Create, read, update and delete operations
Querying with views and filters
Caching
File Helper
Examining Operation Requests

The Windows 7 phone database Rapid Repository makes create, read, update and delete functionality extremely simple.

The following examples will show how to perform these operations including an extra helper method called Exists.

The following entity classes will be used throughout the examples.

Player
 public class Player : IRapidEntity
{
    public Guid Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public List<GameScore> Scores { get; set; }
 
    public Player()
    {
        this.Scores = new List<GameScore>();
    }
}
 

GameScore
 public class GameScore
{
    public double Score { get; set; }
    public DateTime Date { get; set; } 
}
 

Create

As seen in my previous post, a create is performed by simply calling Add on the repository and saving the changes.

Save Player
 public void SavePlayer()
{
    Player newPlayer = new Player { FirstName = "Sean", LastName = "Mcalinden", Scores = new List<GameScore>() };
    newPlayer.Scores.Add(new GameScore { Score = 123, Date = DateTime.Now });
 
    RapidRepository<Player> repository = new RapidRepository<Player>();
    repository.Add(newPlayer);
    RapidContext.CurrentContext.SaveChanges();
}
 

Update

An entity is updated by simply passing the entity to the update method on the repository and saving the changes.

Update Player
 public void Update(Player player)
{
    player.Scores.Add(new GameScore { Score = 111, Date = DateTime.Now });
 
    RapidRepository<Player> repository = new RapidRepository<Player>();
    repository.Update(player);
    RapidContext.CurrentContext.SaveChanges();
}
 

Delete

Delete operations can be achieved by either passing the Id of the entity or by passing in the entity itself.

Delete
 public void Delete(Guid Id)
{
    RapidRepository<Player> repository = new RapidRepository<Player>();
    repository.Delete(Id);
    RapidContext.CurrentContext.SaveChanges();
}
 
public void Delete(Player player)
{
    RapidRepository<Player> repository = new RapidRepository<Player>();
    repository.Delete(player);
    RapidContext.CurrentContext.SaveChanges();
}
 

Exists

The following shows an example of how to check whether an entity exists before performing an action.

Exists
 public void Exists(Guid id)
{
    RapidRepository<Player> repository = new RapidRepository<Player>();
    if(repository.Exists(id))
    {
        // do something
    }
}
 

GetById

The following shows how to retrieve an entity by it’s Id.

GetById
 public void GetById(Guid id)
{
    RapidRepository<Player> repository = new RapidRepository<Player>();
    Player entity = repository.GetById(id);
}
 

GetAll

The following shows how to retrieve all entities of a given type, this returns a list which you can filter using linq or lambda.

GetAll
 public void GetAll()
{
    RapidRepository<Player> repository = new RapidRepository<Player>();
    IList<Player> players = repository.GetAll();
}
 

Linq & Lambda
 public void GetAll()
{
    RapidRepository<Player> repository = new RapidRepository<Player>();
 
    IEnumerable<Player> lambda = repository.GetAll()
        .Where(x => x.LastName == "McAlinden");
 
    IEnumerable<Player> linq = from p in repository.GetAll()
                         where p.LastName == "McAlinden"
                         select p;
}
 

Summary

This covers all of the main repository methods.

The next post will show a much better way to query the database using Views and Filters.

I Hope this is useful.

Kind Regards,

Sean McAlinden.

Windows Phone 7 Database Rapid Repository V2.0 Querying with Views and Filters

SeanMcAlinden — Sun, 19 Dec 2010 00:15:00 GMT

Rapid Repository is a Windows Phone 7 Database and Silverlight Isolated Storage Database.

Download Rapid Repository from Microsoft Codeplex

Blog Tutorials

Release Overview
Creating and saving entities
Create, read, update and delete operations
Querying with views and filters
Caching
File Helper
Examining Operation Requests

Views and Filters are the main features driving Rapid Repository V2.0.

The purpose of Views and Filters are to greatly improve performance when querying the database.

The following examples will show how to create and use views and filters.

For the examples we are going to be using the following entities:

Customer
 public class Customer : IRapidEntity
{
    public Guid Id { get; set; }
    public string Title {get;set;}
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string PhoneNumber { get; set; }
    public string MobileNumber { get; set; }
    public Address Address { get; set; }
}
 
public class Address
{
    public string HouseNumber { get; set; }
    public string PostCode { get; set; }
}
 

What are Views and why use them?

Views are simply a subset of an entity, lets say you are designing a page that lists the last name and postal code of each customer, it would be really inefficient to load all of the entity data just to display this limited amount of data (especially if you have a lot of data).

In this scenario, the page would be better served with a flattened list of classes containing just the information it requires for the page, this is called a View Model.

For the rest of the examples we are going to create and use the following View Model:

Customer View Model
 public class CustomerViewModel : IRapidView
{
    public Guid Id { get; set; }
    public string LastName { get; set; }
    public string PostCode { get; set; }
}
 

You will notice that along with the data required for displaying on the page, there is also an Id property enforced by the IRapidView interface.

This Id is set to the Id of the actual entity when the view is created, this allows GetById to be called using the View Model Id and have the actual entity returned.

Creating the View

Creating the view is really simple although it does require the use of lambda.

During application start up or in the MainPage constructor, you need to set up the mapping for the view.

This is achieved by mapping the View Model properties to it’s corresponding entity property.

The following example creates the mapping for the CustomerViewModel:

Setup View Mapping
 public MainPage()
{
    InitializeComponent();
 
    RapidRepository<Customer>.AddView<CustomerViewModel>(x => new CustomerViewModel { LastName = x.LastName, PostCode = x.Address.PostCode });
}
 

As you can see, in this case a mapping has been created for the CustomerViewModel in the main page constructor.

Querying the View

Once the mapping is setup, you can query the view data by using the Query method on the repository.

The following example shows the View being queried and filtered to only retrieve customers from south west London.

Querying the View
 public void DisplayCustomersInSouthWestLondon()
{
    RapidRepository<Customer> repository = new RapidRepository<Customer>();
 
    IList<CustomerViewModel> londonCustomers = repository.Query<CustomerViewModel>()
        .Where(x => x.PostCode.StartsWith("SW")).ToList();
 
    myListBox.ItemSource = londonCustomers;
}
 

First thing to notice is the View type is passed as a generic argument, this is because an entity could have many different views for different pages.

As previously mentioned, you can get the actual entity from the database using the Id of a View.

Get Customer Entity
 public void DisplayCustomersInSouthWestLondon()
{
    RapidRepository<Customer> repository = new RapidRepository<Customer>();
 
    IList<CustomerViewModel> londonCustomers = repository.Query<CustomerViewModel>()
        .Where(x => x.PostCode.StartsWith("SW")).ToList();
 
    Customer firstCustomerInList = repository.GetById(londonCustomers[0].Id);
}
 

Filtering the View

In the example so far, we are retrieving the View and then filtering it further by postal code, if the page is actually only ever going to display customers from London we could pre filter the view.

This further aids performance and reduces the code we have to write when querying the database.

Pre-filtering is achieved using the AddFilter method when the View mapping is set up.

Adding a filter.
 public MainPage()
{
    InitializeComponent();
 
    RapidRepository<Customer>.AddView<CustomerViewModel>(x => new CustomerViewModel { LastName = x.LastName, PostCode = x.Address.PostCode })
        .AddFilter(x => x.PostCode.StartsWith("SW"));
}
 

As you can see, the same filter we were achieving using lambda is now a fixed filter for the view, this means that only the data that is actually required for this View is saved.

You can add multiple filters using the fluent syntax.

Multiple Filters
 public MainPage()
{
    InitializeComponent();
 
    RapidRepository<Customer>.AddView<CustomerViewModel>(x => new CustomerViewModel { LastName = x.LastName, PostCode = x.Address.PostCode })
        .AddFilter(x => x.PostCode.StartsWith("SW"))
        .AddFilter(x => x.LastName.Contains("Mc"));
}
 

Synchronising The View (Used when upgrading)

If you are upgrading from V1.0 and already have saved entities that you will now be using a View Model for displaying data, you will need to synchronise the data in the database.

This can be done as a one-off during your upgrade script or even better, if you can afford the small overhead during application start-up do it then so it re-synchronises each time the user starts the app (it shouldn’t need to be done, this is only for the more pessimistic coder).

Synchronising the View
 public MainPage()
{
    InitializeComponent();
 
    RapidRepository<Customer>.AddView<CustomerViewModel>(x => new CustomerViewModel { LastName = x.LastName, PostCode = x.Address.PostCode })
        .AddFilter(x => x.PostCode.StartsWith("SW"));
 
    RapidRepository<Customer>.SynchroniseView<CustomerViewModel>();
}
 

Make sure you’ve registered the view mapping before calling synchronise.

Summary

Hopefully you agree that this is a really powerful addition to the repository and will greatly improve performance when querying the database.

I hope you find this useful.

Sean McAlinden.

Windows Phone 7 Database Rapid Repository V2.0 Creating and Saving Entities

SeanMcAlinden — Sun, 19 Dec 2010 00:14:00 GMT

Rapid Repository is a Windows Phone 7 Database and Silverlight Isolated Storage Database.

Download Rapid Repository from Microsoft Codeplex

Blog Tutorials

Release Overview
Creating and saving entities
Create, read, update and delete operations
Querying with views and filters
Caching
File Helper
Examining Operation Requests

Creating and saving entities to the Windows 7 Phone is really simple when using the Rapid Repository.

For the following examples, my entity is called Player which among it’s properties contains a list of entities called GameScore.

Player
 public class Player : IRapidEntity
{
    public Guid Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public List<GameScore> Scores { get; set; }
 
    public Player()
    {
        this.Scores = new List<GameScore>();
    }
}
 

GameScore
 public class GameScore
{
    public double Score { get; set; }
    public DateTime Date { get; set; } 
}
 

As you can see, the Player class is the root entity or root aggregate, you will notice that it implement the IRapidEntity interface.

This interface enforces the implementation of a Guid Id property.

Simple Example

The following example shows how to save an entity to the database.

There is no setup at all, the following code is all you need to save a valid entity.

Saving a Player instance

public void SavePlayer()

{

    Player newPlayer = new Player { FirstName = "Sean", LastName = "Mcalinden", Scores = new List<GameScore>() };

    newPlayer.Scores.Add(new GameScore { Score = 123, Date = DateTime.Now });

    RapidRepository<Player> repository = new RapidRepository<Player>();

    repository.Add(newPlayer);

    RapidContext.CurrentContext.SaveChanges();

}

As you can see, once the player is created, a repository is created, the player is passed to the Add method and finally SaveChanges() is called on the current context.

The newPlayer instance passed in will now have it’s Id property populated (Do not change this Id).

*Note*

The reason you call SaveChanges() is because when Add is called on the repository, it is just creating a request to save the entity, it is not actually saved until SaveChanges() is called.

Simple Example with Pre-Populated Id

Similar to the previous example, if for any reason you need to create your own Id rather than have the framework create it, you simple set the Id property before SaveChanges() is called on the context.

Save with pre-populated Id
 public void SavePlayerWithPrePopulatedId()
{
    Guid id = Guid.NewGuid();
    Player newPlayer = new Player { Id = id, FirstName = "Sean", LastName = "Mcalinden", Scores = new List<GameScore>() };
    newPlayer.Scores.Add(new GameScore { Score = 123, Date = DateTime.Now });
 
    RapidRepository<Player> repository = new RapidRepository<Player>();
    repository.Add(newPlayer);
    RapidContext.CurrentContext.SaveChanges();
}
 

Derived Repository

If you want to add extra functionality such as logging or you want to hide away the call to Savechanges() on the context, you can derive from RapidRepository<>, all the relevant methods can be overridden.

Player Repository
 public class PlayerRepository : RapidRepository<Player>
{
    public override Player Add(Player entity)
    {
        base.Add(entity);
        RapidContext.CurrentContext.SaveChanges();
        return entity;
    }
 
    public override Player Update(Player entity)
    {
        base.Update(entity);
        RapidContext.CurrentContext.SaveChanges();
        return entity;
    }
 
    public override void Delete(Player entity)
    {           
        base.Delete(entity);
        RapidContext.CurrentContext.SaveChanges();
    }
 
    public override void Delete(System.Guid id)
    {
        base.Delete(id);
        RapidContext.CurrentContext.SaveChanges();
 

Now the above SavePlayer() method looks like the following:

Save player
 public void SavePlayer()
{
    Player newPlayer = new Player { FirstName = "Sean", LastName = "Mcalinden", Scores = new List<GameScore>() };
    newPlayer.Scores.Add(new GameScore { Score = 123, Date = DateTime.Now });
 
    PlayerRepository repository = new PlayerRepository();
    repository.Add(newPlayer);
}
 

Summary

That’s about it for saving entities, the next post will cover all of the Create, Read, Update and Delete functionality.

I hope you find this useful.

Kind Regards,

Sean McAlinden.

Windows Phone 7 Database Rapid Repository V2.0 Released

SeanMcAlinden — Sun, 19 Dec 2010 00:13:00 GMT

Rapid Repository is a Windows Phone 7 Database and Silverlight Isolated Storage Database.

Rapid Repository requires no setup and the API has been designed to be easy to use and discoverable, you will be saving, updating, deleting and querying your complex entities within minutes.

There is no major learning curve, you will literally have a near full understanding of most of the repository within minutes of downloading and referencing the library.

The more advanced features such as querying with views and filters are still very easy to use and the tutorials provided will have you using them within minutes.

Download Rapid Repository from Microsoft Codeplex

Blog Tutorials

Release Overview
Creating and saving entities
Create, read, update and delete operations
Querying with views and filters
Caching
File Helper
Examining Operation Requests

I will be adding some samples and video tutorials soon.

V2.0 Features

This is a full list of features within Rapid Repository V2.0

Numerous methods for performing Create, Read, Update and Delete operations
- Add
- Update
- Delete
- Exists
- GetById
- GetAll
- Query
Views & Filters
- A view is a subset of an entity which can be implemented to greatly improve querying speed and performance
- Filters are Where Conditions placed on the view to further filter the data
Rapid Context
- The context is mainly used for performing any operations request by the repository
- It also allows access to all operation requests, this enables the examination and updating/deleting of any pending changes if required in more complex scenarios
Entity Cache
- Entities are cached locally by default for improved performance, there are methods available for eager loading the cache at application start up and also for turning off caching on a per entity basis
File Access Helper
- RapidRepository.File contains helper methods for storing file that are not entities such as an image byte array

Breaking Changes

RapidContext has moved from namespace RapidRepository.Context to the root namespace RapidRepository. This was done as the context should be a top level class.

A new OperationRequests property has been added to the RapidContext – this is now the way to access any pending requests.

Bug Fixes

There have been numerous improvements from V1.0, the main bug that has been fixed was a caching bug that sometimes caused the GetAll method to not load all entities.

Technical Details

The full source code and tests can be downloaded from or browsed on the Microsoft Codeplex site http://rapidrepository.codeplex.com/.

As an overview, the Rapid Repository is a document database which serialises and deserialises entities into Json and saves the json as text files within the Windows 7 Phone Isolated Storage.

Each saved entity has it’s own json file with a globally unique identifier (GUID) filename.

Views are stored slightly differently, instead of have a file per row, a view is stored in a single json file for the specific view type. An entity can have many different views.

Caching is turned on for each entity type by default, this can be turned off if required. The cache stores an in-memory representation of all entities used during the application session, this enables better performance when re-using the entities within an application session.

Summary

I’m really happy with the improvements in V2.0 and I especially think the Views and Filters feature will be really useful as it will greatly improve the speed of querying the data within the repository.

I hope you like it and would be really grateful for any feedback.

Kind Regards,

Sean McAlinden.

Windows 7 Phone Database Rapid Repository – V2.0 Beta Released

SeanMcAlinden — Tue, 07 Dec 2010 23:20:13 GMT

Hi All,

A V2.0 beta has been released for the Windows 7 Phone database Rapid Repository, this can be downloaded at the following: http://rapidrepository.codeplex.com/

Along with the new View feature which greatly enhances querying and performance, various bugs have been fixed including a more serious bug with the caching that caused the GetAll() method to sometimes return inconsistent results (I’m a little bit embarrased by this bug).

If you are currently using V1.0 in development, I would recommend swapping in the beta immediately.

A full release will be available very shortly, I just need a few more days of testing and some input from other users/testers.

*Breaking Changes*

The only real change is the RapidContext has moved under the main RapidRepository namespace.

Various internal methods have been actually made ‘internal’ and replaced with a more friendly API (I imagine not many users will notice this change).

Hope you like it

Kind Regards,

Sean McAlinden

Rapid Repository – Silverlight Development

SeanMcAlinden — Mon, 06 Dec 2010 21:11:03 GMT

Hi All,

One of the questions I was recently asked was whether the Rapid Repository would work for normal Silverlight development as well as for the Windows 7 Phone.

I can confirm that the current code in the trunk will definitely work for both the Windows 7 Phone and normal Silverlight development.

I haven’t tested V.1.0 for compatibility but V2.0 which will be released fairly soon will work absolutely fine.

Kind Regards,

Sean McAlinden.

Windows 7 Phone Database – Querying with Views and Filters

SeanMcAlinden — Sun, 05 Dec 2010 22:30:10 GMT

I’ve just added a feature to Rapid Repository to greatly improve how the Windows 7 Phone Database is queried for performance (This is in the trunk not in Release V1.0).

The main concept behind it is to create a View Model class which would have only the minimum data you need for a page.

This View Model is then stored and retrieved rather than the whole list of entities.

Another feature of the views is that they can be pre-filtered to even further improve performance when querying.

You can download the source from the Microsoft Codeplex site http://rapidrepository.codeplex.com/.

Setting up a view

Lets say you have an entity that stores lots of data about a game result for example:

GameScore entity
 public class GameScore : IRapidEntity
{
    public Guid Id { get; set; }
    public string GamerId {get;set;}
    public string Name { get; set; }
    public Double Score { get; set; }
    public Byte[] ThumbnailAvatar { get; set; }
    public DateTime DateAdded { get; set; }
}
 

On your page you want to display a list of scores but you only want to display the score and the date added, you create a View Model for displaying just those properties.

GameScoreView
 public class GameScoreView : IRapidView
{
    public Guid Id { get; set; }
    public Double Score { get; set; }
    public DateTime DateAdded { get; set; }
}
 

Now you have the view model, the first thing to do is set up the view at application start up.

This is done using the following syntax.

View Setup
 public MainPage()
{
    RapidRepository<GameScore>.AddView<GameScoreView>(x => new GameScoreView { DateAdded = x.DateAdded, Score = x.Score });
}
 

As you can see, using a little bit of lambda syntax, you put in the code for constructing a single view, this is used internally for mapping an entity to a view.

*Note* you do not need to map the Id property, this is done automatically, a view model id will always be the same as it’s corresponding entity.

Adding Filters

One of the cool features of the view is that you can add filters to limit the amount of data stored in the view, this will dramatically improve performance.

You can add multiple filters using the fluent syntax if required.

In this example, lets say that you will only ever show the scores for the last 10 days, you could add a filter like the following:

Add single filter
 public MainPage()
{
    RapidRepository<GameScore>.AddView<GameScoreView>(x => new GameScoreView { DateAdded = x.DateAdded, Score = x.Score })
        .AddFilter(x => x.DateAdded > DateTime.Now.AddDays(-10));
}
 

If you wanted to further limit the data, you could also say only scores above 100:

Add multiple filters
 public MainPage()
{
    RapidRepository<GameScore>.AddView<GameScoreView>(x => new GameScoreView { DateAdded = x.DateAdded, Score = x.Score })
        .AddFilter(x => x.DateAdded > DateTime.Now.AddDays(-10))
        .AddFilter(x => x.Score > 100);
}
 

Querying the view model

So the important part is how to query the data.

This is done using the repository, there is a method called Query which accepts the type of view as a generic parameter (you can have multiple View Model types per entity type)

You can either use the result of the query method directly or perform further querying on the result is required.

Querying the View
 public void DisplayScores()
{
    RapidRepository<GameScore> repository = new RapidRepository<GameScore>();
    List<GameScoreView> scores = repository.Query<GameScoreView>();
 
    // display logic
}
 

Further Filtering
 public void TodaysScores()
{
    RapidRepository<GameScore> repository = new RapidRepository<GameScore>();
    List<GameScoreView> todaysScores = repository.Query<GameScoreView>().Where(x => x.DateAdded > DateTime.Now.AddDays(-1)).ToList();
 
    // display logic
}
 

Retrieving the actual entity

Retrieving the actual entity can be done easily by using the GetById method on the repository.

Say for example you allow the user to click on a specific score to get further information, you can use the Id populated in the returned View Model GameScoreView and use it directly on the repository to retrieve the full entity.

Get Full Entity
 public void GetFullEntity(Guid gameScoreViewId)
{
    RapidRepository<GameScore> repository = new RapidRepository<GameScore>();
    GameScore fullEntity = repository.GetById(gameScoreViewId);
 
    // display logic
}
 

Synchronising The View

If you are upgrading from Rapid Repository V1.0 and are likely to have data in the repository already, you will need to perform a synchronisation to ensure the views and entities are fully in sync.

You can either do this as a one off during the application upgrade or if you are a little more cautious, you could run this at each application start up.

Synchronise the view
 public void MyUpgradeTasks()
{
    RapidRepository<GameScore>.SynchroniseView<GameScoreView>();
}
 

It’s worth noting that in normal operation, the view keeps itself in sync with the entities so this is only really required if you are upgrading from V1.0 to V2.0 when it gets released shortly.

Summary

I really hope you like this feature, it will be great for performance and I believe supports good practice by promoting the use of View Models for specific pages.

I’m hoping to produce a beta for this over the next few days, I just want to add some more tests and hopefully iron out any bugs.

I would really appreciate any thoughts on this feature and would really love to know of any bugs you find.

You can download the source from the following : http://rapidrepository.codeplex.com/

Kind Regards,

Sean McAlinden.

Windows 7 Phone – Loading from Isolated Storage

SeanMcAlinden — Thu, 18 Nov 2010 22:18:47 GMT

In my previous post (Saving to isolated storage) I demonstrated a simple example of saving a serialised json file to the Windows 7 Phone isolated storage, in this post I’m going to show a simple example of retrieving a file out of isolated storage simlar to my approach in the Windows 7 phone database Rapid Repository.

Here we go…

Load isolated storage file
 public class LoadFileFromIsolatedStorage
{
    private string myDirectory = "MyDirectory";
 
    public string LoadFile(string fileName)
    {
        try
        {
            using (var store = IsolatedStorageFile.GetUserStoreForApplication())
            {
                string filePath = string.Format("{0}.json", Path.Combine(myDirectory, fileName));
 
                using (IsolatedStorageFileStream fileStream = new IsolatedStorageFileStream(filePath, FileMode.Open, store))
                {
                    using (TextReader reader = new StreamReader(fileStream))
                    {
                        return reader.ReadLine();
                    }
                }
            }
        }
        catch (IsolatedStorageException exception)
        {
            throw exception;
        }
    }
}
 

As you can see, a store variable is set to the application user store and get the file path.

We then open a file stream and use a text reader to read the json file which is then returned as a string.

I hope this is useful, if you would like to see a more ‘real world’ example – you can view the source of the Rapid Repository FileManager class here.

Kind Regards,

Sean McAlinden.

Windows 7 Phone – Saving to Isolated Storage

SeanMcAlinden — Wed, 17 Nov 2010 14:07:36 GMT

I was recently asked how to save a serialised file to the Windows 7 phone isolated storage so I thought I’d post an example, similar to how I did this within my Windows 7 phone database Rapid Repository.

In this post, I’m going to show a simple example of:

Creating a directory
Building the file path
Saving the file

To see how to load a file from isolated storage, see the following post http://weblogs.asp.net/seanmcalinden/archive/2010/11/18/windows-7-phone-loading-from-isolated-storage.aspx.

This post assumes that you have a serialised json file to save that is passed into the Save method along with a file name.

Here we go…

Save to isolated storage
 public class SaveToIsolatedStorage
{
    private string myDirectory = "MyDirectory";
 
    public void Save(string fileName, string jsonFile)
    {
        try
        {
            using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication())
            {
                fileName = String.Format("{0}.json", fileName);
                string filePath = Path.Combine(myDirectory, fileName);
 
                if (!store.DirectoryExists(myDirectory))
                {
                    store.CreateDirectory(myDirectory);
                }
 
                using (IsolatedStorageFileStream fileStream = new IsolatedStorageFileStream(filePath, FileMode.Create, store))
                {
                    using (StreamWriter stream = new StreamWriter(fileStream))
                    {
                        stream.Write(jsonFile);
                    }
                }
            }
        }
        catch (IsolatedStorageException exception)
        {
            throw exception;
        }
    }
}
 

As you can see, we get the user store for the application, this is then used for all our interaction with the isolated storage file system.

Once we have the store, a directory called MyDirectory is created if it doesn’t already exist.

Once we’re happy the directory exists we open a file stream and then use a stream writer to write the json file to isolated storage.

I hope that this is useful, if you would like to see a more ‘real world’ example – you can view the source of the Rapid Repository FileManager class here.

Kind Regards,

Sean McAlinden.

Windows 7 Phone Database Rapid Repository Exclude Entities From Cache

SeanMcAlinden — Fri, 12 Nov 2010 20:25:00 GMT

Download the code and a fully working example application from http://rapidrepository.codeplex.com/

Tutorials

If you are writing a memory intensive windows 7 phone application and can’t afford any extra overhead, you can turn off the default caching within Rapid Repository on an Entity basis.

The best place to do this is at the start of your application - then all you need to do is add similar to the following code for each entity type you want to exclude:

Remove Cache Example

public MyApplicationStartup()
{
    EntityCache.NoCache<Customer>();
}

As you can see, in this example, a Customer entity is excluded from the cache.

Note: This does mean that each time you load an entity where the type is excluded from the cache, it will have the overhead of reading from the file system and deserialising,

Hope this is useful.

Sean McAlinden

Windows 7 Phone Database Rapid Repository – Examining Pending Changes

SeanMcAlinden — Wed, 10 Nov 2010 22:08:00 GMT

Download the code and a fully working example application from http://rapidrepository.codeplex.com/

Tutorials

A possible useful feature of the RapidRepository is the ability to examine, add and remove pending changes.

Basically, before you call SaveChanges() on the context, every action on the repository is held in the context as a pending change called an Operation Request.

The OperationRequest class holds all of the properties required for saving the entity.

OperationRequest
 using System;
using RapidRepository.DbC;
namespace RapidRepository.Context
{
    /// <summary>
    /// Stores data required for an operation.
    /// </summary>
    public class OperationRequest
    {
        #region Properties
 
        /// <summary>
        /// Gets or sets the entity id.
        /// </summary>
        /// <value>The entity id.</value>
        public Guid EntityId { get; private set; }
 
        /// <summary>
        /// Gets or sets the entity.
        /// </summary>
        /// <value>The entity.</value>
        public object Entity { get; private set; }
        
        /// <summary>
        /// Gets or sets the type of the entity.
        /// </summary>
        /// <value>The type of the entity.</value>
        public Type EntityType { get; private set; }
 
        /// <summary>
        /// Gets or sets the type of the operation.
        /// </summary>
        /// <value>The type of the operation.</value>
        public OperationRequestType OperationRequestType { get; private set; } 
 
        #endregion
 
        #region Constructor
 
        /// <summary>
        /// Initializes a new instance of the <see cref="OperationRequest"/> class.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <param name="entityType">Type of the entity.</param>
        /// <param name="operationRequestType">Type of the operation request.</param>
        public OperationRequest(object entity, Type entityType, OperationRequestType operationRequestType)
        {
            Contract.Requires("entity", entity != null);
            Contract.Requires("entityType", entityType != null);
 
            if (operationRequestType != Context.OperationRequestType.Add)
            {
                this.EntityId = ((IRapidEntity)entity).Id;
            }
 
            this.Entity = entity;
            this.EntityType = entityType;            
            this.OperationRequestType = operationRequestType;
        }
 
        /// <summary>
        /// Initializes a new instance of the <see cref="OperationRequest"/> class.
        /// </summary>
        /// <param name="entityId">The entity id.</param>
        /// <param name="entityType">Type of the entity.</param>
        /// <param name="operationRequestType">Type of the operation request.</param>
        public OperationRequest(Guid entityId, Type entityType, OperationRequestType operationRequestType)
        {
            Contract.Requires("entityId", entityId != Guid.Empty);
            Contract.Requires("entityType", entityType != null);
 
            this.EntityId = entityId;
            this.EntityType = entityType;
            this.OperationRequestType = operationRequestType;
        }
 
        #endregion
    }
}
 

Each operation request has an operation type, indicated using the following enumeration:

OperationRequestType
 namespace RapidRepository.Context
{
    /// <summary>
    /// The type of operation requested.
    /// </summary>
    public enum OperationRequestType
    {
        /// <summary>
        /// Specifies an Add operation.
        /// </summary>
        Add = 0,
 
        /// <summary>
        /// Specifies an Update operation.
        /// </summary>
        Update = 1,
 
        /// <summary>
        /// Specifies an Delete operation.
        /// </summary>
        Delete = 2
    }
}
 

The methods for adding and removing OperationRequests reside on the RapidContext class, they are:

Add Operation Request
 public void AddOperationRequest(OperationRequest operationRequest)
 

Remove Operation Request
 public void DeleteOperationRequest(OperationRequest operationRequest)
 

Delete All Operation Requests
 public void DeleteAllOperationRequests()
 

The collection of pending OperationRequests live within a collection: RapidContext.CurrentContext.operationRequests

Example

So, the following is an example of how this can be used.

In this example, at the end of a game the users score is persisted to the database by default so it is added to the repository:

Add User Score
 ScoreRepository scoreRepository = new ScoreRepository();
 
Score score = new Score();
score.Results.Add(new Result() { Score = 123, UserName = "Joe" });
 
scoreRepository.Add(score);
 

Now, before leaving the page and submitting the changes, you give the option of allowing the user to not save the score.

To be sure the score is not saved, you need to find it and remove it from the pending changes (OperationRequests).

Remove Add Operation Request
 OperationRequest addRequest = RapidContext.CurrentContext.operationRequests
    .Where(x => x.OperationRequestType == OperationRequestType.Add).First();
 
RapidContext.CurrentContext.DeleteOperationRequest(addRequest);
 

Ok, even though this example is a little simplistic and contrived, you can see that you have a fair amount of control over the context and you can dig deeper into the operations of the database if required.

You can download Release V1.0, the source code and an example phone app from the following http://rapidrepository.codeplex.com/

I hope this is useful.

Kind Regards,

Sean McAlinden.

Windows 7 Phone Database Rapid Repository – Queries and Views Proposal

SeanMcAlinden — Tue, 09 Nov 2010 22:01:35 GMT

Hi All,

I’m about to start working on the query side of the Rapid Repository as I think this will be the most important requirement for the next release (which I am hoping will come pretty soon).

My current plan is to do something fairly simple but I thought I’d publish the idea first in case any would prefer a different implementation.

Proposed implementation

Setup

Queries will be done against View Models.

A view model will be a simple class which implements an interface IRapidView (this will enforce that the entity id is captured within the view model class).

The view model will or should be a flattened subset of an entity, perfect for displaying on a page.

An example could be something like the following:

View Model Example
 public class CustomerView : IRapidView
    {
        public Guid Id { get; set; }
        public string FirstName { get; set; }
        public string PostCode { get; set; }
    }
 

To setup the view, at application start up there will be a method similar to the following:

Setting up a View at startup
 RapidRepository.AddView<Customer, CustomerView>(c =>
            {
                return new CustomerView { FirstName = c.FirstName };
            })
 

Also, I am proposing a filtering feature during setup where linq / lambda can be used to ensure the view filters out any unwanted data – it will look similar to the following:

Filtering the View
 RapidRepository.AddView<Customer, CustomerView>(c =>
            {
                return new CustomerView { FirstName = c.FirstName };
            })
            .Filter<CustomerView>(cv => cv.FirstName != "Sean" && cv.PostCode.Contains("SW1"));
 

Querying the View

Querying the View will be achieved through a method on the repository that will take the type of view as a generic parameter, this will return a (possibly cached) List<TViewType> that can be queried against using full Linq to Objects.

This will look similar to the following (lambda):

Querying the View
 Repository<Customer> customerRepository = new Repository<Customer>();
 
            List<CustomerView> results = customerRepository.Query<CustomerView>().Where(x => x.PostCode.Contains("SW1")).ToList();
 

or Linq

Querying the View with linq
 List<CustomerView> results = (from c in customerRepository.Query<CustomerView>()
                                         where c.PostCode.Contains("SW1")
                                         select c).ToList();
 

Why will this be any better than just loading all the entities?

There are a number of reasons why this would be better than getting all on an entity type (how the current release works).

The first being the fact that the view model will contain only the data required for the view, this immediately means less data in memory and less to de-serialise.

The other reasons will include how i intend to store, cache and load the View.

As a basic idea, I’m going to look at storing a view in one view file per type, and have that (optionally) load into the application cache on start up.

The view will then be synchronously managed in memory whilst asynchronously managed within isolated storage.

Conclusion

Anyway, as a really basic overview, that is my current plan, any thoughts, criticisms or ideas would be most welcome.

You can download the current release, source code and test windows 7 phone application from http://rapidrepository.codeplex.com/.

Kind Regards,

Sean McAlinden.