Brian Mains

Location Formats in ASP.NET MVC

2009-11-17T01:49:00Z

ASP.NET MVC is a wonderful thing. One of the many great features is the ability to customize all of the .NET framework's code by swapping out one implementation and using another. One such instance is creating a custom view engine, which you can do as illustrated in this example: http://www.singingeels.com/Articles/Creating_a_Custom_View_Engine_in_ASPNET_MVC.aspx. The point of my article is not to illustrate how this can be done, but about how to customize it for your needs. By default, the web forms view engine looks for views in the folder of the controller or the shared folder. So if you try to trigger an action method "Index" within the controller of type CustomerController, a partial view (.ascx) or the view (.aspx) is sought for in the ~/Shared folder or ~/Customer folder.

Now, I tend to like to use partial views in order to separate and reuse functionality a lot. So I tend to have a lot of partial views that tend to get reused across pages and I don't want everything to be in the shared folder (by default, partial views have to be in the shared folder or in the same folder as the controller). So I added some code to the view engine that allowed me to create subfolders within the shared folder and for the view engine to look for the classes there. Imagine this folder structure:

Shared
    Customers
    Orders
    Products

So the shared folder breaks up my partial views into the folder above.

Thinking long-term, rather than hard-coding all these folder references and assigning them to the ViewLocationFormats and PartialViewLocationFormats properties, I wanted something that I wouldn't have to worry about changing later. So in true ASP.NET MVC framework form, I created some extra code to create the ability to automatically add references to subfolders too. In order to do this, it's required to use the VirtualPathProvider class to extract the URL, as in the following code:

public MyViewEngine() {
var locations = new List<string>
{
    "~/Views/{1}/{0}.aspx",
    "~/Views/{1}/{0}.ascx",
    "~/Views/Shared/{0}.aspx",
    "~/Views/Shared/{0}.ascx"
};

var dir = this.VirtualPathProvider.GetDirectory("~/Views/Shared");
var subs = dir.Directories.OfType<VirtualDirectory>();

foreach (var sub in subs)
{
    locations.Add("~" + sub.VirtualPath.Substring(sub.VirtualPath.IndexOf("/", 2)) + "{0}.ascx");
}

base.ViewLocationFormats = locations.ToArray();
base.PartialViewLocationFormats = base.ViewLocationFormats;
}

This is the constructor for the custom view engine. It contains some additional code to use the VirtualPathProvider property (a property of our custom view engine) to extract the subdirectories of the shared folder. You see the four hard-coded references at the beginning, and so we need to create virtual path strings (which start with "~" and work from the beginning of the virtual directory) to add to the custom list. When working with folders using VirtualPathProvider, the issue becomes the way paths are referenced. By default, the path may be:

/MyVirtualFolder/Views/Shared/Customers/

When you need:

~/Views/Shared/Customers/

And so some additional work to format the path is needed (the substring strips off the virtual directory folder. Now we have a component that will allow the MVC framework to look for partial views in all subdirectories in the shared folder.

Telerik's Compressing and Combining Scripts in MVC

2009-11-11T02:50:00Z

The latest Telerik MVC set of components features a ScriptRegistrar component that's responsible for compressing or combining scripts into a single file. This compression utility is very easy to implement: to setup this component, use the following steps:

1. In your configuration file, add the following line to the httpHandlers element in <system.web> and <system.webserver>:

2. Use the ScriptRegistrar and groups to group scripts together. Preferrably, put this in the master page at the very end of the page before the ending </body> tag.

<% Html.Telerik().ScriptRegistrar().Scripts((s) =>
{
    s.AddGroup("MyGroup", (g) =>
    {
         g.Add("script1.js").Add("script2.js").Add("script3.js");
    }
}).Render(); %>

Now we have our scripts defined, but if you run the app, you will be disappointed by finding out three script files were added. Instead, we need to add some additional properties to the group definition.

s.AddGroup("MyGroup", (g) =>
{
g.Add("script1.js").Add("script2.js").Add("script3.js").Combined(true).Compress(true).CacheDurationInDays(10);
}

The Combined() method signals to combine all three scripts together within this group The Compress() method signals to compress the scripts, and the CacheDurationInDays method specifies the number of days to cache the scripts.

This can also be performed by stylesheets, without the ability to combine and compress them. You can group them together using the same approach, except using the StyleSheets method.

This setup produces the following output.

The other option for adding scripts is to use the DefaultGroup method, a method that uses the default group to setup scripts for. For instance, we setup a custom group, but if you only need one group, we can use the DefaultGroup method to define all our scripts in.

Working with Web Forms and MVC: Bridging the Gap - Context

2009-11-07T17:02:00Z

I've spent some time figuring out how to bridge the gap between web forms and ASP.NET MVC style of development. Just because the UI works differently, doesn't mean the actual framework works in a different way. If you use .NET 3.5 SP 1 for both your web forms and MVC style development, it is helpful to come up with a helper component to serve up the context. Why would I suggest this? Well, in web forms, you can access the current context information by accessing System.Web.HttpContext.Current, which returns the current HttpContext being executed. The HttpContext object has an array of services (request, response, etc.) that you can make use of. This is available in ASP.NET MVC in the controller too, via the ControllerContext.HttpContext reference.

The difference between the two is that the former uses an HttpContext object, while MVC uses an object of type HttpContextBase in System.Web.Abstractions.DLL. The context is a reference to HttpContextWrapper, which inherits from HttpContextBase, and provides you with all of the services previously mentioned. So basically, you are working with the same thing, but not the same object. But if you use 3.5 for all of your development, you can use the same object to leverage both, by creating a helper class and always referring to this for your context.

public static class HttpWebContext
{
    public static HttpContextBase GetContext()
    {
         return new HttpContextWrapper(HttpContext.Current);
    }
}

This works in web forms because this is how it works anyway, while MVC uses this in its underlying architecture (if you use a tool like Reflector you can dig down into the code to find it). And so this common component shares the context across two environments, and its isolated and follows the Singular Repsonsibility Principle [SRP]. Now what about testability, because your internal components will be using this, and the http context won't be available in a testing environment (since it's web framework specific). For instance, your controller may do something like:

public ActionResult View()
{
    var context = HttpWebContext.GetContext();
    //use the context in some way

   return View();
}

So how can that type of method be mocked? If you use TypeMock, this can be done easily:

var ctx = Isolate.Fake.Instance<HttpContextBase>();
var requestFake = Isolate.Fake.Instance<HttpRequestFake>();
Isolate.WhenCalled(() => ctx.Request).WillReturn(requestFake);
//Additional faking here

Isolate.WhenCalled(() => HttpWebContext.GetContext()).WillReturn(ctx);

For Moq, this is harder because it doesn't mock statics; so you could make it an instance-based approach, or you could use a provider approach. For instance, create a provider that has:

public abstract class ContextProvider
{
public HttpContextBase GetContext();
}

Have two implementations, one for returning the current context like we have above, and have another returning a faked http context that inherits from HttpContextBase, and then store this reference in the configuration file or pass it in as a parameter to a class. You could get kind of crazy with it, but by using the provider approach, it helps you differentiate the web environment and test environment without exceptions occurring.

Would this approach work in .NET 2.0? Well, the great feature about 3.5 is the System.Web.Abstractions, which contains the HttpContextBase class that handles this for you. So if you can use 3.5, you can leverage this API for your needs. Otherwise, you would have to create your own wrapper, which is possible but tedious (since it's such a big class).

IServices service loader approach to loading services

2009-11-05T02:38:00Z

This is a continuation of a blog series on creating services. You can find the previous articles here:

Accessing Service Oriented API's using an IService interface

So the ApplicationContext object uses a service loader as one way to load the IService objects into it. This class exists solely to load these services into the context. This object is then linked into the Application context through the configuration file. The below example is used for loading MVC services by default (you can inherit, override this method, and add additional ones you use as a way to make it easier for loading the services you need). This object already exists in the Nucleo.Web.Mvc DLL, in the Nucleo.Web.Context namespace.

public class MvcApplicationContextServiceLoader : IApplicationContextServiceLoader
{
#region " Methods "

public virtual void LoadServices(IApplicationContextProvider provider)
{
  provider.RegisterService<IApplicationStateService>(new MvcApplicationStateService());
  provider.RegisterService<IBrowserCapabilitiesService>(new WebFormsBrowserCapabilitiesService());
  provider.RegisterService<ICookieService>(new MvcCookieService());
  provider.RegisterService<INavigationService>(new MvcNavigationService());
  provider.RegisterService<IPostDataService>(new MvcPostDataService());
  provider.RegisterService<ISessionStateService>(new MvcSessionStateService());
  provider.RegisterService<IServerUtilityService>(new MvcServerUtilityService());
  provider.RegisterService<IUrlResolutionService>(new MvcUrlResolutionService());
}

#endregion
}

The LoadServices method is where the action happens. The application context provider is used to receive these services and supply them to the ApplicationContext. You don't actually have to worry about that; the service provider is used by the context to serve up these services. This class is then linked up in the configuration file. See the following example for the setup:

The context settings section is the configuration object for specifying the loader you would like to use. At runtime, the ApplicationContext object uses this to load the relevant services, so when you do:

context.GetService<ICookieService>();

A valid service will be returned to you. We'll talk more later about the purpose of the context provider later, how that's configured .

Moq and TypeMock in Comparison

2009-11-04T00:31:00Z

I've been working on a new MVC project and man has it been enlightening! It's my first MVC project, so I get to go through all the things I thought I knew from reading Pro ASP.NET MVC Framework (Apress by Steve Sanderson) to realizing I don't know squat,and have to really delve into the learning in order to finish the project, a task which I knew I was getting into and greatly accept the challenge. Anyway, as I've been developing, I've been trying to use Moq to create my unit tests. It's a free mocking library that enables you to write code that mocks your existing objects. While most libraries heavily use interfaces for writing mocks, Moq can mock classes that have the methods or properties to override marked as virtual (and there are some other conditions as well; you can see an example on Stephen Walther's blog). As you can see, Moq is great and is useful for MVC applications, and can be used in web forms in a more limited fashion.

TypeMock, however, offers you a few more conveniences over mocking. For instance, Moq doesn't support mocking static methods, internal methods, and a few other scenarios. In fact, Moq is a good approach if you design software using the DI pattern, as is illustrated below:

public class TestClass
{
public TestClass(IDependency dep) { }
}

This is where a dependency is passed in to the constructor (or it can be via a property), which Moq can setup easily as in the following code:

var depFake = new Mock<IDependency>();
//Setup any mocking here

var tc = new TestClas(depFake.Object); //fake gets inserted here
// tc.Dep = depFake.Object; <-- this is an alternative approach

However, TypeMock allows you to use other approaches as well, which fits closer to my development style. For instance, suppose you have this type of class that uses the dependency:

public class TestClass
{
    private TestClass() { }

    public static TestClass Create()
    {
         var c = new TestClass();
         c.Dep = DepResolver.Get();

         return c;
    }
}

With Moq, we have no inherent way to tap into this method. This is where TypeMock comes in. TypeMock allows us to tap into this method a couple of ways. First, we could skip the Create method altoghether using:

var tc = Isolate.Fake.Instance<TestClass>();
Isolate.WhenCalled(() => TestClass.Create()).WillReturn(tc);

The first line creates our fake, similar to Moq's "new Mock<TestClass>" syntax. Rather than returning a proxy, it returns an actual instance of our mocked class. The second statement provides a way to override the static method and return directly our fake. This may not be as useful, so let's look at the next way to tap into this method:

var dep = Isolate.Fake.Instance<IDependency>();
Isolate.WhenCalled(() => DepResolver.Get()).WillReturn(dep);

var tc = TestClass.Create();

When this code runs, the TestClass instance is actually created, and that code works as is. But the code revolving around the IDependency is faked, so that the DepResolver returns our fake and doesn't actually run. So you can see some of the ways that TypeMock allows developers to tap into their code without forcing a design. We'll look at other ways this can happen later on.

Note: This doesn't mean Moq is bad by any means; designing your software for testability is a good thing, as it's good to leverage unit tests to ensure accuracy of your code doing what it was supposed to do. It's just that TypeMock gives you a few other options, and this is one of the additional features that TypeMock provides.

Nucleo Link Control Overview

2009-10-31T18:53:00Z

My latest release at http://www.codeplex/nucleo also features a new Link control (in the Nucleo.Web.Controls namespace). This control tries to integrate two kinds of links; clickable links which fire an event, and redirection links that navigate to another site. The link control incorporates an enumeration to incorporate this: the ClickAction property of type LinkClickAction. When set to FIreEvent, the client-side clicked event or server-side clicked event (depending on rendering mode set by the RenderMode property) of the control, whereas Redirect fires a Redirecting event.

The redirecting parameters can be set by establishing the NavigateUrl property. This property specifies the location to redirect to. Another option, Target, specifies whether to use a new window to open the link in, or the same window. The link also specifies a NavigateUrlFormatString that you can use to do something like this:

<n:Link ... NavigateUrl='<%# Eval("Key") %>' NavigateUrlFormatString="products.aspx?id={0}" />

When a format string is specified, the navigateurl property is injected in the format string, as a convenience option. Only one format placeholder is available. The server component also has helper methods to get the final values for text (which has Text and TextFormat properties), navigate url, and more. The GetText, GetNavigateUrl, and GetTarget methods are convenience methods for extracting this information as the control would need for rendering.

These options can be changed on the client-side; each of the main properties (navigateUrl, clickAction, target, text, etc.) is available on the client except for the format strings. So you can change the way the link reacts to clicks, change where it navigates to, and more.

var link = $find("<%= l1.ClientID %>");
link.set_text("New Text");
link.set_clickAction(Nucleo.Web.Controls.LinkClickAction.Redirect);
link.set_navigateUrl("http://www.yahoo.com");
link.refreshUI();

Note the refreshUI method; this is a method that's used to perform the actual updates. This is important because the UI changes won't occur until that method calls. The reason is because I created a batch method to perform these updates for performance reasons (updating on every setter would be cumbersome).

Accessing Service Oriented API's using an IService Interface

2009-10-31T03:09:00Z

If you've used MVC, you know the System.Web.Abstractions API offers you a lot of capabilities to make it easy to write unit tests in your MVC controllers. It's really easy to setup a Moq or TypeMock unit test to create a fake implementation of objects like HttpContextBase. Some objects are not as testable. For instance, UrlHelper may not be as easy to implement testing with (although TypeMock can test pretty much any object very easily since it doesn't require a DI setup or interfaces). Rather than leverage this approach, I chose an approach not just limited to web forms, and something that may be available in a windows, silverlight, or WPF environment as well. Welcome the ApplicationContext object and the IService interface.

ApplicationContext is a central object that is used to make services available to those who need it. You have to go through a process of loading these services; however, this process isn't that hard (will cover in another blog post). To use the application context looks something like:

ApplicationContext context = ApplicationContext.GetCurrent();
ILoggerService service = context.GetService<ILoggerService>();

Every service that the application context uses implements IService (this interface doesn't really do anything, but simply is used as a marker). ILoggerService happens to be one of the services available (ILoggerService implements IService) and so it's retrievable vai the ApplicationContext object. Built into the framework is the NucleoContext namespace (which contains environment-agnostic services) and Nucleo.Web.Context (web/MVC specific services) that you can use the ApplicationContext object to retrieve.

The idea of this object is to make available core services. For instance, in MVC, you can instantiate the service you need (HttpContextWrapper, HttpRequestWrapper, etc.). Instead of using this, you can use the application context to request these services instead. I don't have all of the existing web services created; however, I do have services available for cookies, querystring, forms, and more. Rather than create one big request object, I instead break up each of these into smaller services by function.

How do you retrieve? That's the purpose of the service loader, a subject we'll discuss next. You can get the latest code base for this example from: http://www.codeplex.com/nucleo

Using the Nucleo Button

2009-10-28T02:26:00Z

I've been working on a project available at for http://www.codeplex.com/nucleo. It's a project I've had in the works for a while, and it's finally coming to fruition. So I am starting to create blog posts explaining features about these controls. I am really excited about this button because I think it offers you more than what other control vendors offer you (at least the ones I seen, because I don't know every control suite out there). Anyway, my button comes with some nice features.

First, it has a DisableUntilPageLoad property that will disable the button until page load scripts have run. This is a useful feature I found in Professional ASP.NET AJAX from Wrox that really does make sense. So I added it into my button control, which simply can be enabled via:

<n:Button ... DisableUntilPageLoad="True" />

And now the button doesn't enable until page loads on the client. Note: It's up to you to ensure JavaScript works :-; Next, we have the ability to disable the button when it clicks by setting the DisableOnFirstClick property to true. This disables the button permanently, but can be re-enabled using the enabled client-side property. The DisableOnFirstClickTimeout specifies a timeout in seconds, which will be used to re-enable a button. This is a nice feature because often developers want to prevent double-clicks from happening, yet still ensure that they can click the button. Using these setting:

<n:Button DisableOnFirstClick="True" DisableOnFirstClickTimeout="300" />

This disables the button on click, then re-enables it at 300 milliseconds. The button does support all the traditional IButtonControl implementations, but doesn't use the ASP.NET implementation; rather, I use a cleaner approach that can be used on both the server and the client.

The button also specifies a mode to render in, whether link button, push button, or image button. This mode is then rendered appropriately. This then requires only one button instance, and can be changed on the server. It currently cannot be changed on the client, but should be something I implement in the future.

This are some of the Button control's available offerings. More to come soon on some of the other controls.

Pro Asp.NET MVC Framework (Apress) by Steve Sanderson

2009-10-20T02:08:00Z

Rating: 5 out of 5

I believe Pro ASP.NET MVC Framework is one of the best books on the market about MVC. This book is crammed with a lot of information that you need to know as a developer. While he doesn't cover each subject fully (no book really does that), he does cover the major topic points related to MVC in-depth, and touches upon the other concerts that you need to be aware of to implement or customize MVC for your own purposes. I’ve broken up my review into several major subsections related to the book and analyze each one individually. From an overall level, I think the book really did well in its explanation and examples of MVC.

Book's Knowledge

This book is really crammed with lots of valuable information. I find myself referring back to the book when working with MVC, because it has a lot of various important sections about how to use JQuery to dynamically change MVC partial views within a view, how to customize the creation of a controller, and other important facts. There is so many small or medium details regarding the MVC framework that is important to know about covered in this book, that it does really make it a very beneficial book.

The chapters on each major feature (views, routing, controllers, etc.) are very long, which is great because they contain so much information about each of the subjects. I was really impressed with the information packed into each of these chapters. After reading the book, I felt comfortable enough to work on MVC and understand some of the concerns when implementing MVC for my own applications. I felt there was minimal downtime trying to play with MVC to understand its inner-workings; I really felt confortable jumping in.

Writing Style

I really like Steven's ability to clearly articulate points about MVC. If the writer is not fluent, I tend to lose interest, but I didn't lose interest at all in this book. This book doesn't just talk about the functionality, but actually illustrates its use through examples and theory, which is important for such a big subject. That's not to say he doesn't explain his code, which he does in the right amount of detail.

Content Structure

Though a pro book, the author ensures that he covers the basic prerequisites for the book, to fill in the user how MVC works. The book continues on with three chapters of a sample MVC application, explaining it some as he goes, following up with most of the book detailing each features.

The main complaint of the book that I have is that Chapters 4, 5, and 6 cover the basics of creating an MVC sports store application and tries to get you familiar with MVC by jumping right in without a lot of preliminary discussion. While he does discuss what he’s illustrating, I feel it would have been helpful to cover the documentation of the features first, and then rolled through the example last, with a bigger/more complex example.

The plus to this design is that the sample walks you through the basics, and the subsequent materials enhance your understanding of routing, views, controllers and actions, data entry and model binding, AJAX and client-scripting, and security.

I found much use alone out of the chapters on using AJAX to use an unobtrusive JavaScript approach and the concerns to have with implementing security (since ASP.NET web forms handled certain security features for you automatically and MVC does not).

Implementation

While I do have a deep technical background, the concept of MVC is somewhat foreign to me; I had a familiarity to the pattern, but didn't know anything about the product. After reading this book, I felt very confident about my ability to create an MVC site. There were some curveballs and I had to reference the book again and again, but I felt overall that this book was a fantastic resource to get me going. It's the only book I read on the subject (outside of the NerdDinner resource provided by Scott Guthrie).

Conclusion

MVC is a great product. While in its infancy (2.0 has some great features coming), MVC gives you control over the UI that web forms took away. MVC is a big undertaking and does require some knowledge about how it works. I believe this book is a great way to take a big chunk out of the mystery of MVC, especially for those coming from a web forms world.

ADO.NET Entity Model Helpers

2009-10-02T01:17:00Z

I'm starting to get into a project using ADO.NET entity model. This is a pretty cool technology, and I like a lot of the features (especially the logical model approach). There are some things I really dislike about Phase 1, like having to delete the entire model or edit SSDL manually (or with XML tool) - anybody know of some free tools available for this? But overall, I like the approach, and the concept, so I look forward to adding features.

Some features I want to add is automatic logging. Sometimes, you just need to know what's going on with your application to see if the logic is working correctly. I often create a logger class, create an ILogger interface with a LogError and LogMessage methods, and create derived classes to log to event log, console, health monitoring, etc. That is out of scope for this article, but I want to focus on the idea of extensibility. I've been reading articles about how to plugin to the provider architecture and other approaches, but I don't personally want to affect the architecture. Rather, I'd rather take the wrapping approach. This is separated and isolated from any provider architecture changes over the years. While that's not a major concern anyway (at least for me), a separate class seems like a good approach.

So I use a class that does something like this:

public class ObjectContextHelpers
{
    public static void SaveNewObject(CustomObjectContext context, string entitySetName, object entity)
    {
         //get a reference to the logger - pass in as ref or via singleton, or some other approach
        logger.LogMessage("Attempting to save object for entity set " + entitySetName);
        //Can log other details, number of objects commiting, details about object state entries, and other information

        try
        {
            context.AddObject(entitySetName, entity);

        }
        catch(Exception ex) { logger.LogMessage("Saving object failed: " + ex.ToString()); }

        logger.LogMessage("Saved object for entity set " + entitySetName);
    }

    public static CustomObjectContext Create()
    {
         return new CustomObjectContext(ConfigurationManager.ConnectionStrings["ConnString"].ConnectionString);
    }
}

Here we have a Create method that uses one common connection string, which is a connection string pre-configured (assuming that you aren't building a custom library that may require configurability).

Facebook Connect and Localhost

2009-09-24T02:36:00Z

Most people may not realize, but you can use Facebook Connect with your http://localhost server. This works great for ASP.NET and MVC (and other environments too, but I'm primarily a .NET guy so please pardon my favoritism). You setup the localhost environment as the Facebook connect URL, as in http://localhost/<Virtual>. I would recommend using a virtual directory, and not using the Cassini web server (the local web server which may reassing port addresses on you).

You do have to be connected to the internet for this to work, as an FYI. Not usually a problem, but just something to know about. THis is because Facebook is making requests to its server, and there isn't anything setup to use a local credentials store for development only.

Using FQL in SQL Server Over REST

2009-09-24T02:29:00Z

If you haven't heard from my blog or Facebook WIKI's before, there are two ways to query data from Facebook, using the ApiClient object to query the data from the Facebook server, or by using FQL to query against their propietary database directly. In a recent app, I found that using FQL cut in half the number of calls to the server than what I would have had to made using the REST api. So using FQL can be a great benefit. Picture this query:

select page_id, name, page_url, pic_small, website, location, bio, founded from page where page_id in (select page_id from page_fan where uid = '{0}')

This queries the database server looking for pages that you became a fan of, where you are a fan of that page. There are two primary tables: page and page_fan, where page contains the page data, and the page_fan table links your user ID to the page that you are a fan of. To do this via rest required two calls to the server, one to get the pages you are a fan of, while the other to get the details of the page. This means you have to use callbacks within callbacks, and really creates a nested hierarchy. This way, FQL cuts off that work.

I've had other scenario's where it was going to take many calls to have the same effect as one FQL query, where you end up making a rest call just to get the ID's of your friends, then making a call to load your friend's data, and then loading other data related to your friends. You can see how that can be cumbersome without FQL.

Adding an Effective/End Date CodeSmith Template

2009-09-15T00:55:00Z

I really like CodeSmith, a great tool for generating templates. It comes with a variety of default templates, all managed in a Visual Studio-like environments, complete with intellisense that's good, but not quite as powerful as Visual Studio. I do a lot of scripting, so I wanted to make stored procedure generation easier. One scenario not covered is reference tables, where the reference tables happen to have two specific columns all the time:

EffectiveDate datetime not null,
EndDate datetime null

The effective and end dates determine which entries are in process at the given time. I don't want to be having to write this code all the time. Instead, I added this to the default template (StoredProcedures.cst) that comes with CodeSmith. These are the modifications I made. First, I need to be able to use the IEnumerable<T> interface, and thus we need the mscorlib assembly. So I added these two declarations at the top. More on why in a little bit.

<%@ Assembly Name="mscorlib" %>
<%@ Import Namespace="System.Collections.Generic" %>

I added a new property for this method that can be used to turn it off or on. This is a boolean, with a default to true:

<%@ Property Name="IncludeSelectByEffectiveEndDate" Type="System.Boolean" Default="True" Category="3. Procedure Types"
Description="If true a SELECT procedure will be generated to select by effective/end dates, if the table has these fields." %>

If you are unfamiliar with this, CodeSmith uses the @Property attribute to allow a configurable setting that can be changed in the property window (shown below). This property window makes it easy to add all sorts of configuration capabilities to your scripts. Note the description appears within the description window.

So now we have a property to turn our feature on and off, we need some supporting methods, such as a method to generate the proc name. The existing template has a variety of method that do this, and working in straight copy-and-adapt mode, I added a method that follows suit as shown below. Note: if you aren't aware, CodeSmith allows code segments within its <script runat='server"> tags, following an inline code approach that ASP.NET uses. This makes for a great place to stick in helper methods that return text, or write a response directly to the output.

public string GetSelectByEffectiveEndDateProcedureName()
{
return String.Format("{0}[{1}{2}ReadByEffectiveEndDate]", GetTableOwner(), ProcedurePrefix, GetEntityName(true));
}

Our first task in using this is to drop the proc, if it exists, via the GenerateDropStatement method. This work is already done, and needs a simple call to first check if the conditions are met (the flag is set to true and we indeed have an EffectiveDate/EndDate fields because not all tables will). Note that SourceTable is a TableSchema object that represents that individual table.

if (IncludeSelectByEffectiveEndDate &&
  this.SourceTable.Columns.Contains("EffectiveDate") &&
  this.SourceTable.Columns.Contains("EndDate"))
{
  GenerateDropStatement(GetSelectByEffectiveEndDateProcedureName());
}

Next, the process for creating the proc is pretty simple too. It starts off with a generic comment and header (as repeated from other examples. I must do the same flag/effective/end date check, and if all is well, then we can begin by generating the header (already done via GenerateProcedureHeader). Take a look at the body below.

<%------------------------------------------------------------------------------------------
*
* SelectByEffectiveEndDate Procedure
*
------------------------------------------------------------------------------------------%>
<%
if (IncludeSelectByEffectiveEndDate &&
this.SourceTable.Columns.Contains("EffectiveDate") &&
this.SourceTable.Columns.Contains("EndDate"))
{
GenerateProcedureHeader(GetSelectByEffectiveEndDateProcedureName());
%>

CREATE PROCEDURE <%= GetSelectByEffectiveEndDateProcedureName() %>
(
@EffectiveDate datetime,
@EndDate datetime
)
AS

SET NOCOUNT ON
<% GenerateSetTransactionIsolationLevelStatement(IsolationLevel); %>

SELECT
<% GenerateColumns(SourceTable.Columns, 1); %>
FROM
<%= GetTableOwner() %>[<%= SourceTable.Name %>]
WHERE
ISNULL(EffectiveDate, '1/1/1900') <= @EffectiveDate AND
ISNULL(EndDate, '12/31/9999') >= @EndDate

<%
GenerateProcedureFooter(GetSelectProcedureName());
this.Progress.PerformStep();
}
%>

In this case, I know the fields already, so I don't need to generate them dynamically since I'm assuming they exist. The GenerateColumns methods generates all columns for select, GetTableOwner returns dbo or the schema name for whatever the case may be, and the table name is accessible via SourceTable.Name property (SourceTable, as I said before is a TableSchema object).

For more information about using CodePlex and the database schema objects, check out this article: http://aspalliance.com/1580_Creating_Code_Smith_Templates.all

MVC Controller Context - Where does it come from?

2009-09-13T04:03:00Z

The Controller class maintains a reference to the HttpContext property, and object of HttpContextBase. HttpContextBase is a great class because now we have an abstract way to replace default logic if needed (but generally that wouldn't be recommended). Ideally, it's great for fake environments. But I digress, HttpContextBase is the main object for accessing context-specific information. But where does this actually get created? I went digging around the API in Reflector, and found where the MVC handlers that create the request. The MVCHttpHandler uses theMvcHandler object, along with the HttpContext.Current reference as a way to instantiate the context. So while in ASP.NET you would directly reference HttpContext.Current to access the context, here in MVC references to HttpContextBase comes from HttpContext.Current.

If , for whatever reason, you wanted to instantiate the HttpContext object directly, you would do this via: new HttpContextWrapper(HttpContext.Current).

Facebook Location Object

2009-09-12T05:04:00Z

If you have used the Facebook FQL syntax to query the location column of a table, or have requested the location parameter from the friends_get or other API methods, what you need to know is location is a complex object consisting of the following properties:

city
country
state
street
zip

These properties can be directly accessed via location.zip, location.city, etc.

Facebook FQL

2009-09-12T04:49:00Z

Facebook supports a variant of SQL called FQL, or Facebook Query Language. If you know anything about Facebook's data storage center, Facebook has moved away from the traditional relational database and created their own custom application for storing data, which has the ability to query petaflops worth of data in seconds. So what is FQL? FQL looks very like SQL. It has a select and select list, a from, a where clause, which makes it seem like its ordinary SQL. However, it cannot use inner joins or outer joins, and its limited on the number of fields that it can query. For more information on the language itself, please consult this: http://wiki.developers.facebook.com/index.php/FQL. For a list of tables, see this. http://wiki.developers.facebook.com/index.php/FQL_Tables.

One way FQL can be executed is in JavaScript, through the fql_query method. Below is a sample query where pages are queried for its page id, name, small picture, location, and website.

var api = FB.Facebook.apiClient;
api.fql_query('SELECT page_id, name, pic_small, location, website FROM page WHERE name in \"' + name + '\"',

function (results, ex) { .. });

This is one way to query the Facebook database for a list of pages. The name field is queryable using in, or could also be used with an equal sign, as you see in SQL. However, there aren't very many other constructs supported (if any than = and in). The results returned are in the form of JSON, and can be processed like any other JavaScript would process the code. This brings quite a number of possible options for using queries in your data.

Note that FQL may not allow you to restrict input to the exact results you want due to limitations in FQL. This has been posted around the internet, about having to bring back more results from the database, and limiting the results in your code. To test out the query that you may want to setup, try it out in the Facebook Tools section. Selecting the method to execute as fql_query allows you to test database queries against the backend to see what is allowed and what is not.

For some sample queries, check out this page: http://wiki.developers.facebook.com/index.php/Sample_FQL_Queries

Facebook Connect JavaScript API

2009-08-29T02:36:00Z

I recently submitted a Facebook development article to ASP.NET Pro magazine. It was quite the challenge initially to get it started. But once I got going (I think I'll blog on this later), I was off and running but there aren't a lot of examples on the WIKI. I put a combination of items together in order to figure it all out.

First, the core content I used to extract user's information was the Facebook JavaScript API, available here: http://wiki.developers.facebook.com/index.php/JS_API_Index. The core object in Facebook to extract data from its servers is the ApiClient object (http://wiki.developers.facebook.com/index.php/JS_API_T_FB.ApiClient). Unfortunately, for most method calls, there isn't any documentation. A few things to note:

If you google on these methods (like groups_get, friends_get, or photos_getAlbums), you're likely to come up with something. Usually, it's PHP examples, but it's something you can go off of.
You can post in the forums, but in the questions I had, there really wasn't any movement.
If you see the method return FB.PendingResult, this is because it returns data asynch from the server. In most cases that I saw, it fires a callback with the signature function(results, ex) { }. This callback can be specified in the parameter list where the SequencerBase parameter is defined.
Speaking of SequencerBase, the WIKI has an example of how you can use a SequencerBase class to download all of the user data on one shot simultaneously.

Some other notes/general issues I found are:

The user ID of the user is a long that represents them. When logged in, you can get this via the ApiClient. Assuming the ApiClient object is stored in the api variable, the code to get the user's ID would be: api.get_session().uid.
However, a lot of the rest API's use a string for the user, so you need to ensure it's a string. Don't know why.
The ApiClient.users_getInfo method takes a concatenated list of strings of fields to download for the user. There is a long list of information that can be retrieved can be found here: http://wiki.developers.facebook.com/index.php/Users.getInfo
The groups_get method returns a collection of groups, each group with a specific API: http://www.app-developers.com/index.php?topic=11.0
The photos_getAlbums objects also has a specific API: http://www.app-developers.com/index.php?topic=13.0
Certain features require permissions, which means a call to FB.Connect.showPermissionDialog: http://wiki.developers.facebook.com/index.php/JS_API_M_FB.Connect.ShowPermissionDialog

I hope this helps, and more content will be coming.

TypeMock Isolation Members - CallOriginal

2009-08-18T01:26:00Z

This post assumes you are familiar with TypeMock's Arrange-Act-Assert method of test creation. If you are not, please read my overview at: http://dotnetslackers.com/articles/designpatterns/TypeMocks-Arrange-Act-Assert.aspx.

When creating your fakes with TypeMock, you have to be careful which member your choose as the default mocking level. For instance, when you create the following class:

var cls = Isolate.Fake.Instance<TestClass>();

The variable cls has a fake reference to our test class. All calls to any method are mocked (no code actually runs for that method), unless you do:

Isolate.WhenCalled(() => cls.MyMethod()).CallOriginal();

You can also control the results through the other methods available from Isolate.WhenCalled, such as using WillReturn to return a pre-specified value. That is out of scope, but a good subject for a future blog post. Anyway, back to the subject, you may wonder why certain methods fail, especially if you use Isolate.Verify to verify method calls. I had the same issue, and it turns out its because of the default behavior of the fake. For instance, if I would have done:

var cls = Isolate.Fake.Instance<TestClass>(Members.CallOriginal);

The default behavior is to call the original instance of methods within the class, and not to mock their calls. This was the solution to an issue was having; I had an internal collection of objects like:

private ACollection AList
{
    get
   {
       if (_aList == null)
             _aList = new ACollection();
       return _aList;
    }
}

Because I didn't do the following statement during the default level of mocking access:

Isolate.NonPublic.Property.WhenGetCalled(cls, "AList").CallOriginal();

AList was mocked in my test and my test failed. Adding Members.CallOriginal caused AList original implementation to be called, and then the test succeeded.

Paging Table Columns Using JavaScript

2009-08-04T22:41:00Z

I recently have been thinking about tabular displays and how to make them better. For instance, suppose that your final output of an application looked like the following:

<table id="tbl">
<thead>
  <tr>
   <th>One Header</th>
   <th>Two Header</th>
   <th>Three Header</th>
   <th>Four Header</th>
   <th>Five Header</th>
   <th>Six Header</th>
   <th>Seven Header</th>
   <th>Eight Header</th>
  </tr>
</thead>
<tbody>
  <tr>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
  </tr>
  <tr>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
   <td>Value</td>
  </tr>
.
.
.
.

</table>

Imagine this is for a form of some sort. Think in reverse of a GridView control in ASP.NET; the GridView control renders a dynamic number of rows; this example is more suited for an application you may build that is columns-based, say to render a comparison between products, or maybe the headers a representative of people, and the rows contains some attributes about them (name, height, weight, and other stats).

So, this example using JavaScript and JQuery is meant to enable a new way of paging columns-based data; however, it could be adapted to page row-based data. Now, if you have a lot of data in the column-based form, it will force a horizontal scrollbar, something that is against standards in most organizations (and is not a preferred approach anyway unless culturally significant). To offset this, the script I'm about to show you will show only 4 columns at a time, allowing the user to page left/right. To do this, I will use a looping construct to loop through the columns and rows to change visibility. The script looks like:

$(document).ready(function() {
  var t = $("#tbl");
  $("#output").html(t.outerWidth().toString() + ", " + t.outerHeight().toString());

  refresh();
});

function refresh() {
  var table = $("#tbl")[0];
  var headerRow = tbl.getElementsByTagName("THEAD")[0].rows[0];
  var rightColumn = leftColumn + columnCount;

  if (leftColumn <= 0) leftColumn = 0;
  if (leftColumn >= headerRow.cells.length - 3) leftColumn--;

  for (var r = 0, rlen = table.rows.length; r < rlen; r++) {
   for (var c = 0, clen = headerRow.cells.length; c < clen; c++) {
     table.rows[r].cells.style.display = ((leftColumn <= c && c < rightColumn) ? "table-cell" : "none");
   }
  }
}
</script>

To begin, to figure out which 4 columns to show is determined by the leftColumn variable; it stores the current column index of the far left visible column. The column count stores the number of columns to display, so that is configurable and can be something other than 4 columns. When the document loads (using JQuery's document ready event), the UI initializes to show the 4 columns. The refresh method actually shifts the columns, and it does this using math.

The THEAD definition is special, because that is the easy way to figure out how many columns their are; there isn't any explicit way to figure columns (unless a COLGROUP is specified); so the header easily figures out there are 8 columns available. Two loops take place; first, it loops through each row to show/hide the appropriate cells, while the rest get hidden. It iterates through the rows first, then the columns, and changes the display accordingly.

To page, I included two buttons that will page left/right. You may have notice the if checkes in the previous JS code; it simply ensures the paging isn't out of the valid range of values.

<button id="navleft">Move Left</button>
<button id="navright">Move Right</button>

JQuery hooks up to the click event, and refreshes the UI after it increments or decrements the left column index.

$("#navleft").click(function() {
  leftColumn--;
  refresh();
});

$("#navright").click(function() {
  leftColumn++;
  refresh();
});

And that is all that it takes to use JavaScript, and JQuery (even if I don't fully take advantage of it) to create a way to page columns of a table. It works really well and is fast.

Book Review for Pro Silverlight 2 in C# 2008 By Matthew McDonald

2009-07-07T01:32:00Z

I read Matthew McDonald’s book Pro WPF to bone up on WPF, XAML, and everything .NET 3.5 has to offer. I have to say that I was impressed by Matthew’s writing style, level of detail, and general knowledge that he passed onto the reader. This fact is also the case with Pro Silverlight 2. While WPF has some similarities to Silverlight, the author points out some of the differences (like the lack for EventTrigger support for any event but the Loaded event in the current version).

The book covers all of the major topics, starting with an overview of the basic elements: XAML elements, properties (simple and attached), moving into the subjects of Layout containers, dependency properties, and routed events. He then moves into an overview of the various controls. This overview isn’t exhaustive, but gives you a firm foundation. I thought his chapters on shapes, brushes, transforms, audio/video, and animation to be very helpful. It can be difficult to understand how to setup these various features, and Pro Silverlight 2 clarifies it well.

The next section of the book covers the more advanced topics that you would need to know to use Silverlight, such as using web services within ASP.NET/silverlight (a useful topic since Silverlight doesn’t use ViewState or server-side technologies because it’s running on the client), databinding (which can be challenging due to various levels of nested Silverlight structures), multithreading, and more. He really doesn’t leave very many stones unturned in his explanation of the features.

I would highly recommend this book from Apress. Although Silverlight 3 is coming soon, this book will help you understand those fundamentals that will be in the next version.