CCook's Blog

Creating a Bejeweled Blitz Bot in C#

CCook — Sun, 05 Sep 2010 19:43:12 GMT

One of the more addictive games out there is Bejeweled Blitz on Facebook. It's fun to play, but as a programmer one thing nags at you as you play. The thought 'I could program something that would do this much better.' I program mostly scientific codes and business applications. A bot application is quite different, and hence a great project. I'll cover the process of making a bot here; however, I will not give a direct download. If you want to run the bot you will have to compile your own application. Cheating isn't the goal here.

First, credit where it is due, Mike Vallotton posted on the same topic. Between this and his article assembling a bot should be straight forward. My additions are in locating the game window, using statistics to identify game pieces, and using a damper on game moves. He reports a score of 212K; I have reached 1.06M without much attention to the pattern recognition.

The approach is to create a bot that interfaces with the game in the same way a user would, through the mouse. Doing so involves three major steps, reading the game state from the screen, solving for a move, and finally making the move. Reading the game state from screenshots may be the trickiest of the three.

Locating the game window

Locating where the game window is on the screen was one of the more interesting problems to solve. While we could use some libraries to get the window location of a browser which contains the Bejeweled game, we would not know where within the window the game resides. Further, when needing to know where the game is to the pixel, the game location on the page is far too volatile with changing ads, content, etc.

To find the window I use a screenshot of the whole desktop and then find the game within this image. Doing a per-pixel match is absurdly expensive, so I use an idea I borrowed from multigrid solvers, yet much simpler. To find the window I first capture a screenshot and crop it down to the game I want to find, and save it to disk; In this case the title screen of the game. Then I take a screenshot of the desktop captured during the run and attempt to find the title screen within.

To find the title screen I first convert both images to grayscale by simply taking the red channel. With grayscale images we then have a two dimensional array to work with, speeding things up a bit. To speed things up further, both images are scaled down to 0.10 their original size (this is the idea of successive scales is borrowed from the multigrid solver). Then the title screen is subtracted from the array at various locations. After the subtraction the two dimensional array is summed to get a total sum value. The location where the sum has the least value is taken to be the location where the window is located.

For the first levels of locating we do not need to be exact; we are just looking for regions where the title screen is so that the next level will have a reduced area to search. For the first search I stepped across the screenshot by 2 pixels (20 pixels on the original image). This then locates the game title screen to +/- (2*10) pixels on the screen. Great, now we can resize to 0.25 and search a 10 by 10 region. This is repeated at 0.50 before searching the final full scale screenshot. I prefer to work in Matlab for such operations. This does require compiling the Matlab code and referencing it from the .NET application.

The C# code to get a screenshot and call the compiled Matlab function:

private void FindGameScreen()
{

					
    Rectangle r = new Rectangle(0, 0,
        Screen.PrimaryScreen.Bounds.Width,
        Screen.PrimaryScreen.Bounds.Height);

					
    Bitmap bmp = new Bitmap(r.Width, r.Height);

					
    using (Graphics g = Graphics.FromImage(bmp))
    {
        g.CopyFromScreen(
            new Point(0, 0),
            new Point(0, 0),
            r.Size);
    }

					
    int[,] bmpmat = new int[r.Height, r.Width];
    for (int i = 0; i < r.Width; i++)
        for (int j = 0; j < r.Height; j++)
        {
            Color pixelColor = bmp.GetPixel(i, j);
            bmpmat[j, i] = pixelColor.R;
        }

					

					
    var bmpinp = (MWNumericArray)bmpmat;
    var fileinp = (MWCharArray)@"gametitle.bmp";
    MWArray test = (MWNumericArray)findWindow.findwindow(bmpinp, fileinp);

					
    double[,] data = (double[,])test.ToArray();
    double x = data[0, 0];
    double y = data[0, 1];
    gamex = Convert.ToInt32(x);
    gamey = Convert.ToInt32(y);
}

The Matlab code which performs the described method:

% Uses rescaling to find successive approximate locations of the window,

% finally finding the location to the pixel.

function [data]= findwindow(fullscreen, game_filename)

gametitle = imread(game_filename);

fullscreen = uint8(fullscreen);

gametitle = gametitle(:,:,1);

fullscreen2 = imresize(fullscreen,.1);

gametitle2 = imresize(gametitle,.1);

[x,y] = findwindow2(fullscreen2,gametitle2,1,1,0,0,2);

x = x*10;

y = y*10;

fullscreen2 = imresize(fullscreen,.25);

gametitle2 = imresize(gametitle,.25);

x = x*.25-6*3;

y = y*.25-6*3;

xn = x+2*6*3;

yn = y+2*6*3;

if (x<1)

x=1;

end

if (y<1)

y=1;

end

[x,y] = findwindow2(fullscreen2,gametitle2,x,y,xn,yn,3);

x = x*4;

y = y*4;

if (x<1)

x=1;

end

if (y<1)

y=1;

end

fullscreen2 = imresize(fullscreen,.5);

gametitle2 = imresize(gametitle,.5);

x = x*.5-3*3

y = y*.5-3*3

xn = x+2*3*3;

yn = y+2*3*3;

[x,y] = findwindow2(fullscreen2,gametitle2,x,y,xn,yn,3);

x = x*2;

y=y*2;

if (x<1)

x=1;

end

if (y<1)

y=1;

end

x = x-2*3

y = y-2*3

xn = x+2*2*3;

yn = y+2*2*3;

[x,y] = findwindow2(fullscreen,gametitle,x,y,xn,yn,1);

data = [x,y]

end

function [x,y] = findwindow2(fullscreen,gametitle,x0,y0,xn,yn,stepsize)

xmin=0;

ymin=0;

testmin = inf;

[gheight, gwidth] = size(gametitle);

[fheight, fwidth] = size(fullscreen)

if (xn == 0)

xn=fwidth-gwidth-stepsize

end

if (yn == 0)

yn = fheight-gheight-stepsize

end

for(x=x0:stepsize:xn)

for(y=y0:stepsize:yn)

test = error_fun([x,y]);

if (test < testmin)

xmin = x;

ymin = y;

testmin = test;

end

x=xmin;

y=ymin;

function f = error_fun(x)

f= test_sub(x(1),x(2),fullscreen,gametitle);

end

function fit = test_sub(x, y, full, game)

x = round(x);

y = round(y);

[height, width] = size(game);

sub = full(y:y+height-1,x:x+width-1);

sub = sub-game;

fit = sum(sum(sub,1));

end

Recognizing pieces

To get the game state from the screenshots I chose to avoid OCR methods and just go with a statistical approach. The idea was that the histogram for a piece will be unique from the other colors. For example, the mean red value for red would be different than that of the other pieces. To get the reference statistics from the game I used AForge.NET. The Framework comes with a nice application to work with images and a library to reference from the bot.

The first step is to collect statistics for all the game pieces. To do this, get a screenshot of all of them, and then crop down to just the game pieces. Each piece has some shape surrounded by the background board. To improve the statistics I chose to grab a 20 by 20 pixel box centered on the piece location. That is to say, crop down the 40 by 40 location to just the inner 20 by 20 and what remains is the core of a game piece.

The statistics I collected using AForge .NET.

Piece	Red Mean	Green Mean	Blue Mean
white	218.79	218.79	218.79
purple	176.7325	38.1	177.2425
blue	16.975	109.5675	204.7625
green	43.06	214.2775	75.365
yellow	227.01	197.165	28
orange	238.49	143.535	55.7425
red	242.855	31.28	62.07

Great, we now have readily available statistics to match a game piece too. Further, the statistics are calculated by the same library so matching should be good.

Matching a piece to the statistics is straightforward using a Root Sum Square error approach. For a statistic at a location we calculate the error to each piece and take the one with the smallest error. The code would look something like:

double bestScore = 255;
double curScore = 0;
foreach (KeyValuePair<Color, List<double>> item in statReference)
{
    curScore = Math.Pow(item.Value[0] / 255 - stats.Red.Mean / 255, 2)
        + Math.Pow(item.Value[1] / 255 - stats.Green.Mean / 255, 2)
        + Math.Pow(item.Value[2] / 255 - stats.Blue.Mean / 255, 2);
    if (curScore < bestScore)
    {
        PieceColor = item.Key;
        if (item.Key == Color.YellowGreen)
            PieceColor = Color.Yellow;
        if (item.Key == Color.MediumPurple)
            PieceColor = Color.Purple;
        bestScore = curScore;
    }
}

In this implementation a score, or error, is calculated by differencing the mean color values from an 'ideal' value and them performing the RSS on that value. The score with the smallest error indicates the piece which has the closest match. With pieces 20 by 20 and a cheap RSS being used, this method parses the game state very fast and accurately. Note that it is important to crop down to the 'core' of the game piece as the background board tends to smooth out the statistics, especially between yellow and orange.

Finding the statistics for the pieces can be done like so, where game is the current screenshot cropped to the game and gGamePieces is an array of initialized Graphics objects.

for (int i = 0; i < 8; i++)
    for (int j = 0; j < 8; j++)
    {
        gGamePieces[i, j].DrawImage(
            game,
            new Rectangle(
                new Point(0, 0),
                new Size(20, 20)),
            new Rectangle(
                new Point(gameStartX + (i * 40) + 10,
                    gameStartY + (j * 40) + 10),
                new Size(20, 20)),
            GraphicsUnit.Pixel);
        ImageStatistics stats = new ImageStatistics
            (bmpGamePieces[i, j]);

					
        ImageStatisticsYCbCr stats2 = new ImageStatisticsYCbCr(
            bmpGamePieces[i, j]);

					
        pGame[i, j].Parse(stats, stats2);
    }

I chose to store the piece reference statistics in a dictionary and initialize as follows:

private void BuildReference()
{
    //RedMeanB    GreenMeanB    BlueMeanB
    statReference = new Dictionary<Color, List<double>>();
    statReference.Add(Color.White,
        new List<double> { 218.79, 218.79, 218.79 });
    statReference.Add(Color.Purple,
        new List<double> { 176.7325, 38.1, 177.2425 });
    statReference.Add(Color.Blue,
        new List<double> { 16.975, 109.5675, 204.7625 });
    statReference.Add(Color.Green,
        new List<double> { 43.06, 214.2775, 75.365 });
    statReference.Add(Color.Yellow,
        new List<double> { 227.01, 197.165, 28 });
    statReference.Add(Color.Orange,
        new List<double> { 238.49, 143.535, 55.7425 });
    statReference.Add(Color.Red,
        new List<double> { 242.855, 31.28, 62.07 });
}

We now have a way to locate the game window and identify the game pieces on the board. We have our game state, great.

Determining a move

For this I did not do anything fancy. With our known game state I simply search the board for any locations where swapping two pieces resulted in a three piece chain. I didn't bother to add any checks for larger combos as I did not see this as accomplishing anything other than improving a score.

There was an additional component to determining the moves. After doing a simple implementation I noticed an interesting dynamic feedback on the game. The bot would move fast enough to try and create combos where they did not exist. For example, it would swap a piece and while it was moving notice that if it also moved another piece a combo would be created while the pieces moved. The game does not allow you to move two pieces to create a combo, so this just resulted in a bunch of spinning pieces that oscillated back and forth. I chose to damp the board to prevent this.

To do this, I used an eight by eight double array to keep track of a delay. Any time a move was performed I added 550 to that location and 275 to locations around it. The values are delay values in milliseconds. This way the bot will not move pieces away from an action in that area. Every tick of the engine would subtract the elapsed time from the entire array. Game moves are only made to locations where the delay value is zero (negative values are kept to zero). This allows us to simply call all possible moves without destroying previous moves. Note that for each tick I send moves for every possible match on the board. I don't perform a move and exit the loop; I send them all without a Sleep. The game does remarkably well at handling this.

Running the bot is similar to a game loop. I just created a timer which ticked at 50 milliseconds and stopped after 63 seconds (typically three seconds from the game pausing for specials).

Making the move

Making the move involves an Interop call to user32. Here I refer you to Mike Vallotton's post. One 'gotcha' here, if you are running on x64 you need to change the offsets in the class or nothing will happen. Also, I suggest putting in a Thread.Sleep while you test; the last thing you want is your mouse moving out of control with a bug, clicking around your Facebook page at 20 Hz.

[StructLayout(LayoutKind.Explicit)]
private struct INPUT
{
    [FieldOffset(0)]
    public int type;
    [FieldOffset(8)]
    public MOUSEINPUT mi;
    [FieldOffset(8)]
    public KEYBDINPUT ki;
    [FieldOffset(8)]
    public HARDWAREINPUT hi;
}

Of course you will need to figure out the pixel offsets for the game board within the game and how to calculate piece locations as well. Something like the following where the gameStart values are found by using an image editor (the game seems to change every once in a while as they update) and the game locations come from the title screen locating.

var x1 = i1 * 40 + gameStartX + gameX + 20;
var y1 = j1 * 40 + gameStartY + gameY + 20;
var x2 = i2 * 40 + gameStartX + gameX + 20;
var y2 = j2 * 40 + gameStartY + gameY + 20;
                
SendInputClass.Click(x1, y1);

					
SendInputClass.Click(x2, y2);

Good luck, and have fun.

Undo Within Selected

CCook — Sun, 07 Jun 2009 16:53:05 GMT

Today I was working on some code, nothing particularly different than any other day. I did something I have done thousands of times before, made some changes, and then needed to get previous code back. This was quickly done with undo several times, copy to clip board, redo several more and then paste. Then it hit me, why don't we have an undo within selected text? We have a search and replace within selection. Undo within selection complements the search and replace really well, and further, allows for quicker retrieval of code several edits ago. Particularly when the change was a single iteration ago in a particular location… In a sense spatial undo versus temporal undo.

Hopefully this will make it into Visual Studio some day, either as a power tool or third party plug-in.

ASP NET MVC Version 1 Released

CCook — Wed, 18 Mar 2009 13:21:52 GMT

Version 1 of ASP.NET MVC has been released, presumably for MIX in Vegas. It's been a year following the project, and it's exciting to see MVC released after three years of development since March 16^th 2007.

http://www.microsoft.com/downloads/details.aspx?FamilyID=53289097-73ce-43bf-b6a6-35e00103cb4b&displaylang=en

Overview

ASP.NET MVC 1.0 provides a new Model-View-Controller (MVC) framework on top of the existing ASP.NET 3.5 runtime. This means that developers can take advantage of the MVC design patterns to create their Web Applications which includes the ability to achieve and maintain a clear separation of concerns (the UI or view from the business and application logic and backend data), as well as facilitate test driven development (TDD). The ASP.NET MVC framework defines a specific pattern to the Web Application folder structure and provides a controller base-class to handle and process requests for "actions". Developers can take advantage of the specific Visual Studio 2008 MVC templates within this release to create their Web applications, which includes the ability to select a specific Unit Test structure to accompany their Web Application development.

The MVC framework is fully extensible at all points, allowing developers to create sophisticated structures that meet their needs, including for example Dependency Injection (DI) techniques, new view rendering engines or specialized controllers.

As the ASP.NET MVC framework is built on ASP.NET 3.5, developers can take advantage of many existing ASP.NET 3.5 features, such as localization, authorization, Profile etc.n

SmartPen by LiveScribe

CCook — Sat, 14 Feb 2009 02:54:40 GMT

Few gadgets actually change my life. I have used PDAs in the past, but they were eventually neglected and never replaced. I have owned a Tablet PC, which ended up being used just like a laptop; so much so, I replaced it with a laptop later. I finally bought an iPod just this year, but it too it seems is going to be neglected and unused. The SmartPen by LiveScribe is different.

The SmartPen is aptly named, for it can be used just like a pen with additional features. The features are quite extensive, from the expected digitizing of written material to on paper translation and piano keyboards. While the later features are more for show, there are several features which have completely changed how I do things at work and school.

Audio Recording: The audio is recorded and 'linked' to the written material. At a latter point the audio linked to the writing can be played by 'double clicking' the content. Great for reviewing meetings and class notes.
Computer Synchronization: The content of the pen synchronizes with the computer by USB with a handy magnetically assisted cradle. The benefit is that the application can search your writing for phrases rather accurately. This is invaluable when doing open note assignments and tests. Some other benefits with the program are the ability to export pages as images and share the notes online through their hosted services.
Math: The pen does an excellent job at recording notes containing math. This is an area where the tablet PC seriously struggled.

There are a few nuances as is the case with perhaps every gadget.

Ink: I go through an ink cartridge every two and half weeks by just taking notes in courses (15 hours). The ink is not terribly expensive however.
Printing Custom Sheets: The program crashes when printing your own 'special' paper. To work around this I had to manually grab the PostScript files from the app and use an open source PostScript printing application. This problem was repeatable across other machines.
Deleting Pages: This was a surprise… You can't delete pages. You can delete a whole notebook though… So be careful what you write (Or what others write when testing it thinking they are funny… thanks Sean).
Exporting Content: There are two ways to share notes. One is to 'copy' the page as an image, but of course the audio is lost. The notes with the audio can be published, but only through the LiveScribe service. I would like to host the notes myself.

While using the pen, a few ideas have sprung to mind which I would really like to see in the next revision.

Dot Matrix Overlay: It would be great to be able to print documents through a LiveScribe service that simultaneously overlaid the print request with the dot matrix, and imported the template into the application. This way the pen could be used in drafting say reports. It should be technically feasible as PrimoPDF demonstrates.

Unifico Load Tested with and without WCF Remoting

CCook — Sun, 11 Jan 2009 06:32:37 GMT

This is rather exciting to me; I just ran a few load tests on Unifico with and without remoting the services with WCF bindings. I knew the application could remote. The concern was how efficient. I created a quick web test that simply goes through the admin, lists the admin lists, performs a filter, edits and saves an item, then logs out. Roughly every action was hit (eh, it's a spike :)). I then setup the bindings and ran a load test remotely and locally (remotely being hosted on 127.0.0.1).

I like to call the operating point at about 75% cpu. This placed the local run at 282 req/s and the remote run at 214 req/s for a 75% efficiency in serializing all the service requests through WCF. It's a crude test, but a promising one at that! (Normally isolated servers are used, and a bunch of effort goes into the scenarios and analysis). The results are listed below, and the code is up on codeplex.

Local Run

Key Indicators


Counter	Instance	Category	Computer	Color	Range	Min	Max	Avg
User Load	_Total	LoadTest:Scenario	XPS720		1,000	10	630	315
Requests/Sec	_Total	LoadTest:Request	XPS720		1,000	0	411	231
Avg. Response Time	_Total	LoadTest:Request	XPS720		10	0.0053	1.07	0.18
Errors/Sec	_Total	LoadTest:Errors	XPS720		0	0	0	0
Threshold Violations/Sec	_Total	LoadTest:Errors	XPS720		1	0	0.20	0.070

Controller and Agents


Counter	Instance	Category	Computer	Color	Range	Min	Max	Avg
% Processor Time	_Total	Processor	XPS720		100	4.85	99.9	63.8
Available MBytes	-	Memory	XPS720		1,000	829	908	863

Remote Run

Key Indicators


Counter	Instance	Category	Computer	Color	Range	Min	Max	Avg
User Load	_Total	LoadTest:Scenario	XPS720		1,000	10	410	210
Requests/Sec	_Total	LoadTest:Request	XPS720		1,000	8.00	286	164
Avg. Response Time	_Total	LoadTest:Request	XPS720		1	0.0086	0.38	0.094
Errors/Sec	_Total	LoadTest:Errors	XPS720		0	0	0	0
Threshold Violations/Sec	_Total	LoadTest:Errors	XPS720		1	0	0.20	0.058

Controller and Agents


Counter	Instance	Category	Computer	Color	Range	Min	Max	Avg
% Processor Time	_Total	Processor	XPS720		100	5.65	98.1	59.2
Available MBytes	-	Memory	XPS720		10,000	936	1,036	988

Using a Recursive Expression to Create an Html Menu

CCook — Fri, 09 Jan 2009 00:40:15 GMT

I find recursive expression to be really useful. They are particularly handy when dealing with parent child relationships. As a demonstration, see a potential method for generating a site map below:

    1 using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    4 using System.Text;
    5 
    6 namespace SiteMapDemo
    7 {
    8     class MenuItem
    9     {
   10         public Guid ID { get; set; }
   11         public Guid? ParentID { get; set; }
   12         public string Name { get; set; }
   13         public string Path { get; set; }
   14         public int Rank { get; set; }
   15     }
   16     class Program
   17     {
   18         static void Main(string[] args)
   19         {
   20             List<MenuItem> menu = new List<MenuItem>(new[]{
   21                 new MenuItem{ID = Guid.NewGuid(), Name = "First", ParentID=null, Path="/", Rank=0},
   22                 new MenuItem{ID = Guid.NewGuid(), Name = "Second", ParentID=null, Path="/second.aspx",Rank=1},
   23             });
   24             menu.AddRange(new[] { 
   25                 new MenuItem{ID = Guid.NewGuid(), Name = "FirstSub", ParentID=menu[0].ID, Path="/firstsub.aspx",Rank=0},
   26                 new MenuItem{ID = Guid.NewGuid(), Name = "SecondSub", ParentID=menu[0].ID, Path="/secondsub.aspx",Rank=1},
   27                 });
   28             Func<List<MenuItem>, Guid?, string> renderMenu = null;
   29             renderMenu = (menus, Parent) =>
   30             {
   31                 var sub = menus.Where(m => m.ParentID == Parent).OrderBy(s => s.Rank).ToList();
   32                 if (sub.Count > 0)
   33                 {
   34                     StringBuilder sb = new StringBuilder();
   35                     sub.ForEach(s => { sb.Append(String.Format("<li><a href=\"{0}\">{1}</a>{2}</li>", s.Path, s.Name, renderMenu(menus, s.ID))); });
   36                     return sb.ToString();
   37                 }
   38                 return "";
   39             };
   40             Console.Write(renderMenu(menu, null));
   41             Console.ReadLine();
   42         }
   43     }
   44 }

The output:

<li><a href="http://www.charlesrcook.com/">First</a></li><li><a href="http://www.charlesrcook.com/firstsub.aspx">FirstSub</a></li><li><a href="/secondsub.aspx">SecondSub</a></li><li><a href="http://www.charlesrcook.com/second.aspx">Second</a></li>

Paging with Filters and Sorts added to Unifico

CCook — Sun, 04 Jan 2009 23:25:58 GMT

Two new additions were added to Unifico: filtering on fields and sorting on fields with the help of Html Extension methods.

A PagingSet class was defined to contain configuration options for the paging. In this way a View can still page on more than one list and maintain complete control over the Html rendered. Every string used in the Html Helpers is pulled from the configuration (A default is made available).

Several extension methods were added to the Html Helper to make rendering the controls easier.

The filtering html form can be rendered with <%= Html.FilterInput(Paging, "Go") %> Where "go" is the button text.

A sortable column header can be rendered with <%= Html.PageSorting(Paging, "Email","E-Mail")%>

Where the paging configuration has been passed from the controller, leaving the paging control completely in the hands of the controller:

<% PageResponse<User> Users = (PageResponse<User>)ViewData.Model;

PagingSet Paging = (PagingSet)ViewData["PagingSet"];

View the complete "View" here, http://www.codeplex.com/unifico/SourceControl/changeset/view/1798#54414

View the complete Controller here, http://www.codeplex.com/unifico/SourceControl/changeset/view/1798#44699

The end result of all this is paging that executes through the PageRequest class, so that no changes are required of the Service and paging that executes in SQL. It also has the nice benefit of residing completely in the QueryString and not requiring changes to the Controller's Action's parameters.

An example path created from paging with sorting and filtering: /Admin/Account/Users?expr=asdf9&filterby=All&orderby=Name&asc=False&page=1

And the SQL it generates.

exec sp_executesql N'SELECT TOP (10) [t0].[UserID] AS [ID], [t0].[Name], [t0].[Password], [t0].[Email]
FROM [dbo].[User] AS [t0]
WHERE ([t0].[Name] = @p0) OR ([t0].[Name] = @p1)
ORDER BY [t0].[Name] DESC',N'@p0 nvarchar(5),@p1 nvarchar(5)',@p0=N'asdf9',@p1=N'asdf9'

Unifico’s Account Component Gets an Admin

CCook — Sun, 04 Jan 2009 03:45:07 GMT

The Account Component in the Unifico Framework which is serving as a sample component now has an admin. Two supporting developments for the admin are also up: the paging HtmlHelper and overridable embedded views. Allowing for the embedded views to be overridden by placing new views in App.Web greatly eases development and should help in Component maintenance and versioning (new views can be made without rebuilding the component). I am also rather happy with the eas to which views are made overridable.

The paging turned out quite well, a few changes to the PageResponse<T> to implement IPageable made things fit really nicely. For example if PageResponse<User> is passed to the view from the controller, the paging can be generated with default settings in the snippet below. I also made use of my QueryString extension methods to make it work with populated QueryStrings (and have support for many pagers).

<%= Html.PageListing(Users) %>

http://www.codeplex.com/unifico

Allowing for Dynamic Embedded View Substitution with MVC

CCook — Sat, 03 Jan 2009 03:18:45 GMT

A while back I found an interesting post on embedding resources in MVC at "The Glass is Too Big" (http://www.wynia.org/wordpress/2008/12/05/aspnet-mvc-plugins/). Following the method was straightforward and allowed views to be embedded within a Component Class Library. Well, two extra items would be nice. It would be nice to not have to write that large plug-in path, and if a view was defined in the views folder it would be returned in lieu of the embedded view.

Adding this support required two modifications. First the AssemblyResourceProvider was modified to check for the view's existence by adding a Regex pattern match and checking for the file. If the file is found within the view folder, the file is returned, if not the embedded resource will return.

58 // Check to see if a file has been added to the views folder. If so, return that view.

59 Match m = Regex.Match(path, @"~/Plugin/[\w\.]+.dll/([\w\.]+).Views.([\w\.]+).aspx");

60 if (m.Success)

61 {

62 string assemblyMatch = m.Groups[1].Value;

63 string viewPath = m.Groups[2].Value;

64 string physicalPath = HttpContext.Current.Server.MapPath(String.Format("~/Views/{0}/{1}.aspx",

65 assemblyMatch, viewPath.Replace(".", "/")));

66 if (File.Exists(physicalPath))

67 return File.Open(physicalPath,FileMode.Open);

68 }

http://www.codeplex.com/unifico/SourceControl/changeset/view/1491#9855

To avoid having to write out the plug-in strings I wrote an extension method to write it and return the ViewResult. Reflection is used to gather the assembly name.

9 public static class ControllerPluginPathExtender

10 {

11 public static ViewResult PluginView(this Controller controller)

12 {

13 string controllerName = controller.RouteData.GetRequiredString("controller");

14 string viewName = controller.RouteData.GetRequiredString("action");

15 string assemblyName = controller.GetType().Assembly.FullName.Split(',')[0];

16 string pluginPath = String.Format(

17 @"~/Plugin/{0}.dll/{0}.Views.{1}.{2}.aspx",

18 assemblyName,controllerName,viewName

19 );

20 return new ViewResult{

21 ViewName = pluginPath

22 };

23 }

24 }

http://www.codeplex.com/unifico/SourceControl/changeset/view/1491#52892

Now using the embedded option is less tedious, for example:

34 [Authorize(Roles="Admin")]

35 public ActionResult Index()

36 {

37 ViewData["Title"] = "Account Admin Home";

38 ViewData["Message"] = "Welcome to the account admin";

40 return this.PluginView();

41 //return View("~/Plugin/App.Account.dll/App.Account.Views.Admin.Index.aspx");

42 }

It would be nice to not have to use 'this', but I can't see a way around it without rebuilding MVC, not something I want to start doing. Also some caching and less reflection might be nice.

Update: The VewData and TempData have to be added to pass the models to the view

   11         public static ViewResult PluginView(this Controller controller)
   12         {
   13             string controllerName = controller.RouteData.GetRequiredString("controller");
   14             string viewName = controller.RouteData.GetRequiredString("action");
   15             string assemblyName = controller.GetType().Assembly.FullName.Split(',')[0];
   16             string pluginPath = String.Format(
   17                     @"~/Plugin/{0}.dll/{0}.Views.{1}.{2}.aspx",
   18                     assemblyName,controllerName,viewName
   19                     );
   20             return new ViewResult{
   21                 ViewName = pluginPath,
   22                 ViewData = controller.ViewData,
   23                 TempData = controller.TempData
   24             };
   25         }

Paging Helpers in Unifico, Filtered and Sorted Paging

CCook — Thu, 01 Jan 2009 01:59:16 GMT

Unifico has a few paging helpers to make service methods easily paged from a client. Essentially the framework makes consuming a page request object as simple as calling .ToList() on an IQueryable source. The object, the PageRequest, has two collections, Filters and Sorts with several constructors to make instantiation easy. The collections are rather straight forward, providing filtering and sorting ability on a paging source. The uniqueness comes from the ability to request multiple filters and sorts together, along with a paging request. This request is then execute on the IQueryable source, so if DLINQ is used, results in exactly two database hits. A COUNT statement is executed to find out how many pages there are, and a single select statement providing the paged results. This is all done without exposing LINQ or IQueryable to the service's client.

Making an existing source page-able is rather simple, compare the two implementations.

Without paging implemented:

44 public List<App.Account.Models.Role> GetRoles()

45 {

46 return accountRepository.GetRoles().ToList();

47 }

With paging implemented:

43 public PageResponse<App.Account.Models.Role> GetRolePage(PageRequest PageRequest)

44 {

45 return accountRepository.GetRoles().ToPageResponse(PageRequest);

46 }

Utilizing the paging is almost painfully easy.

Grabbing the first page at a size of ten:

120 PageResponse<Role> rolePage = accountService.GetRolePage(new PageRequest(0, 10));

Or grabbing the first page sorting by the role's name (ascending):

120 PageResponse<Role> rolePage = accountService.GetRolePage(new PageRequest(0, 10, "Name", "string", true));

Or fully defining the page request:

120 accountService.GetRolePage(new PageRequest

121 {

122 Index = 2,

123 PageSize = 10,

124 Filters = new ContractList<Filter>(

125 new[]{new Filter { BinaryExpression=FilterBinaryExpression.Equal, Parameter="Name", TypeName="String",Value="Admin"},

126 new Filter { BinaryExpression=FilterBinaryExpression.GreaterThan, Parameter="Level", TypeName="Int32", Value=1}}),

127 Sorts = new ContractList<Sort>(

128 new[] { new Sort { Ascending = true, TypeName = "Int32", Parameter = "Level" } })

129 });

130 /* Executes

131 SELECT [t1].[RoleID] AS [ID], [t1].[Name], [t1].[Level] AS [Level]

132 FROM (

133 SELECT ROW_NUMBER() OVER (ORDER BY [t0].[Level]) AS [ROW_NUMBER], [t0].[RoleID], [t0].[Name], [t0].[Level]

134 FROM [dbo].[Role] AS [t0]

135 WHERE ([t0].[Level] > 1) AND ([t0].[Name] = 'Admin')

136 ) AS [t1]

137 WHERE [t1].[ROW_NUMBER] BETWEEN 20 + 1 AND 20 + 10

138 ORDER BY [t1].[ROW_NUMBER]

139 */

I'm sure you have notice the TypeName properties and wondered why they are there. They enable the helper's methods to work with the expression tree before the query has been executed. Notice that the paging occurs in SQL against the table names and columns, not against the models. While the syntax is nowhere near that of LINQ, it seals of the service and keeps the paging responsibility within the service without requiring the service to handle specific paging requests. A similar method can be used to search multiple sources, and will be added shortly. Ohh, and it works across WCF.

CCook's Blog

Creating a Bejeweled Blitz Bot in C#

Locating the game window

Recognizing pieces

Determining a move

Making the move

Undo Within Selected

ASP NET MVC Version 1 Released

SmartPen by LiveScribe

Unifico Load Tested with and without WCF Remoting

Local Run

Remote Run

Using a Recursive Expression to Create an Html Menu

Paging with Filters and Sorts added to Unifico

Unifico’s Account Component Gets an Admin

Allowing for Dynamic Embedded View Substitution with MVC

Paging Helpers in Unifico, Filtered and Sorted Paging

The Unifico Framework