Techie things

Unit testing a Powershell Commandlet

2013-04-17T15:27:00.000+02:00

I chose to write Powershell commandlets in C#. I created a class library (DLL) project and inherited a class from Cmdlet base class. I created a snapin class derived from PSSnapIn to be able to install my commandlets from powershell.

Unit testing

Writing a unit test

    [TestClass]
    public class UnitTest1
    {
        private static RunspaceConfiguration config;
        private static Runspace runspace;
        private static Pipeline pipe;
        private static Command command;

        [ClassInitialize]
        public static void TestFixtureSetup(TestContext context)
        {
            config = RunspaceConfiguration.Create();

            PSSnapInException warning;
            config.AddPSSnapIn("SnapinName", out warning);

            runspace = RunspaceFactory.CreateRunspace(config);
            runspace.Open();
        }

        [ClassCleanup]
        public static void TestFixtureTeardown()
        {
            runspace.Close();
        }

        [TestInitialize]
        public void Setup()
        {
            pipe = runspace.CreatePipeline();
            command = new Command("CommandName");
            pipe.Commands.Add(command);
        }

        [TestMethod]
        public void TestMethod1()
        {
            command.Parameters.Add(new CommandParameter("ParameterName", "Value"));

            var psObject = pipe.Invoke();
        }
    }

Snapin couldn't be found

I wrote a unit test against one of my commands but it couldn't find my snapin, I got the following exception:

System.Management.Automation.PSArgumentException: System.Management.Automation.PSArgumentException: The Windows PowerShell snap-in '...' is not installed on this computer..

I could use my snapin from Powershell command line.

Solution

Add the following lines as post-build events:

c:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe $(TargetPath)
c:\Windows\Microsoft.NET\Framework\v4.0.30319\InstallUtil.exe $(TargetPath)

Both 32-bit and 64-bit installation will happen this way.

Cause

Visual Studio 2012 is a 32-bit process. I registered with 64-bit install util only. Now I register both versions.

XAML Resource Loading

2013-04-15T16:21:00.000+02:00

Visual Studio 2012 kept locking my .DLLs. It happened mostly after starting a debugger session. I could trace back the problem to a GetManifestResourceStream() call.

Solution

This is my solution that seems to be working:

public Stream GetResourceStreamByType(Type type, string resourceName)
{
  var location = Assembly.GetAssembly(type).Location;
  var assemblyBytes = File.ReadAllBytes(location);

  var appDomain = AppDomain.CreateDomain("Resource domain");
  var assembly = appDomain.Load(assemblyBytes);

  return assembly.GetManifestResourceStream(resourceName);
}

public BitmapImage GetBitmapByType(Type type, string resourceName)
{
  var bmp = new BitmapImage();
  using (var source = GetResourceStreamByType(type, resourceName))
  {
    bmp.BeginInit();
    bmp.StreamSource = source;
    bmp.EndInit();
  }

  return bmp;
}

Reasons

Loading the resource by calling the GetManifestResourceStream() on the current assembly loads the assembly into the debugger's app domain which is Visual Studio in this case. Reading the bytes and loading them manually prevents this behavior.

I couldn't reload the form again after loading the resources this way so I had to create a separate app domain as well. Without separate app domain the assembly was already loaded and the reloading didn't happen with an error message like 'does not have a resource identified by the URI'.

Ember–Handlebars.helpers in Windows 8 Metro

2012-09-04T13:02:00.001+02:00

I tried to use Ember.js Handlebars helper {{action}} in a Windows 8 Metro (Windows Store) application. The data marker attribute appeared, but the function was never called.

I managed to find the root cause: Ember.js uses jQuery.ready() for initialization.

Solution

Change

waitForDOMContentLoaded: function() {
    this.deferReadiness();

    var self = this;
    this.$().ready(function() {
      self.advanceReadiness();
    });
  },

waitForDOMContentLoaded: function() {
    this.deferReadiness();

    var self = this;
      
    WinJS.Application.addEventListener("ready", function () {
        self.advanceReadiness();
    });

  },

and comment out 2 lines as shown below:

advanceReadiness: function() {
    this._readinessDeferrals--;

    //if (this._readinessDeferrals === 0) {
      Ember.run.once(this, this.didBecomeReady);
    //}
  },

Now you will use the Metro infrastructure for events.

Handlebars and Ember templating in Window 8 Metro

2012-09-02T20:10:00.001+02:00

Handlebars uses script blocks for template markup. E.g.

<script type="text/x-handlebars" data-template-name="say-hello">
      Hello, <b>{{MyApp.name}}</b>
</script>

Unfortunately the Metro JavaScript engine removes the data-template-name attribute from the script tag, so this method can’t be used for templating.

As JS files are available locally for execution, the template files can be stored in separate HTML files and can be parsed from code. The implementation is simple:

        

Windows.ApplicationModel.Package.current.installedLocation.getFolderAsync(path).done(function(folder) {
    var search = folder.createFileQuery(Windows.Storage.Search.CommonFileQuery.orderByName);
                search.getFilesAsync().done(function (res) {
                        res.forEach(function (file) {
                                var template;
                                Windows.Storage.FileIO.readTextAsync(file).then(function(fileContent) {
                                       var template = Ember.Handlebars.compile(fileContent);
                                       Ember.TEMPLATES[file.displayName] = template;
[…]

I omitted the async promises from the code for readability, but the code won’t work without them.

The code above

reads all the files from a folder
compiles the template
stores the compiled template as an Ember template

Now Ember.js and Handlebars.js are fully functional, even Ember.View can be used with view.append().

Digital TV Experience

2012-09-01T12:55:00.001+02:00

I have some experience with a Samsung smart TV I will summarize here.

TV

I have access to analog TV signal, and I must tell you this is not what a digital TV was made for. It’s acceptable, but

the image is not sharp, thanks to the low resolution
the aspect ratio of the picture (aka picture size) changes among channels, or even between programs
the TV tries to enhance the quality of the image (e.g. sharpens the edges at still images), and sometimes that can be annoying
no electronic program guide (EPG)

I tried to receive DVB-T signal but I couldn’t. Just a few channels with long breaks in receiving. Though the image quality was wonderful and I got EPG.

Teletext

Teletext comes with the channels supporting this technology. It is the shadow of the analog era. Digital TVs try to enhance this technology:

store pages in memory, no need to wait for paging
more txt display modes

Don’t expect too much from this.

Multimedia

Digital TVs support a standard protocol (DLNA) for receiving multimedia streams from other devices. Just put the two devices onto the same subnet of your LAN (use the same router with cable or Wi-Fi) and the two devices will see each other. In my case I run a Samsung AllShare DLNA server on my desktop computer and

I can select the movie I want to play from the TV’s menu
I can start playing the movie on my TV pressing a button on my computer using AllShare or Windows Media Player.

Smartphones have the same capabilities. Moreover

I can start playing a movie on the TV from my computer pressing a button on my smart phone
I can control the TV from the smart phone as a TV remote (needs special app on your phone)

You can by a NAS with DLNA support and you will have an always online media server without noisy fans.

HDMI

Connecting a HDMI cable to the TV and the computer, means the computer’s desktop can be displayed on the TV, in excellent quality.

Even the sound can be redirected to the TV’s speakers or sound system. Just open the sound playback devices and set the TV as the default sound device.

If your TV supports HDMI Ethernet channel, you can use your TV as a(n Internet) router for multimedia device (blue-ray player etc.).

Smart features

I have access to a Samsung smart TV. It has an Internet browser and apps can be downloaded from a store. There are some useful apps like online radio and TV channel guide, but the most useful app is the Internet browser. It has Flash support and loads most of the websites I tried to visit.

For better experience I suggest you to buy a wireless keyboard and mouse. There are multimedia keyboards combining these devices into a small device just like a game controller.

Require JS with Win 8 Metro interface

2012-08-31T16:21:00.001+02:00

Require.js works with Windows 8 Metro-style (Windows Store) applications.

Page scripts

There is a JavaScript file for each HTML page files. You cannot wrap this .js file into a require function. The page events (e.g. the ready event) won’t be called.

You can place a require call into the event handler function and that works.

Git: create a tag on a (remote) branch

2012-04-12T11:14:00.001+02:00

You can create a tag on the local branch and you must push the tag to the remote.

Command line

> git tag …

> git push --tags

TortoiseGit

Create tag

set tag name
set tag/branch/version
enter message

Sync/Push

Select Push tags instead of Push button in the dropdown

Git Extensions

Browse
Right click on the commit log you want to tag
Select Create new tag
Enter data
Push

Select Push tags tab

Hate JavaScript?

2012-02-10T17:21:00.001+01:00

Do you hate JavaScript? Well, I have bad news. There are still no alternatives in the web browsers.

I develop ASP.NET (MVC) –based web applications, and I must use JavaScript. What’s the big difference between the modern web applications and websites from a few years ago? Well, the server-side/client-side ratio. A few years ago I was happy coding on server-side. I did as much as I could do in C#, in ASP.NET. I did learn JavaScript but I avoided it as much as I could (so I never knew it well enough).

Now you can’t avoid JavaScript anymore. More and more code is on client-side. More and more business logic and architectural challenges are on client-side, right in the browser. I’ve written database-like features and even messaging systems in JavaScript. That challenge reminds me the early days of other languages. Missing features, missing language support, missing best practices, missing design patterns. Pure greenfield tasks.

How well do you speak JavaScript? A few years ago it was enough to understand how to define a function and some variables. Learn how DOM works. How different DOMs work. That’s not a small thing if you did it well. But did we write good, quality code with low bug ratio and good manageability? I’d say no.

A few years later there came the object-oriented world to JavaScript. We, I personally, had to learn the idea behind prototype-based languages. That’s a hard step with a ‘real’ object-oriented (Java, C#, C++) mindset. How can I implement inheritance? How can I hide data? How can I achieve polymorphism? Tough questions. Luckily along came design patterns. There are even a few books on the topic in JavaScript. Still, it’s not easy. I personally can recite 4-5 inheritance patterns. There are at least 2 data hiding patterns I can recall right now.

Well, many options, with their own drawbacks. It’s not easy to choose, e.g. at the beginning of a new project. There is no universal solution. There is no good solution. You have to consider the tasks you have to do with your object model and the knowledge level of the colleagues. Usually the later is harder. How much knowledge people have about JavaScript in e.g. Java/C# world? As much as they get along the projects. They teach each other. To good and bed. What I saw in the last years, mostly obsolete and sometimes bad. Not easy to show them the current trends and solutions. Or may I say, contemporary engineering practices. People can, and usually are, be very proud of their coding style, quality, cleverness, etc. How can they be so neglect on these in an other language, e.g. JavaScript?

Now there are frameworks for DOM manipulation (jQuery, dojo, YUI), for common tasks (Underscore, YUI, Closure), and there are architectural frameworks (Knockout, Backbone) as well. As you can see, they are fractured and you must use different frameworks for different tasks. You should choose well because it’s very very hard to change frameworks, and you have to watch out for compatibility. Framework version changes represent huge risk in the lifetime of a project. Even a minor version change can render your web application totally useless. So test heavily.

No we have two ways. Full manual testing with a lot of humans. Or follow the ‘new’ trend and use some kind of automated test frameworks (Selenium, Watir). If they work the way you think. If it’s not more time to maintain your tests than execute them manually.

The same applies to unit tests. There are various frameworks in different flavors (xUnit, BDD, etc.) with different capabilities and APIs. Some live long, some live short. Choose well. Update regularly. Follow the news, trends.

Well, I chose a unit testing framework. Now I should test my code. How? It produces HTML into the DOM and calculates things according to different business rules – in the same function. Well, good luck. Try separating your business logic from visual stuff. Rings the bell? MVC? MVVM? Well, I’d say Knockout and Backbone. I’d say use (revealing) module pattern for your view model and your rendering as well. Separate them. Use a framework, e.g. Require.js. If you do it good, you can even get rid of the inheritance and other OO problems. Now you can test your business logic separated from the UI.

Next problem: I have a dynamic AJAX (AJAJ - Asynchronous Javascript and JSON) application calling back to the server. That’s not good. Let’s spy. Let’s stub. Let’s mock. Find a framework, I chose Sinon.

So, let’s summarize. I do my job well if I know functions, variables, OO patterns, DOM frameworks, task frameworks, architectural frameworks, testing frameworks, module patterns, JavaScript mocking frameworks. Is that enough?

I have bed news. We in the web world develop applications like C++ coders develop applications for Windows, Linux, BSD… at the same time with the same code base. Instead of OSs, we have browsers and JavaScript standard versions. Now we have mobile devices as well, with different kind of browsers. So keep up, learn and write code in JavaScript. It’s better to learn and understand it than hope for surviving it. The next few years are about JavaScript and the Web. Get used to it, accept it. Do it as good as you do your job on server-side.

jQuery div vs native doc fragment

2012-01-19T09:24:00.001+01:00

I assumed creating a div with jQuery takes more time compared to native document fragment creation. Surprise, I was wrong. I’ve created a test page on JSPerf at http://jsperf.com/jquery-vs-documentfragment. Simply put, the speed depends on the browser.

Verdict: Use document fragment in all browsers except Internet Explorer. In general, use document fragment:

document.createDocumentFragment();

Less CSS and IIS 7

2011-11-14T13:11:00.001+01:00

In case you are using Less CSS to generate CSS markups, IIS won’t find your .less files by default. You will get a 404 Not Found error. The problem is the missing MIME type.

The solution is simple, just register the MIME type for .less in web.config:

<system.webServer>
  <staticContent>
    <mimeMap fileExtension=".less" mimeType="text/css"/>
  </staticContent>
</system.webServer>

ASP.NET MVC Internals 3: Controller structure

2011-09-18T20:47:00.001+02:00

Controllers implement the IController interface:

public interface IController 
{
    void Execute(RequestContext requestContext);
}

ControllerBase abstract class implements the IController interface:

public abstract class ControllerBase : MarshalByRefObject, IController 
{

    private TempDataDictionary _tempDataDictionary;
    private bool _validateRequest = true;
    private IDictionary<string, ValueProviderResult> _valueProvider;
    private ViewDataDictionary _viewDataDictionary;

    public ControllerContext ControllerContext {
        get;
        set;
    }

    public TempDataDictionary TempData {
        get {
            if (_tempDataDictionary == null) {
                _tempDataDictionary = new TempDataDictionary();
            }
            return _tempDataDictionary;
        }
        set {
            _tempDataDictionary = value;
        }
    }

    public bool ValidateRequest {
        get {
            return _validateRequest;
        }
        set {
            _validateRequest = value;
        }
    }

    public IDictionary<string, ValueProviderResult> ValueProvider {
        get {
            if (_valueProvider == null) {
                _valueProvider = new ValueProviderDictionary(ControllerContext);
            }
            return _valueProvider;
        }
        set {
            _valueProvider = value;
        }
    }

    public ViewDataDictionary ViewData {
        get {
            if (_viewDataDictionary == null) {
                _viewDataDictionary = new ViewDataDictionary();
            }
            return _viewDataDictionary;
        }
        set {
            _viewDataDictionary = value;
        }
    }

    protected virtual void Execute(RequestContext requestContext) {
        if (requestContext == null) {
            throw new ArgumentNullException("requestContext");
        }

        Initialize(requestContext);
        ExecuteCore();
    }

    protected abstract void ExecuteCore();

    protected virtual void Initialize(RequestContext requestContext) {
        ControllerContext = new ControllerContext(requestContext, this);
    }
    
    [...]
}

The Controller class derives from ControllerBase abstract class:

public abstract class Controller : ControllerBase, IActionFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter {

    private IActionInvoker _actionInvoker;
    private ModelBinderDictionary _binders;
    private RouteCollection _routeCollection;
    private ITempDataProvider _tempDataProvider;

    public IActionInvoker ActionInvoker {
        get {
            if (_actionInvoker == null) {
                _actionInvoker = new ControllerActionInvoker();
            }
            return _actionInvoker;
        }
        set {
            _actionInvoker = value;
        }
    }

    protected internal ModelBinderDictionary Binders {
        get {
            if (_binders == null) {
                _binders = ModelBinders.Binders;
            }
            return _binders;
        }
        set {
            _binders = value;
        }
    }

    public HttpContextBase HttpContext {
        get {
            return ControllerContext == null ? null : ControllerContext.HttpContext;
        }
    }

    public ModelStateDictionary ModelState {
        get {
            return ViewData.ModelState;
        }
    }

    public HttpRequestBase Request {
        get {
            return HttpContext == null ? null : HttpContext.Request;
        }
    }

    public HttpResponseBase Response {
        get {
            return HttpContext == null ? null : HttpContext.Response;
        }
    }

    internal RouteCollection RouteCollection {
        get {
            if (_routeCollection == null) {
                _routeCollection = RouteTable.Routes;
            }
            return _routeCollection;
        }
        set {
            _routeCollection = value;
        }
    }

    public RouteData RouteData {
        get {
            return ControllerContext == null ? null : ControllerContext.RouteData;
        }
    }

    public HttpServerUtilityBase Server {
        get {
            return HttpContext == null ? null : HttpContext.Server;
        }
    }

    public HttpSessionStateBase Session {
        get {
            return HttpContext == null ? null : HttpContext.Session;
        }
    }

    public ITempDataProvider TempDataProvider {
        get {
            if (_tempDataProvider == null) {
                _tempDataProvider = new SessionStateTempDataProvider();
            }
            return _tempDataProvider;
        }
        set {
            _tempDataProvider = value;
        }
    }

    public UrlHelper Url {
        get;
        set;
    }

    public IPrincipal User {
        get {
            return HttpContext == null ? null : HttpContext.User;
        }
    }

    [...]

    protected internal virtual ContentResult Content(string content, string contentType, Encoding contentEncoding) {
        return new ContentResult {
            Content = content,
            ContentType = contentType,
            ContentEncoding = contentEncoding
        };
    }

    [...]

    protected override void ExecuteCore() {
        TempData.Load(ControllerContext, TempDataProvider);

        try {
            string actionName = RouteData.GetRequiredString("action");
            if (!ActionInvoker.InvokeAction(ControllerContext, actionName)) {
                HandleUnknownAction(actionName);
            }
        }
        finally {
            TempData.Save(ControllerContext, TempDataProvider);
        }
    }

    [...]

    protected internal virtual FilePathResult File(string fileName, string contentType, string fileDownloadName) {
        return new FilePathResult(fileName, contentType) { FileDownloadName = fileDownloadName };
    }

    protected virtual void HandleUnknownAction(string actionName) {
        throw new HttpException(404, String.Format(CultureInfo.CurrentUICulture,
            MvcResources.Controller_UnknownAction, actionName, GetType().FullName));
    }

    protected internal virtual JavaScriptResult JavaScript(string script) {
        return new JavaScriptResult { Script = script };
    }

    [...]

    protected internal virtual JsonResult Json(object data, string contentType, Encoding contentEncoding) {
        return new JsonResult {
            Data = data,
            ContentType = contentType,
            ContentEncoding = contentEncoding
        };
    }

    protected override void Initialize(RequestContext requestContext) {
        base.Initialize(requestContext);
        Url = new UrlHelper(requestContext);
    }

    protected virtual void OnActionExecuting(ActionExecutingContext filterContext) {
    }

    protected virtual void OnActionExecuted(ActionExecutedContext filterContext) {
    }

    protected virtual void OnAuthorization(AuthorizationContext filterContext) {
    }

    protected virtual void OnException(ExceptionContext filterContext) {
    }

    protected virtual void OnResultExecuted(ResultExecutedContext filterContext) {
    }

    protected virtual void OnResultExecuting(ResultExecutingContext filterContext) {
    }

    [...]

    protected internal PartialViewResult PartialView(string viewName) {
        return PartialView(viewName, null /* model */);
    }

    protected internal virtual PartialViewResult PartialView(string viewName, object model) {
        if (model != null) {
            ViewData.Model = model;
        }

        return new PartialViewResult {
            ViewName = viewName,
            ViewData = ViewData,
            TempData = TempData
        };
    }

    protected internal virtual RedirectResult Redirect(string url) {
        [...]
        return new RedirectResult(url);
    }

    protected internal RedirectToRouteResult RedirectToAction(string actionName) {
        return RedirectToAction(actionName, (RouteValueDictionary)null);
    }

    [...]

    protected internal virtual RedirectToRouteResult RedirectToAction(string actionName, string controllerName, RouteValueDictionary routeValues) {
        RouteValueDictionary mergedRouteValues;

        if (RouteData == null) {
            mergedRouteValues = RouteValuesHelpers.MergeRouteValues(actionName, controllerName, null, routeValues, true /* includeImplicitMvcValues */);
        }
        else {
            mergedRouteValues = RouteValuesHelpers.MergeRouteValues(actionName, controllerName, RouteData.Values, routeValues, true /* includeImplicitMvcValues */);
        }

        return new RedirectToRouteResult(mergedRouteValues);
    }

    [...]

    protected internal RedirectToRouteResult RedirectToRoute(string routeName) {
        return RedirectToRoute(routeName, (RouteValueDictionary)null);
    }

    [...]

    protected internal bool TryUpdateModel<TModel>(TModel model) where TModel : class {
        return TryUpdateModel(model, null, null, null, ValueProvider);
    }

    [...]

    protected internal bool TryUpdateModel<TModel>(TModel model, string prefix, string[] includeProperties, string[] excludeProperties, IDictionary<string, ValueProviderResult> valueProvider) where TModel : class {
        [...]

        Predicate<string> propertyFilter = propertyName => BindAttribute.IsPropertyAllowed(propertyName, includeProperties, excludeProperties);
        IModelBinder binder = Binders.GetBinder(typeof(TModel));

        ModelBindingContext bindingContext = new ModelBindingContext() {
            Model = model,
            ModelName = prefix,
            ModelState = ModelState,
            ModelType = typeof(TModel),
            PropertyFilter = propertyFilter,
            ValueProvider = valueProvider
        };
        binder.BindModel(ControllerContext, bindingContext);
        return ModelState.IsValid;
    }

    protected internal void UpdateModel<TModel>(TModel model) where TModel : class {
        UpdateModel(model, null, null, null, ValueProvider);
    }

    [...]

    protected internal void UpdateModel<TModel>(TModel model, string prefix, string[] includeProperties, string[] excludeProperties, IDictionary<string, ValueProviderResult> valueProvider) where TModel : class {
        bool success = TryUpdateModel(model, prefix, includeProperties, excludeProperties, valueProvider);
        if (!success) {
            string message = String.Format(CultureInfo.CurrentUICulture, MvcResources.Controller_UpdateModel_UpdateUnsuccessful,
                typeof(TModel).FullName);
            throw new InvalidOperationException(message);
        }
    }

    protected internal ViewResult View() {
        return View(null /* viewName */, null /* masterName */, null /* model */);
    }

    protected internal ViewResult View(object model) {
        return View(null /* viewName */, null /* masterName */, model);
    }

    protected internal ViewResult View(string viewName) {
        return View(viewName, null /* masterName */, null /* model */);
    }

    protected internal ViewResult View(string viewName, string masterName) {
        return View(viewName, masterName, null /* model */);
    }

    protected internal ViewResult View(string viewName, object model) {
        return View(viewName, null /* masterName */, model);
    }

    protected internal virtual ViewResult View(string viewName, string masterName, object model) {
        if (model != null) {
            ViewData.Model = model;
        }

        return new ViewResult {
            ViewName = viewName,
            MasterName = masterName,
            ViewData = ViewData,
            TempData = TempData
        };
    }

    protected internal ViewResult View(IView view) {
        return View(view, null /* model */);
    }

    protected internal virtual ViewResult View(IView view, object model) {
        if (model != null) {
            ViewData.Model = model;
        }

        return new ViewResult {
            View = view,
            ViewData = ViewData,
            TempData = TempData
        };
    }

    #region IActionFilter Members
    void IActionFilter.OnActionExecuting(ActionExecutingContext filterContext) {
        OnActionExecuting(filterContext);
    }

    void IActionFilter.OnActionExecuted(ActionExecutedContext filterContext) {
        OnActionExecuted(filterContext);
    }
    #endregion

    #region IAuthorizationFilter Members
    void IAuthorizationFilter.OnAuthorization(AuthorizationContext filterContext) {
        OnAuthorization(filterContext);
    }
    #endregion

    #region IExceptionFilter Members
    void IExceptionFilter.OnException(ExceptionContext filterContext) {
        OnException(filterContext);
    }
    #endregion

    #region IResultFilter Members
    void IResultFilter.OnResultExecuting(ResultExecutingContext filterContext) {
        OnResultExecuting(filterContext);
    }

    void IResultFilter.OnResultExecuted(ResultExecutedContext filterContext) {
        OnResultExecuted(filterContext);
    }
    #endregion
}

The Controller class implements the ExecuteCore() function. It sets the TempData to make it available during the action method execution. The method reads the action name from the RouteData and calls the action method, identified by the recently read name, using the ActionInvoker.InvokeAction() method.
All the usually used helper methods such as View(), UpdateModel(), File(), Json() are defined by the Controller class.

Link: ASP.NET MVC – Controller inheritance

ASP.NET MVC Internals 2: Controller

2011-09-17T18:42:00.001+02:00

The MvcHandler class processes an HTTP request. The routing framework calls its ProcessRequest() function in case of an incoming request matching an MVC route.

public class MvcHandler : IHttpHandler, IRequiresSessionState 
{
    [...]
    protected internal virtual void ProcessRequest(HttpContextBase httpContext) 
    {
        AddVersionHeader(httpContext);

        // Get the controller type
        string controllerName = RequestContext.RouteData.GetRequiredString(&quot;controller&quot;);

        // Instantiate the controller and call Execute
        IControllerFactory factory = ControllerBuilder.GetControllerFactory();
        IController controller = factory.CreateController(RequestContext, controllerName);
        if (controller == null) {
            throw new InvalidOperationException(
                String.Format(
                    CultureInfo.CurrentUICulture,
                    MvcResources.ControllerBuilder_FactoryReturnedNull,
                    factory.GetType(),
                    controllerName));
        }
        try {
            controller.Execute(RequestContext);
        }
        finally {
            factory.ReleaseController(controller);
        }
    }
    [...]
}

Firstly it reads the controller name from the routing data and after that it creates a controller by the name read before. Finally it calls the Execute method of the controller to run the controller’s code.

The ControllerBuilder is a factory for creating the controller instance.

public class ControllerBuilder 
{
    [...]
    private Func<IControllerFactory> _factoryThunk;

    public ControllerBuilder() 
    {
        SetControllerFactory(new DefaultControllerFactory() {
            ControllerBuilder = this
        });
    }

    [...]
    public IControllerFactory GetControllerFactory() {
        IControllerFactory controllerFactoryInstance = _factoryThunk();
        return controllerFactoryInstance;
    }

    public void SetControllerFactory(IControllerFactory controllerFactory) 
    {
        if (controllerFactory == null) {
            throw new ArgumentNullException("controllerFactory");
        }

        _factoryThunk = () => controllerFactory;
    }
    [...]
}

The constructor of the class at line 8 calls the SetControllerFactory method with a DefaultControllerFactory instance. Thus the DefaultControllerFactory class will look up and call the controller with the name provided by the RouteData.

public class DefaultControllerFactory : IControllerFactory 
{
    private IBuildManager _buildManager;
    private ControllerBuilder _controllerBuilder;
    private ControllerTypeCache _instanceControllerTypeCache;
    private static ControllerTypeCache _staticControllerTypeCache = new ControllerTypeCache();

    [...]

    public virtual IController CreateController(RequestContext requestContext, string controllerName) 
    {
        [...]
        RequestContext = requestContext;
        Type controllerType = GetControllerType(controllerName);
        IController controller = GetControllerInstance(controllerType);
        return controller;
    }

    protected internal virtual IController GetControllerInstance(Type controllerType) 
    {
        [...]
        try {
            return (IController)Activator.CreateInstance(controllerType);
        }
        catch (Exception ex) {
            throw new InvalidOperationException(
                String.Format(
                    CultureInfo.CurrentUICulture,
                    MvcResources.DefaultControllerFactory_ErrorCreatingController,
                    controllerType),
                ex);
        }
    }

    protected internal virtual Type GetControllerType(string controllerName) 
    {
        [...]

        // first search in the current route's namespace collection
        object routeNamespacesObj;
        Type match;
        [...]

        // then search in the application's default namespace collection
        [...]

        // if all else fails, search every namespace
        return GetControllerTypeWithinNamespaces(controllerName, null /* namespaces */);
    }

    private Type GetControllerTypeWithinNamespaces(string controllerName, HashSet<string> namespaces) 
    {
        // Once the master list of controllers has been created we can quickly index into it
        ControllerTypeCache.EnsureInitialized(BuildManager);

        IList<Type> matchingTypes = ControllerTypeCache.GetControllerTypes(controllerName, namespaces);
        switch (matchingTypes.Count) {
            case 0:
                // no matching types
                return null;

            case 1:
                // single matching type
                return matchingTypes[0];

            default:
                // multiple matching types
                // we need to generate an exception containing all the controller types
                StringBuilder sb = new StringBuilder();
                foreach (Type matchedType in matchingTypes) {
                    sb.AppendLine();
                    sb.Append(matchedType.FullName);
                }
                throw new InvalidOperationException([...]);
        }
    }

}

As soon as the DefaultControllerFactory.CreateController function, it finds the type of the controller by its name and creates an instance after that. The framework uses the ControllerTypeCache class to find the controller types.

internal sealed class ControllerTypeCache 
{
    [...]

    public void EnsureInitialized(IBuildManager buildManager) 
    {
        if (_cache == null) {
            lock (_lockObj) {
                if (_cache == null) {
                    List<Type> controllerTypes = GetAllControllerTypes(buildManager);
                    [...]
                }
            }
        }
    }

    private static List<Type> GetAllControllerTypes(IBuildManager buildManager) 
    {
        // Go through all assemblies referenced by the application and search for
        // controllers and controller factories.
        List<Type> controllerTypes = new List<Type>();
        ICollection assemblies = buildManager.GetReferencedAssemblies();
        foreach (Assembly assembly in assemblies) {
            Type[] typesInAsm;
            try {
                typesInAsm = assembly.GetTypes();
            }
            catch (ReflectionTypeLoadException ex) {
                typesInAsm = ex.Types;
            }
            controllerTypes.AddRange(typesInAsm.Where(IsControllerType));
        }
        return controllerTypes;
    }

    [...]

    internal static bool IsControllerType(Type t) {
        return
            t != null &&
            t.IsPublic &&
            t.Name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase) &&
            !t.IsAbstract &&
            typeof(IController).IsAssignableFrom(t);
    }
}

The ControllerTypeCache.EnsureInitialized (called by DefaultControllerFactory.GetControllerTypeWithinNamespaces) uses the BuildManager class (in MVC, wrapped by BuildManagerWrapper that implements the internal IBuildManager interface) to find the available assemblies. The ControllerTypeCache.GetAllControllerTypes returns the controller types referenced by the project. A class is a controller type if the class is

public
its name ends with “Controller”, casing is ignored
the type is not abstract
the type “implements” (can be assigned to) the IController interface.

Finally the DefaultControllerFactory.GetControllerInstance creates the instance for the Type using Activator.CreateInstance() method. Now we have the controller instance to work with.
The MvcHandler.ProcessRequest() calls the controller.Execute() to run the controller code.

Link: ASP.NET MVC – Finding the controller

ASP.NET MVC Internals 1: Bootstrapping

2011-09-15T10:11:00.001+02:00

The topic of this article is the ASP.NET MVC bootstrapping process.

Everything starts in Global.asax:

public class MvcApplication : System.Web.HttpApplication
{
    public static void RegisterRoutes(RouteCollection routes)
    {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

        routes.MapRoute(
            "Default",                                              // Route name
            "{controller}/{action}/{id}",                           // URL with parameters
            new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
        );

    }

    protected void Application_Start()
    {
        RegisterRoutes(RouteTable.Routes);
    }
}

This code initializes the ASP.NET Routing framework. The MapRoute() function is an extension method, defined in RouteCollectionExtensions.cs. It’s code is simple:

public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces) {
	if (routes == null) {
		throw new ArgumentNullException("routes");
	}
	if (url == null) {
		throw new ArgumentNullException("url");
	}

	Route route = new Route(url, new MvcRouteHandler()) {
		Defaults = new RouteValueDictionary(defaults),
		Constraints = new RouteValueDictionary(constraints)
	};

	if ((namespaces != null) && (namespaces.Length > 0)) {
		route.DataTokens = new RouteValueDictionary();
		route.DataTokens["Namespaces"] = namespaces;
	}

	routes.Add(name, route);

	return route;
}

Simply creates a route with an MvcRouteHandler at line 9. ASP.NET MVC registers this routing handler to catch the routing requests (MvcRouteHandler.cs):

namespace System.Web.Mvc {
    using System.Web.Routing;

    public class MvcRouteHandler : IRouteHandler {
        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext) {
            return new MvcHandler(requestContext);
        }

        #region IRouteHandler Members
        IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext) {
            return GetHttpHandler(requestContext);
        }
        #endregion
    }
}

This code registers the MvcHandler class (MvcHandler.cs) for handling MVC routing requests:

public class MvcHandler : IHttpHandler, IRequiresSessionState 
{ [...] }

The class implements the IHttpHandler interface from System.Web.dll to be able to ‘synchronously process HTTP Web requests using custom HTTP handlers’. This interface has only one method:

void ProcessRequest(httpContext context)

The implementation of this method will handle the HTTP request. It builds up the MVC infrastructure and calls the appropriate classes (in transitive way) to select the controller, find the action method and do all the related functionality.

Link: ASP.MET MVC Bootstrapping process

jQuery and DOM dimension measurement

2010-12-12T18:34:00.001+01:00

I had to rewrite a code that used standard DOM functions (like offsetWidth) to jQuery functions (like outerWidth).
This is a simple document visually summarizing the differences.

Link: jQuery HMTL with height cheat sheet (DOCX)
Link: jQuery HMTL with height cheat sheet (PDF)

WaitableTimer in C++

2010-11-22T21:54:00.001+01:00

This is an example code for calling a waitable timer. This is a good way to wait for a timer event without using CPU (thread blocks). There is a small trick in the code. It’s hard to create a FILETIME properly so I create a SYSTEMTIME (and set it according to my needs), convert it to FILETIME, finally I cast that to LARGE_INTEGER* (to fulfill the needs of SetWaitableTimer).

I set the timer to autoreset, so it will restart counting after firing the event (counts again and again). The first event (“CALLED”) occurs after 3 secs, the subsequent events occur after 2 secs.

The WaitForSingleObject blocks until a timer event is fired. I break the loop after 5 events, stop the timer and delete the timer handle.

stdafx.h

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>
#include <iostream>
#include <Windows.h>

using namespace std;

WaitableTimer.cpp

#include "stdafx.h"

int _tmain(int argc, _TCHAR* argv[])
{
    int count = 0;    // Iteration counter

    HANDLE hTimer = NULL;    // WaitableTimer handle
    hTimer = CreateWaitableTimer(    // Create waitable timer
        NULL,
        FALSE,    // Autoreset --> timer restarts counting after event fired
        NULL);

    SYSTEMTIME time;        // System time structure
    GetSystemTime(&time);    // Curren time
    time.wSecond += 3;        // Wait 3 sec

    FILETIME ftime;    // File time (expected by SetWaitableTimer)
    SystemTimeToFileTime(&time, &ftime);    // Convert system to file time


    if(!SetWaitableTimer(    // Set waitable timer
        hTimer,    // Timer handle
        reinterpret_cast<LARGE_INTEGER*>(&ftime),    // Convert file time to large integer
        2000,    // Period time, fire again after 2 sec
        NULL,
        NULL,
        0))
    {
            cout << "SetWaitableTimer failed" <<  GetLastError() << endl;
    };

    
    while(WaitForSingleObject(hTimer, 5000) == WAIT_OBJECT_0){    // Wait for timer event
        cout << "CALLED " << ++count << endl;
        if(count+1 > 5){    // Exit after 5 events
            break;
        }
    }
        
    CancelWaitableTimer(hTimer);    // Stop timer
    CloseHandle(hTimer);            // Delete handle

    return 0;
}

See source code: http://code.google.com/p/artur02/source/browse/trunk/CPP/WaitableTimer/WaitableTimer.cpp

Waitable timer objects: http://msdn.microsoft.com/en-us/library/ms687012(VS.85).aspx
CreateWaitableTimer function: http://msdn.microsoft.com/en-us/library/ms682492(v=VS.85).aspx
SetWaitableTimer function: http://msdn.microsoft.com/en-us/library/ms686289(v=VS.85).aspx
Systemtime structure: http://msdn.microsoft.com/en-us/library/ms687008(v=VS.85).aspx
Usage example: http://msdn.microsoft.com/en-us/library/ms687008(v=VS.85).aspx

Perforce file exclusion

2010-11-06T12:03:00.001+01:00

There are file types and folders I don’t want to see in a source control repository. These are user-specific settings, temporary folders and binaries. There is a simple client-side way to exclude these files and folders. Just add the following lines to your workspace definition:

Pattern	Description
-//depot/.../.suo //WORKSPACE/.../.suo	Solution user options file.
-//depot/.../bin/... //WORKSPACE/.../bin/...	Generated binaries.
-//depot/.../obj/... //WORKSPACE/.../obj/...	Object files.
-//depot/.../.user //WORKSPACE/.../.user	User settings. Can contain useful information, e.g. startup parameters.

CV Tag Cloud

2010-11-06T11:51:00.001+01:00

The tag cloud of my CV. Can be viewed in full size: http://www.wordle.net/show/wrdl/2686570/CV

Simple Map Reduce Example in C#

2010-10-31T15:19:00.001+01:00

This is an example of map-reduce implementation for IEnumerable. This code is not optimized. I think we shouldn’t create separate Task for each enumerated item. Probably partitioning the enumeration and dealing with bigger chunks of data would be much more efficient.

Browse source code: Google Code

MapReduce function for IEnumerable:

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Collections;

namespace MapReduceCode
{
    public static class MapReduce
    {
        public static Task<TResult> ForEachParallel<TItem, TSubResult, TResult, TParam>(this IEnumerable items, Func<TItem, TParam, TSubResult> map, Func<TSubResult[], TResult> reduce, TParam param)
        {
            if (items == null) { throw new ArgumentNullException("items"); }
            if (map == null) { throw new ArgumentNullException("map"); }
            if (reduce == null) { throw new ArgumentNullException("reduce"); }

            return Task<TResult>.Factory.StartNew(() =>
            {
                List<Task<TSubResult>> tasks = new List<Task<TSubResult>>();

                foreach (TItem item in items)
                {
                    Task<TSubResult> t = Task<TSubResult>.Factory.StartNew(item2 =>
                        {
                            var mparam = (Tuple<TItem, TParam>)item2;
                            return map(mparam.Item1, mparam.Item2);
                        },
                        new Tuple<TItem, TParam>(item, param),
                        TaskCreationOptions.None | TaskCreationOptions.AttachedToParent);
                    tasks.Add(t);
                }

                List<TSubResult> results = new List<TSubResult>();
                foreach (Task<TSubResult> task in tasks)
                {
                    results.Add(task.Result);
                }

                return reduce(results.ToArray());
            });
        }
    }
}

Usage example:

using System;
using System.Collections;
using MapReduceCode;
using System.Threading;
using System.Threading.Tasks;

namespace MapReduce
{
    class Program
    {
        static void Main(string[] args)
        {
            var a = Generate().ForEachParallel<int, int, int, int>(
                (element, param)=> 
                {
                    var result = element * param;
                    Console.WriteLine("Map: {0}, {1}", result, Task.CurrentId);
                    Thread.Sleep(new Random(DateTime.Now.Millisecond).Next(500));
                    return result;
                }, 
                (subresult)=>
                {
                    var sum = 0;
                    foreach (var item in subresult)
                    {
                        sum += item;
                    }
                    Console.WriteLine("Reduce: {0}", sum);
                    return sum;
                }, 
                5);

            Console.WriteLine(a.Result);
            
        }

        static IEnumerable Generate()
        {
            for (int i = 0; i < 100; i++)
            {
                yield return i;
            }
        }
    }
}

Result:

Map: 0, 1
Map: 5, 2
Map: 10, 3
Map: 20, 4
Map: 15, 5
Map: 25, 6
Map: 30, 7
Map: 35, 8
Map: 40, 9
Map: 45, 10
Map: 50, 11
Map: 55, 12
Map: 60, 13
Map: 65, 14
Map: 70, 15
Map: 75, 16
Map: 80, 17
Map: 85, 18
Map: 90, 19
Map: 95, 20
Map: 100, 21
Map: 105, 22
Map: 110, 23
Map: 115, 24
Map: 120, 25
Map: 125, 26
Map: 130, 27
Map: 135, 28
Map: 140, 29
Map: 145, 30
Map: 150, 31
Map: 155, 32
Map: 160, 33
Map: 165, 34
Map: 170, 35
Map: 175, 36
Map: 180, 37
Map: 185, 38
Map: 190, 39
Map: 195, 40
Map: 200, 41
Map: 205, 42
Map: 210, 43
Map: 215, 44
Map: 225, 45
Map: 230, 47
Map: 220, 46
Map: 235, 48
Map: 245, 50
Map: 240, 49
Map: 250, 51
Map: 255, 52
Map: 260, 53
Map: 265, 54
Map: 275, 56
Map: 270, 55
Map: 285, 57
Map: 280, 58
Map: 290, 59
Map: 295, 60
Map: 300, 62
Map: 305, 61
Map: 310, 63
Map: 315, 64
Map: 320, 65
Map: 325, 66
Map: 330, 67
Map: 335, 68
Map: 340, 69
Map: 355, 72
Map: 350, 71
Map: 360, 73
Map: 365, 74
Map: 345, 70
Map: 370, 75
Map: 380, 77
Map: 375, 76
Map: 390, 79
Map: 395, 80
Map: 385, 78
Map: 400, 81
Map: 405, 82
Map: 415, 84
Map: 425, 86
Map: 410, 83
Map: 420, 85
Map: 430, 87
Map: 440, 89
Map: 435, 88
Map: 450, 90
Map: 445, 91
Map: 455, 92
Map: 460, 93
Map: 470, 95
Map: 480, 97
Map: 475, 96
Map: 485, 98
Map: 465, 94
Map: 490, 99
Map: 495, 100
Reduce: 24750
24750

CAL and AutoMapper

2010-05-19T18:28:00.001+02:00

I’m using Composite Application Library (CAL) in a project. I decided to use AutoMapper as well. I put AutoMapper’s Mapper.CreateMap<source, dest>() calls into one of the Bootstrapper.cs methods. I got an InvalidOperationException in the ModuleCatalog’s InnerLoad() function.

Reason

AutoMapper creates an in-memory assembly and CAL tries to read all the assemblies’ Location property. This property raises an InvalidOperationException in case of in-memory assemblies.

Solution

Insert AutoMapper mappings right after the Bootstrapper.Run() call. In my case I call this in App.xaml.cs, so you can write the following:

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);

    // Run bootstrapper
    Bootstrapper bootstrapper = new Bootstrapper();
    bootstrapper.Run();

    // AutoMapper mappings
    Parallel.Invoke(CreateAutoMapperMappings);
}

/// <summary>
/// Creates the AutoMapper mappings.
/// </summary>
private static void CreateAutoMapperMappings()
{
    Mapper.CreateMap<Source, Dest>();
}

F#: Piping and Composition

2010-05-14T23:31:00.001+02:00

Piping and compositions are very expressive tools in F#. It significantly improves code readability.

Let’s have the following functions:

> let square x = x*x;;
val square : int -> int

> let negate x = -x;;
val negate : int –> int

Function square returns the square of x, while negate returns the negated value of x.

We can calculate square(negate(10)) as follows:

> let x = negate 10;;
val x : int = –10

> let x = square x;;
val x : int = 100

Or a simpler way:

> let x = square (negate 10);;
val x : int = 100

Piping

We can define piping as symbol-named function definition that simply applies two functions in reverse order:

let (|>) f x =
x f

The example with piping:

> 10 |> negate |> square;;
val it : int = 100

That means ((10 negate) square) –> (square (negate 10)). I used an integer (10) as f.

Composition

Composition is a reverse-order function composition:

let (>>) f g x =
g(f x)

The example with composition:

> (negate >> square) 10;;
val it : int = 100

That means ((negate square) 10) –> (square (negate 10)).

Usage

The examples above are very simple ones. The real benefits of piping and composition reveal in case of function definitions and usage.

Pipes can reverse parameter definition orders (like in 10 |> negate) and can help type inferring. When F# infers types, it evaluates from upper left corner to lover right corner of the text file, so sometimes it doesn't know the type of a function parameter. Pipe brings parameters forward.

Composition can help omitting function parameter declaration. If the first function expects a parameter, the composed function expects it’s parameter.

Database Comparison

2010-05-04T21:09:00.001+02:00

I' am very interested in open source database comparisons. I found two interesting blog posts:

Sukhvinder Singh wrote about the comparison of H2, HSQLDB, DERBY, PostgreSQL, MySQL.
Thirdstage wrote about the comparison of about HSQLDB, H2, SQLite

Link: H2, HSQLDB, DERBY, PostgreSQL, MySQL
Link: HSQLDB, H2, SQLite

Get WPF DataGrid row and cell

2010-05-02T11:54:00.001+02:00

There are no simple built-in methods for accessing individual rows or columns in WPF DataGrid. The following code samples will provide simple methods for accessing these items.

First of all we need a helper function for selecting a visual child:

public static T GetVisualChild<T>(Visual parent) where T : Visual
{
    T child = default(T);
    int numVisuals = VisualTreeHelper.GetChildrenCount(parent);
    for (int i = 0; i < numVisuals; i++)
    {
        Visual v = (Visual)VisualTreeHelper.GetChild(parent, i);
        child = v as T;
        if (child == null)
        {
            child = GetVisualChild<T>(v);
        }
       if (child != null)
       {
           break;
       }
   }
       return child;
}

There is a simple method for getting the current (selected) row of the DataGrid:

public static DataGridRow GetSelectedRow(this DataGrid grid)
{
    return (DataGridRow)grid.ItemContainerGenerator.ContainerFromItem(grid.SelectedItem);
}

We can also get a row by its indices:

public static DataGridRow GetRow(this DataGrid grid, int index)
{
    DataGridRow row = (DataGridRow)grid.ItemContainerGenerator.ContainerFromIndex(index);
    if (row == null)
    {
        // May be virtualized, bring into view and try again.
        grid.UpdateLayout();
        grid.ScrollIntoView(grid.Items[index]);
        row = (DataGridRow)grid.ItemContainerGenerator.ContainerFromIndex(index);
    }
    return row;
}

Now we can get a cell of a DataGrid by an existing row:

public static DataGridCell GetCell(this DataGrid grid, DataGridRow row, int column)
{
    if (row != null)
    {
        DataGridCellsPresenter presenter = GetVisualChild<DataGridCellsPresenter>(row);

        if (presenter == null)
        {
            grid.ScrollIntoView(row, grid.Columns[column]);
            presenter = GetVisualChild<DataGridCellsPresenter>(row);
        }

        DataGridCell cell = (DataGridCell)presenter.ItemContainerGenerator.ContainerFromIndex(column);
        return cell;
    }
    return null;
}

Or we can simply select a row by its indices:

public static DataGridCell GetCell(this DataGrid grid, int row, int column)
{
    DataGridRow rowContainer = grid.GetRow(row);
    return grid.GetCell(rowContainer, column);
}

The functions above are extension methods. Their use is simple:

var selectedRow = grid.GetSelectedRow();
var columnCell = grid.GetCell(selectedRow, 0);

View source on Google Code (unformatted selection possible)

Mixed mode assemblies on .NET 4.0

2010-04-17T16:31:00.001+02:00

Mixed mode assembly is built against version 'v2.0.50727' of the runtime and cannot be loaded in the 4.0 runtime without additional configuration information.

I got this message when I tried to start a project migrated from .NET 3.5 to .NET 4.0. I case of migration, migration wizard inserts a <startup></startup> tag into the app.config file.

Solution: insert the

useLegacyV2RuntimeActivationPolicy="true"

attribute into the startup tag. Application should work now.

Reason: .NET 4.0 changed mixed mode assembly loading mechanisms.

NHibernate session management

2010-04-17T14:36:00.001+02:00

When you start working with NHibernate, you will see code examples like this one:

int userID = 1234;

using( ISession session = sessionFactory.OpenSession() )

using( session.BeginTransaction() ) {

    User user = session.Get<User>(userID);

    session.Transaction.Commit();

You get a session object, start a transaction and finally commit that. This is fine when you work in a simple one-layer application or you are OK with tight coupling. When you have multiple layers, or working with binding like in WPF, things get complicated.

Session management strategies

Session per application
Simplest approach. Just one session for the whole application, typically returned by a singleton.
Problem: Async calls can interfere with each other, cache size grows, unrecoverable exceptions, stale data
Session per screen
New session for every form/view/… There are multiple concurrent sessions.
Problem: You can keep a screen opened for a long time, so stale data is expectable.
Session per data access
Every single data access uses a new session object.
Problem: Lazy loading won’t work, problem with 1st level cache…
Session per use-case
You create a new session for every use-case. There will be concurrent sessions.

Firs try: Following examples – Session per data access

I’ve created an application with the simplest solution possible. I followed the examples and whenever I tried to access data, I created a session and a transaction. Everything was fine, until I tried to employ lazy loading. It simply did not work. There was no open sessions the lazy loader proxy could have used.

Second try: Session per application

I modified the application. I created a singleton that returned a session object. Every single data access used this session. The application worked fine – for a while. I used SQLite as DBMS, and SQLite has not the best threading support. So I got exceptions randomly. Sometimes a control was empty, sometimes it was filled with data. Exceptions happened about 1 out of 15 tries. I suspected a threading issue and it seems it was.

Third try: Session per use-case

I had to implement a session per use-case (business transaction) solution to solve the problems above. A business transaction is a user-initiated action involving multiple complicated operations (steps). All operations (and the transaction itself) are either successful or unsuccessful. The state of the involved members are well-defined and consistent at the end of the transaction.

We have to be able to keep alive the NHiberanate ISession object over multiple operations. The solution is the unit of work pattern. It encapsulates the ISession object, so we can pass it around and implement the IDisposable pattern. The class implementing the unit of work pattern can expose ISession functionality. See the example UML class diagram below.

This is an example of calling the UnitOfWork object instance:

using (UnitOfWork unitOfWork = database.CreateUnitOfWork())

    PropertiesRepository propertiesRepository = new PropertiesRepository(unitOfWork);

    properties = propertiesRepository.Current;

You can use a simple factory (it is the database object here) to create a new UnitOfWork instance. This instance should be passed to all the classes accessing NHibernate functionality. This is important, so design your data access and manipulating classes according to this constraint!

Link: Rich-client NHibernate session management
Link: Unit of Work

CodePlex TFS from VS2010

2010-04-17T13:03:00.001+02:00

Visual Studio 2010 Professional has a built-in Team Foundation Server (TFS) client. There are some user interface changes on the Add Team Foundation Server screen. When you are connecting to the CodePlex TFS, you need to specify the following information:

Name or URL of TFS: tfs<number>.codeplex.com
Connection details

Path: tfs
Port number: 443
Protocol: HTTPS

There is no need to specify Project name anywhere on this screen.