XHalent Coding...

Master Details with Dialog in ASP.Net MVC and Unobstrusive Ajax

xhalent — Wed, 25 May 2011 13:19:25 +0000

Today’s post explains a user interface that is not uncommon. The user interface consists of a list of items, and if the user clicks a link in the row of data for an item, a dialog window appears so the user can edit the details of the item. When the user saves their changes, the table updates itself to reflect the new changes.

I’m going to cover an approach you can use with ASP.Net MVC to enable this, and explain the aspects required for the Controller and Views that make it all hang together. I’m not going into detail about where the data comes from or what the data is. The idea here is to concentrate on the pattern – you can work out what the data for the list and details screens, respectively, is.

Controller

We’ll set up the controller first. The controller requires at least four methods:

Index method

This handles the initial interaction of the user with the screen. It’s job is to retrieve the data from whatever is the data source to display and display the “Index” View.

public ActionResult Index(){
  MyListModel model = new MyListModel{
    Data= myDataStore.GetDataAsList()             
  };

  return View(model);
}

The Record – Get – Method

This action returns a partial view via Ajax of the record to be edited. I will cover in a moment what is done on the client, but this method builds the edit View Model for the entity by first retrieving it from the data store. Note the use of the null able parameter to indicate if a new record should be created.

Also of interest is the use of the OutputCache action filter to ensure that the Ajax GET request is not cached on the client.

[OutputCache(NoStore = true, VaryByParam = "None", Duration = 0)]
public PartialViewResult MyEntity(int? id){
  DetailViewModel model = new DetailViewModel ();

  if (id.HasValue){
    model.EntityDetail = myDataStore.GetData(id.Value);
  }
  else{
    model.EntityDetail = new MyEntityDetail();
  }
  
  return PartialView("Detail", model);
}

The Record – Post- Method

This method does the update based on a POSTed model. Note how it the method has same name as the previous method, but is decorated with a [HttpPost] attribute and takes a populated entity model as a parameter. If the ModelState is valid, then it is prudent to clear the model state so that posted values are not re-displayed when rendering the view. Instead, the model is refreshed from the data store.

[HttpPost]
public PartialViewResult MyEntity(DetailViewMode model){
  if(ModelState.IsValid){
     ModelState.Clear();   
     model.EntityDetail = myDataStore.UpdateMyEntity(model.EntityDetail);
     ViewBag.Message = "Details Successfully Updated";  
  }

  return PartialView("Detail", model);
}

The partial list refresh

Once the record has been updated, the list of records needs to refresh itself. To do this, it need to make an Ajax call to the server to return a PartialView of just the table contents. That’s what this method does. Note again the use of the [OutputCache] filter to prevent Ajax request caching.

[OutputCache(NoStore = true, VaryByParam = "None", Duration = 0)]
public PartialViewResult EntityList(){
  MyListModel model = new MyListModel{
    Data= myDataStore.GetDataAsList()             
  };
  return PartialView("List", model);
}

Views

Okay, so that’s the controller covered, now lets consider the views. I’m going to use 3 views:

Index – the initial view when the user goes to the list.
Detail – the details view of the entity, used for creates and edits.
List – the partical view of the table of entitites.

The Index View

This is very simple. It simply renders the partial list view and all the client side script that makes it all work. Aside from the comments in the script, the keys points are the hidden div for the placements of the Ajax retrieved content.

@model MyListModel
@{
    ViewBag.Title = "List of Entities";
    Layout = "~/Views/Shared/_MainLayout.cshtml";
    //render the partial view
    Html.RenderPartial("List", Model);
}

The List View

This is simply a table that shows whatever properties of the entity you want, but with one of the properties being rendered as an Ajax.ActionLink. This little Microsoft extension simply leverages the jQuery Ajax stack in an unobtrusive way. You can see that I have used the AjaxOptions class to define that callback function to call when the Ajax call is complete and the element to put the returned content in, both of which are defined in the Index View.

Note the use of the additional link in the footer of the table to create a new record. In this case, no id is passed to the controller.

@model MyListModel
@{
    AjaxOptions options = new AjaxOptions
    { 
        //"loadEntity" is a javascript method defined on the Index View
        OnComplete = "loadEntity",
        //"ajax-content" is a div defined on the Index View
        UpdateTargetId = "ajax-content"
    };
}



          .........            
    
@foreach (var entity in Model) {           
    
        ......
     
 }
  
  
    
      
        Name
      
  

       
            @Ajax.ActionLink(entity.Name, "MyEntity", new { id = entity.EntityID }, options)
       

  
    
        @Ajax.ActionLink("New Entity", "MyEntity", options)

Name
@Ajax.ActionLink(entity.Name, "MyEntity", new { id = entity.EntityID }, options)
@Ajax.ActionLink("New Entity", "MyEntity", options)

The Details View

This is the edit form, and it will display in a modal dialog all going well. The key points are

The use of an id for the form, so that it can be submitted when the Save button is clicked.
the use of the Ajax.BeginForm to apply unobtrusive Ajax enabling of the form and the corresponding AjaxOptions,
the use of a hidden legend in the fieldset, the text of which you might recall is extracted when and used as the dialog title,
the setting of unobtrusive validations using script, because Ajax loaded content does not have this happen automagically

@model DetailViewModel
@{
  AjaxOptions options = new AjaxOptions{
    //always post
    HttpMethod = "post",
    //replace the existing content in the "ajax-content" element
    InsertionMode = InsertionMode.Replace,
    //defined in the Index view
    UpdateTargetId = "ajax-content",
    //the callback, defined in the Index view
    OnSuccess = "entityDetailsUpdated"        
  };    
}

@using (Ajax.BeginForm("MyEntity", null, options, new { id = "entitydetails" }))
{
  
    Entity Details - @Model.Name
    @if (ViewBag.Message != null){ 
       @ViewBag.Message
    }      
    @Html.ValidationSummary(true)
    
      
         @Html.EditorFor(m => m.EntityDetail.Name)
      
      .......
    
    @Html.HiddenFor(m => m.EntityDetail.EntityID)
    
    
  
}

Conclusion

This post has demonstrated how to achieve the user interface pattern for master-Details views with dialogs using ASP.Net MVC, jQuery and unobtrusive Ajax. The same effects can be created using explicit script of course, but the unobtrusive Ajax extensions are a time saver and make your views more succinct.

Accessing Embedded Resources from Razor Views in ASP.Net MVC

xhalent — Sat, 14 May 2011 09:41:44 +0000

In razor, there is no access to the ClientScriptManager so there is no readily available method of using that class’s useful GetWebResourceUrl method to retrieve embedded resources. There are few techniques for synthesizing the functionality, revolving around the reflection of the AssemblyResourceLoader class which is all fine and well unless the application trust level prohibits reflection of non-public members. A simpler and pragmatic method is to have a partial view of the old ascx variety, and have it access the ClientScript manager of it’s Page property as below:

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>

Note I’m referencing WebForms.js because I’m momentarily insane. I wouldn’t recommend it in practice !! . To include this web resource in a razor layout page is the same as for any partial view:



    @ViewBag.Title
    
    
    
    @{Html.RenderPartial("WebResources");}

And that’s all there is to it. Using this technique enable to continue using embedded resources from within your razor views.

Localization of Dates in ASP.Net MVC

xhalent — Sat, 14 May 2011 07:07:17 +0000

Introduction

It is a somewhat inconvenient truth that users of your web site are everywhere but they don’t all talk the same language or even do simple things like read dates in the same way. ASP.Net prov ides rich support for globalization. This post covers the localization of dates, the different treatment ASP.Net applies to dates received in a QueryString to those in posted fields and provides some techniques to mitigate any issues caused by this different treatment.

ASP.Net treats Dates in URL’s different to POST fields

This came as a surprise to me. When ASP.MVC binds values from POSTed fields, it applies the current culture, but when it binds values from the URL (querystring) is uses the Invariant Culture.

This can result in unpleasant effects, particularly if like me (programming in Australia) want dates in the format day-month-year, and not the invariant month-day-year.

Say you had a form with a input field for dates. If the user entered ‘14/5/2011’ and the form was submitted via GET instead of POST, MVC would complain that this was not a valid date. If you submit the form via POST, MVC would bind the date correctly.

I wrote to Phil Haack about this:

Hi Phil,I noticed this one today. I’m in Australia (en-AU), so it common to use dates of the form dd/mm/yyyy.When these fields are POSTed, the values are as expected, because the ValueProviderResult is being constructed with the CurrentCulture out of the Mvc.FormCollection.But when the string is submitted via GET, the NameValueProvider is creating a ValueProviderResult with the Invariant culture, which is different to the current culture, and it doesn’t believe that 29/4/2011 is a valid date (29 April 2011). Most upsetting !

He replied thus

Yeah. We made a conscious choice that values pulled from the URL would be culture invariant. The reason is that URLs must be uniform. So if I send you the URL, it shouldn’t change its meaning whether the person clicking it is in AU or in US.

I can’t say I’m convinced as to his reasoning. It kind of assumes that URL’s are static and only accessed by ‘clicking’. But a form submitted via GET is a totally different interaction to a mere click. This logic more or less requires unless the server current culture somewhat reflects the invariant culture (ie you’re in the US) you should POST your forms. Consider the following simple page:

@model TestDates.Models.HomeModel


    
    
    


@using (Html.BeginForm("Index", "Home", FormMethod.Get))
{ 
    @Html.ValidationSummary(true)
    @Html.LabelFor(m => m.SubmissionDate);    
    @Html.TextBoxFor(m => m.SubmissionDate, new { type = "date" })
    @Html.ValidationMessageFor(m => m.SubmissionDate);
    
    
}

Assuming that using a cultre with a date format dd/MM/yyyy, if you fire up this page and enter a date of say ’14/5/2010′, you will get an error from the server:”The value ’14/5/2010′ is not valid for SubmissionDate”. Not ideal!! This is a bit of a restriction but there is a workaround. You need to hook into the form submit event, get the URL the form was going to send, including it’s serialized field information and manually find and replace date fields with their equivalent invariant values. Then manually submit the form and cancel the default event. This is done using the script below:

If you run this and submit, then the date will be parsed correctly. However a problem exists – when the date is displayed to the user, it is in the format posted to the server, so although the user typed dd/MM/yyyy, MVC saw yyyy/MM/dd in the query string and this is the format returned to the user. To get around this, you need to ensure that the users local or preferred culture is automatically set from the user’s browser by setting the following web.config element:

 
    
	.....

This will result in output to the browser of, for example, dd/MM/yyyy for en-AU, MM/dd/yyyy for en-US and YYYY/MM/dd for ja-JP.

The problem still remains in that I want the date to come back to the browser in an invariant manner, so I’m going to modify my submit script to take into the current culture and always submit the date in yyyy/mm/dd format – ISO-8601 format. But because the relative positions of date, months and years can change between cultures, I need to work out the positions before applying the respective replacement regex. To do this, I create a test date and format it to a string in the current UI Culture and test what the first element is. That tells me whether the date or month or year comes first. I can then render the appropriate regex accordingly.So instead of:


data = data.replace(/(\d{1,2})%2F(\d{1,2})%2F(\d{4})/g, "$3%2F$2%2F$1");

I need to use some Razor C# when rendering the script block as follows:


....//following on previous script
@{        
  //create a known date 
  string testDate = new DateTime(2000, 10, 30).ToString("d");

  //replace the known values for years, months and days 
  //with the replacement regex expressions
  string dateRegex = testDate.Replace("2000", @"(\d{4})")
     .Replace("10", @"(\d{1,2})").Replace("30", @"(\d{1,2})").Replace("/", "%2F");

  //see if the produced date starts with the date component
  if(testDate.StartsWith("30")){
    @:data = data.replace(/@dateRegex/g, "$3%2F$2%2F$1");                           
  }
  //see if it starts with the month component
  else if(testDate.StartsWith("10")){
    @:data = data.replace(/@dateRegex/g, "$3%2F$1%2F$2");
  }  
  //it starts with the year component so no work to be done
}

....//continuing on with the script

Obviously you can extend the logic to test for date culture formats such as yyyy/dd/MM or dd/yyyy/MM (if such cultures exist) but I hope you get the point.

Localization and jQuery datepicker

It is worth noting how to switch the jquery datepicker localization. It’s simply a matter of dynamically setting the localization js as follows:


    @ViewBag.Title

Conclusion

This post has demonstrated the vagaries of localizing dates using ASP.Net MVC, and presented a few methods to provide a consistent date experience to the user, regardless of their culture.

Custom Unobstrusive Jquery Validation in ASP.Net MVC 3 using DataAnnotationsModelValidatorProvider

xhalent — Thu, 12 May 2011 13:50:38 +0000

Introduction

In a previous post I covered the use of Custom Unobrusive Validation in ASP.Net MVC using the IClientValidatable. The use of this interface may not always be possible, for example if the validation attribute is defined in an assembly that cannot reference the MVC assembly, or such a reference makes no sense. Under these circumstances, there is another approach to take and that is to use adapters to help the MVC assign the client side validation to apply for a given validation attribute.

Server side code

I’ll use the same example as last time, that is a check sum validator for Australian Business and Company Numbers, but in this case I will not be implementing IClientValidatable.

public abstract class CheckSumNumberAttribute : ValidationAttribute{                       

  private string checkSumType;

  protected CheckSumNumberAttribute(string checkSumType){
    this.checkSumType = checkSumType;
  }

  public string CheckSumType{
    get {return checkSumType;}
  }
}

The implementations of two concrete classes AustralianBusinessNumberAttribute and AustralianCompanyNumberAttribute remain the same.

public class AustralianBusinessNumberAttribute : CheckSumNumberAttribute{
  private static int[] ABN_WEIGHT = { 10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 };
  private static Regex ABNRegex = new Regex("\\d{11}");

  public AustralianBusinessNumberAttribute() : base("abn") { }

  public override bool IsValid(object val){
    string ABN = val as string;
    bool valid = false;
    if (ABN != null){
      ABN = ABN.Replace(" ", "").Trim();
    }

    if (string.IsNullOrEmpty(ABN)){
      return true;
    }

    if (!ABNRegex.IsMatch(ABN)){
      return false;
    }

    int sum = 0;
    try{
      for (int i = 0; i < ABN_WEIGHT.Length; i++){
        // Subtract 1 from the first left digit before multiplying against the weight
        if (i == 0){
          sum = (Convert.ToInt32(ABN.Substring(i, 1)) - 1) * ABN_WEIGHT[i];
        }else{
          sum += Convert.ToInt32(ABN.Substring(i, 1)) * ABN_WEIGHT[i];
        }
      }
      valid = (sum % 89 == 0);
    }
    catch{
      valid = false;
    }
    return valid;
  }
}


public class AustralianCompanyNumberAttribute : CheckSumNumberAttribute{
  private static int[] ACN_WEIGHT = { 8, 7, 6, 5, 4, 3, 2, 1 };
  private static Regex ACNRegex = new Regex("\\d{9}");

  public AustralianCompanyNumberAttribute(): base("acn"){}

  public override bool IsValid(object val){
    string ACN = val as string;
    bool valid = false;

    if (ACN != null){
      ACN = ACN.Replace(" ", "").Trim();
    }

    if (string.IsNullOrEmpty(ACN)){
      return true;
    }

    if (!ACNRegex.IsMatch(ACN)){
      return false;
    }

    int remainder = 0;
    int sum = 0;
    int calculatedCheckDigit = 0;

    try{
      // Sum the multiplication of all the digits and weights
      for (int i = 0; i < ACN_WEIGHT.Length; i++){
        sum += Convert.ToInt32(ACN.Substring(i, 1)) * ACN_WEIGHT[i];
      }

      // Divide by 10 to obtain remainder
      remainder = sum % 10;

      // Complement the remainder to 10
      calculatedCheckDigit = (10 - remainder == 10) ? 0 : (10 - remainder);

      // Compare the calculated check digit with the actual check digit
      valid = (calculatedCheckDigit == Convert.ToInt32(ACN.Substring(8, 1)));
    }
    catch{
      valid = false;
    }
    return valid;
  }
}

Without the IClientValidatble interface, we need to create a “buddy” class of type DataAnnotationsModelValidator that MVC will use to create the data-val information for a given validator.

public class CheckSumValidator : 
  DataAnnotationsModelValidator{
  private string errorMessage;
  private string checkSumType;

  public RelatedDatesValidator(
      ModelMetadata metadata, ControllerContext context, CheckSumNumberAttribute attribute)
    : base(metadata, context, attribute){
     this.errorMessage = attribute.FormatErrorMessage(metadata.DisplayName);
     this.checkSumType = "checksum";
  }

  public override IEnumerable GetClientValidationRules(){
    var rule = new ModelClientValidationRule{
      ErrorMessage = this.errorMessage,
      ValidationType = this.validationType
    };

    rule.ValidationParameters.Add("checksumtype", checkSumType);
    yield return rule;
  }
}

Having defined the adapter class, it is neccesary to register the adapter with the DataAnnotationsModelValidatorProvider for the validation attribute. Global.asax is a good place to do this.

protected void Application_Start(){
    .....
  DataAnnotationsModelValidatorProvider
     .RegisterAdapter(
         typeof(CheckSumNumberAttribute>), 
         typeof(CheckSumValidator));
    .....
}

Client side code

The javascript required for the client side validation also remains the same as per the previous post, but here is it again for completeness.

var Xhalent = Xhalent || {};

Xhalent.validateABN = function (value) {

  value = value.replace(/[ ]+/g, '');

  if (!value.match(/\d{11}/)) {
    return false;
  }

  var weighting = [10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];

  var tally = (parseInt(value.charAt(0)) - 1) * weighting[0];

  for (var i = 1; i < value.length; i++) {
    tally += (parseInt(value.charAt(i)) * weighting[i]);
  }

  return (tally % 89) == 0;
};

Xhalent.validateACN = function (value) {
  value = value.replace(/[ ]+/g, '');

  if (!value.match(/\d{9}/)) {
    return false;
  }

  var weighting = [8, 7, 6, 5, 4, 3, 2, 1];
  var tally = 0;
  for (var i = 0; i < weighting.length; i++) {
    tally += (parseInt(value.charAt(i)) * weighting[i]);
  }

  var check = 10 - (tally % 10);
  check = check == 10 ? 0 : check;

  return check == parseInt(value.charAt(i));
};

//get reference to global jquery validator object and addMethod named 'xhalent_checksum'
$.validator.addMethod("xhalent_checksum", function (value, element, checksumtype) {
  if (value == null || value.length == 0) {
    return true;
  }

  if(checksumtype == 'abn') {
    return Xhalent.validateABN(value);
  }else if (checksumtype == 'acn') {
    return Xhalent.validateACN(value);
  }
});

//register the method with the unobtrusive validator library
$.validator.unobtrusive.adapters.addSingleVal('checksum', 'checksumtype', 'xhalent_checksum');

Of course, my caveats about placing this script after the dependant javascript libraries have been loaded still apply.

Conclusion

This post have demonstrated how to use Custom Unobstrusive Jquery Validation in ASP.Net MVC 3 using DataAnnotationsModelValidatorProvider instead of IClientValidatable. This is a suitable solution where it is not possible to decorate an attribute the the IClientValidatable interface or it is inappropriate to reference the MVC library from the assembly the validation attribute is defined in.

Javascript Closures

xhalent — Thu, 12 May 2011 13:07:36 +0000

Introduction

Following on from my previous article on javascript object creation and objects, arrays and associative arrays, I am now going to cover the concept of call-scope and closures in JavaScript.

Understanding scopes

In common with most languages, JavaScript has the concept of scope. Scope defines what objects are visible to a body of code at runtime. In JavaScript script the variables in scope are those in scope at the time the function was created or assigned. Variables defined in the global scope are visible to all code so long as the variable or object has been declared prior to the code in question:

 
var x = 1;

function sumFunc(y)
{   
    alert(x+y);
}

sumFunc(3);

//the value of x is visible within the function sunFunc().

JavaScript code is run in the context of a call object, which contains references to all accessible variables. Each new function or frame results in a new call object being chained onto the previous (parent) one, with the properties of the parent scope being available in the child scope. Additionally, any variables declared within the new function, and any parameters, will be properties on the child scope. If a child scope defines variables or arguments that have the same name as a property of the parent scope, they will hide the parent scope
s instance.

Examining what is going on above, when sumFunc is called, the global scope contains x. The child scope has inherited the property ‘x’ and added a new property ‘y’ which was in the parameters. When the function ends, there will be no more references to the child scope and it will be disposed of by the garbage collection. The value ‘y’ will not be available to any code. Consider if we change the code slightly:

 
var x = 1;

function sumFunc(y)
{   
    return function(){alert(x+y);};
}

var f1 = sumFunc(3);
var f2 = sumFunc(4);

f1();
f2();

If you run this code, you will get 4 and 5 displayed, respectively. What is happening is that each invocation of sumFunc results in a new instance of the nested function being created in the current scope, with their unique value of the parameter ‘y’. Exiting the function has not led to the scope being destroyed because the nested function in it’s construction attains a reference to the current scope.

Where closures are interesting is that although JavaScript does not have the concept of private variables, the use of closures can synthesize private members successfully. Consider the following script. I want to create a function that returns the next number whenever it is called.

I create a function that defines a local variable iNext and return from the function a nested function that refers back to iNext. Any function I create in this child scope will always be able to reference the value of iNext. Now when uniqueID is called, the function can reference the variable iNext because it was in scope when the function was created (it doesn’t matter if it is in scope when the function is called).

 
var uniqueID = (function(){
    var iNext = 0;   
    return function(){return iNext++;};
})();

alert(uniqueID());
alert(uniqueID());
alert(uniqueID());
alert(uniqueID());

The really interesting point is that iNext is not programmatically accessible in code. This technique can be extended to synthesize private functions. In the following script the function getSquare is not accessible through code once the self-executing function has run.

 
var uniqueID = (function(){
    var iNext = 0;   
    var iPower = 0;
    function getSquare(){
        return Math.pow(iNext,iPower);
    }
    
    return function(){return getSquare(iNext+=2, iPower++);};
})();

alert(uniqueID());
alert(uniqueID());
alert(uniqueID());
alert(uniqueID());

The closure of a function is evaluated when the function is assigned to a variable. Consider the following code. When the prototype method area is assigned to the newly created object, ‘this’ is in scope and is the object being constructed. When the function is copied into a global variable, the value of ‘this’ is evaluated again and this time it is the global window object, which does not have a value for width or height.

 
function Rect(width,height){
  this.width = width;
  this.height = height;
};

Rect.prototype = {
  area:function(){
      return this.width * this.height;     
   }
};

//create a new rect object
var rect= new Rect(10,5);

//this will output 50
alert(rect.area());

var copyOfArea = rect.area;

//this will alert NaN
alert(copyOfArea());

If we were to add two global variables width and height to the global window object, then copyOfArea would be the product of those two numbers.

It can be seen now why it is necessary to prefix all calls to properties and function for an object with the ‘this’ keyword. At the time of construction, ‘this’ is the object being constructed and all the properties relate to that instance only. That is how properties and function make up a javscript object – through the shared call context when the object is constructed.

Be aware it is important to remember that when coding event handlers that the value ‘this’ is not taken for granted. Consider the following script.

 
function MyObj(){
  this.SpecialName = "myobj";
 
    jQuery('#someButton').click(function(){        
        alert(this.SpecialName);
    });
};

var r = new MyObj();

If a button with Id “someButton” was clicked, the value of this.SpecialName would be undefined. That is because the value of “this” is different to the value of “this” when the object was created.

The correct approach for referencing an object from within a delegated function is take a local reference to “this” and have the function use it instead as below:

 
function MyObj(){
  this.SpecialName = "myobj";
   var _this = this;
    jQuery('#someButton').click(function(){        
        alert(_this.SpecialName);
    });
};

var r = new MyObj();

Conclusion

This post has covered the basics of closures in JavaScript. It was shown that functions are a combination of both the their code and the context or scope in which they are called. Interesting closures can be created by returning nested functions from functions containing local variables or methods, and in doing do private members can be synthesized. It is important to keep in mind how scopes can result in the value of “this” being overwritten in event handlers, and a safe approach under these circumstances is refer to a local reference of the “this” object prior to declaring the event handler.

A few ideas to improve NHibernate performance

xhalent — Thu, 24 Mar 2011 12:52:29 +0000

I’m currently working a project with a major focus on insert – throughput and I’d thought I mention a few things I’ve done to improve that throughout that are departures from your typical CRUD .Net application.

Don’t use identities.

They require an additional read immediately after inserting
They defeat insert batching

Use Guid.Comb instead

Creates Guids with just enough order to enable SqlServer to index effectively
Generated by NHibernate without a round trip to the server.
Enables deferment on inserts
Enables insert batching

Lock only aggregate roots and not every entity

Control entity access through repositories for each aggregate root entity.

Use pessimistic locking instead of optimistic locking (with timestamps/versions)

Using a timestamp results in an additional read after each insert or update
Defeats batching

Use a table per hierarchy instead of a table per subclass (which is the default)

A joined-subclass table strategy requires two inserts, one to the primary table and then the a second to the joined table.
Can’t be batched

Look hard at inheritance hierarchies. Batching only works for entities of the same type, so subclass entities cannot be batched with their base types. I whittled down a few classes and opted for null-properties (exposed as components) rather than subclass – you shouldn’t be building a hierarchy based on data anyway, but behaviour.
Use second level caching for reference objects. I had a few entities were really almost static in nature but need to be referenced by each inserted record. I used the HashtableCache (not really a enterprise cache) to hold these entities. I am not concerned about the cache growing out of control and growing stale, and the application is not clustered so my choice I think stands up. By caching these entities I save a lot of reads from the database.

In general what I have attempted to do is to minimise the calls the database. NHibernate batching is brilliant at this, enabling any number of commands to be issued in a single ADO batch, but it works only under certain conditions.

There were a few other ideas put to me by the local DBA which I haven;t implemented but would consider:

Drop foreign key constraints as the constraints are handled at the application layer
Don’t have a primary key on the inserting tables, rather simply have indexed columns. This would enable SqlServer to heap insert rather than B-tree inserts, which if the primary key is sequential might become problematic as the B-tree would need to rebalance.

Using CodeContracts Reference Assemblies in Client Applications

xhalent — Thu, 24 Mar 2011 12:23:36 +0000

It is useful when designing interfaces to be able to define the design-contracts for those interfaces, however because interfaces cannot contain code, CodeContracts cannot be written for them directly. Instead, contracts are defined through the of “buddy” contract abstract classes that are not really classes at all, but just place holders for the contracts in the interfaces.

Consider the simple interface below:

[ContractClass(typeof(MyServiceContracts))]
public interface IMyService{
   string Echo(string str);
}

To define a simple not null contract, we create a class as follows:

[ContractClassFor(typeof(IMyService))]
public abstract class MyServiceContracts : IMyService{
  public string Echo(string str){
    Contract.Requires(str != null);
    return null;
  } 
}

You can see that the buddy class implements the interface it is the buddy for. Because this buddy class is never intended to be referenced, the actual implementation is not important other than the contracts it defines.

To build the reference assembly, make sure you set the Contract Reference Assembly option to “Build” in the project settings, on the Code Contracts tab.

Using the Reference Assembly

There was surprisingly little information on how to actually use a reference assembly to enforce constraints on interfaces, so I created a test harness as follows:

class Program{
  public class MyServiceImpl:IMyService{
    public string Echo(string str){
      throw new NotImplementedException();
    }
  }

  static void Main(string[] args){
    IMyService service = new MyServiceImpl();

    Console.WriteLine(service.Echo(null));
  }
}

If the contracts worked and enforced at the interface level, then I should get a null argument exception thrown, else if they don’t work I would get the “NotImplementedException”.

I copied the built interfaces assembly to a separate, new folder location on my machine, leaving the CodeContracts assembly alone for now. I then added a reference to the interface assembly from my client code. When I ran the test, I did not get the contract exception. I then checked the code contracts settings for the project to make sure I was enabling full runtime checking. I then noticed that the Assembly Mode was set to “Custom Parameter Validation” so I changed it to “Standard Contract Requires”, ran the test and still got no contract exception.

I then copied the CodeContracts reference assembly from the first project to the location of the interface assembly and re-ran the test. Still no code contract exception. This was really beginning to bug me.

A burst of inspiration hit me and I re-built the client application (instead of merely re-running it) and well hello, I got the contract exception I was longing for.

I also experimented with locating the contracts reference assembly in the folder called CodeContracts in the same place as the interface assembly, and it works as well.

Conclusion

This post has covered how to use contracts reference assemblies in client applications. It is necessary to either co-locate the reference assembly where the real assembly is placed, or in a folder “CodeContracts” in that location. It is also necessary to turn on CodeContract runtime checking and use “Standard Contract Requires”, and a rebuild is required to pick up CodeContract assemblies.

EntityFramework–What’s in it for Microsoft?

xhalent — Mon, 21 Mar 2011 11:09:27 +0000

I can’t understand why Microsoft persists with the EntityFramework development. Don’t get me wrong, the project isn’t necessarily terminally flawed or anything, but what is their corporate motivation?

Can they go their shareholders and demonstrably show that development of the EntityFramework will increase the companies bottom line?

I don’t think so.

The decision on what data access strategy to use does not drive the choice of server platform or development language. Generally enterprise organisations will have an overall strategy or theme to their suite of applications, with an intention to reduce the technology footprint to maximise the opportunities for re-use both in terms of components and physical resources, including developers.

It is very unlikely, IMHO, that a project in a predominantly unix/java environment would suggest creating a Win2008 stack so that their project can use EntityFramework 4.1.

If you programming web sites hosted in a windows enterprise environment, then you’re going to use .Net (especially if you reading this). You’re not using .Net because of the EntityFramework. If the EntityFramework did not exist then you would still use .Net and host in windows servers. In fact, only a year ago when EntityFramework really, really, was the pits that was exactly what we all did.

Can you seriously imagine in the pre-EntityFramework a developer saying, “hey guys, lets do this in java and hibernate, because, you know, .Net data access is just too hard….”. But that seems like the business problem Microsoft is trying to solve, and I for one just can’t see it.

So, that brings me back to the thrust of my discussion. Microsoft are not going to sell any more licenced products because of the EntityFramework. That means they will not make a cent from it.

How big is the EntityFramework team? I’m not sure, but whatever millions of dollars a year Microsoft is spending on the development I doubt they will ever see a red cent in return.

Microsoft is not a charity. If there aren’t making a dollar from a business activity, how loyal are they going to be to it?

But it’s worse than that. Microsoft haven’t developed a great product, and by freezing development on Linq-2-Sql they’ve burnt social capital. They’ve lumbered themselves with a product that they’ve asked enterprises to trust but knowing that it doesn’t scale up to the needs of enterprises.

There’s a marketing blitz to manage. Books to write, blogs and tweets and whatever people do on Facebook. A new fleet MVP’s spruiking the latest and greatest and demonstrating, once again, how EntityFramework works if you’re designing the worlds simplest blog or dinner invite management program.

So, projects will take on EntityFramework. They might have been directed to by their bosses, or perhaps they themselves feel cosier in the warm embracing bosom of the Microsoft mother ship. They’ll send of queries to the “support” line at Microsoft wondering about specific features to be told that those features are not supported, and may never be supported, and if we did support them then it would be a scheduled release sometime in the first quarter of the next millennium. You are not going to get a special build, just for you. Are you certainly are not going to be able to compile your own version.

And when it all goes horribly wrong, when entities and contexts and states are sprinkled from the the browser to the database and all the tiers in between (oh, yes – whose ever seen a demo on n-tier implementations of the EntityFramework, and aren’t self tracking POCO objects a contradiction?) and it performs like a dog then the blame will laid at Microsoft’s feet.

I think there is every likelihood that Microsoft will stop development of EntityFramework. Just. Like. That. Wouldn’t that be a pain. Projects already coupled to EF would have a just get by. Perversely, Microsoft are not likely to loose any revenue from this decision.

Consider NHibernate as an alternative. It hasn’t got a profit motive – it is driven by the passion of those core developers and the community that picks up builds and provides feedback. No corporate backer demanding profits and revenue streams, source code free to download and wade through. By any comparison NHibernate is more feature rich than EntityFramework (a direct result of it’s maturity and pedigree). The main complaint with NHibernate is the lack of coherent documentation on all the knobs, levers and other points of extensibility that can be made use of.

I think EntityFramework is a case of corporate “Not Written Here Syndrome”, where software is written in the firm but predominantly mistaken belief that you can write something better than that other, mature product, because you’re a genius and you’re starting from scratch. We’ve all done it. But hopefully at some point we mature out of it.

I want to reflect on the fact that Microsoft supports jQuery, to the benefit of both – it certainly adds keyboard-cred to the ASP.Net MVC platform. In my opinion, Microsoft would have done everyone a favour by getting behind the NHibernate project while enhancing Linq-2-Sql for the small data access tasks.

Javascript Object Instantiation and Prototypes

xhalent — Wed, 16 Feb 2011 11:42:38 +0000

This is part of series on javascript mechanics I’m writing – mainly for my own benefit but also to help those shy server developers out there venture into the mysterious land of the ‘client side’. In my last post I covered the basics of what is a javascript object, and in my next post I am going to cover javascript closures but today I’m going to cover object construction and initialisation.

Following on from my previous post, I now want to explain javascript objects in some greater detail. In my previous post I had some script that created an object as follows:

 
var rect = new Object();

rect.width = 10;
rect.height = 30;

rect.area = function () {
    return this.width * this.height;
};

This script is invoking the Object type’s instance factory method that returns a new Object instance. This is equivalent defining a function called Object() and calling in the context of a newly created object as follows:

 
function Object(){
  return this;
}

var rect = {};

Object.apply(rect);

.....

So what is really going on here?

What the new keyword does is instantiates an empty object ({}) and calls the specified constructor function in the context of the newly created object. Once you understand this, you are well on your way to becoming a javascript legend!

So you can see that every javascript starts the same – as an empty object {}, it is what method gets called in conjunction with new keyword that defines the properties of the resultant object. To demonstrate what I mean, consider the following script:

 

var objectCount = 1; 

Object = function(){ 
  this.id = objectCount++; 
}; 

var obj = new Object(); 
//this will have a value of 1
alert(obj.id); 

var otherobj = {}; 
//this object did not get run though the object factory, so this will be undefined
alert(otherobj.id);

If you run this, obj.id will have some integer value. However otherobj.id is undefined, becuase it’s instance has not been run though the object factory. If I now do this..

 
var objectCount = 1; 

Object = function(){ this.id = objectCount++; }; 

var otherobj = {}; 
//apply the factory method in the context of the new object 

Object.apply(otherobj); 

//the object now has the property set and equal to 2 
alert(otherobj.id);

otherobj.id now has a integer value.

So to reiterate, in javascript all object are created equal. What the new operator does is to apply a factory method to the newly instantiated object.

Now we understand what a object fatcory is, we can start to create them so we get uniformly created objects. First we’ll create a Factory method for a mythical but possibly useful Rect class as follows:

 

function Rect(width,height){
  this.width = width;
  this.height = height;
  this.area = function () {
    return this.width * this.height;
  };
}

var rect= new Rect(10,5);

alert(rect.area());

var rect2 = new Rect(5,1);

alert(rect2.area());

alert(rect2.area == rect.area);

Here you’ll note the use of parameters in the constructor. Again, what the new keyword results in is the construction of an empty object {}, which is then set as the “this” context for the factory method that is called with the two parameters. If you run this script, you’ll see that the for each instance of Rect created, they both have a method area defined, but they each have their own version.

This may initially seem bizarre, but it should be remembered that functions in javascript are objects that can be assigned to properties at runtime, much like delegates in C#.

This is probably sub-optimal, so javascript has the concept of a prototype. The prototype of a constructor function is a special property of the function that is used in the object construction pipeline to initialise objects prior to their constructor being run. Each property of the prototype object is shallow copied to the new object (from my previous post, you’ll recall javascript objects are more or less associative arrays whose properties can be altered freely at runtime).

The psudeo-code for object construction then becomes

Create an empty object {}
Copy all the properties of the prototype object of the constructor function to the newly created object
Pass the object to the constructor function to perform any initialisation

Revisiting the script from above

 

function Rect(width,height){
  this.width = width;
  this.height = height;;
};

/* Add to the prototype */
Rect.prototype.area  = function () {
   return this.width * this.height;
};

var rect= new Rect(10,5);

alert(rect.area());

var rect2 = new Rect(5,1);

alert(rect2.area());

alert(rect2.area == rect.area);

When this code is run, it will be seen that both rects have the function srea and they are in fact the same function-object. This makes sense becuase when the prototype is applied, the copies of the function are by reference.

Note that the prototype of an constructor function can be altered at any point. If we re-assign the area of our rect, then new instances of rect will have a different area method to the first few instances. Changing the prototype does not affect instances of created objects.

Being objects, the popular way to define a prototype is to use object-notation. The provides for a succinct collation of each function to be assigned to the new object. The following sample demonstrates:

 

function Rect(width,height){
  this.width = width;
  this.height = height;;
};

/* Add to the prototype */
Rect.prototype = {
  area:function(){
       return this.width * this.height;
   },
   diagonal:function(){
       return Math.sqrt( Math.pow(this.width,2) + Math.pow(this.height,2) );
   }
};


var rect= new Rect(10,5);

alert(rect3.diagonal());

One thing to keep in mind when creating prototype objects is the need to reference object properties using the keyword this. This is to deal with closures, which will the topic of my next javascript in-depth topic.

Conclusion

In this post I have the fundamentals of objects and their instantiation in Javascript.

Copying Jquery Validation from one element to another

xhalent — Tue, 08 Feb 2011 11:09:30 +0000

A simple note to self about copying jquery validations on one element to another.

1. First get the validation rules pertaining to the element you want to copy from using the validation jquery extensions

var rules = $(‘#elementtocopy’).rules();

2. The get the messages that match those rules – these are in the settings object for the element. Note how element name is used, and not element id.

rules['messages'] = $(‘form’).data(‘validator’).settings["your element name, NOT id"];

3. Simply invoke the validation jquery extension on the selector that you wish to apply the rules to

$(‘#newelementid’).rules(“add”, args);

Simple eh