Techie things

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.

Refresh WPF DataGrid

2010-01-24T19:57:00.001+01:00

I am using WPF DataGrid for displaying a list of items. I had to modify an item, but the item had no INotifyPropertyChanged event on that property (it was a collection).

So my first idea was:

Update the list behind ItemsSource
Set ItemsSource property to null to force unbinding
Set ItemsSource property to the new collection
Set the SelectedItem to the new item
Call ScrollIntoView() on the new item

Well, I got a huge exception at step 5. There must be a simpler solution. And there is.

The DataGrid generates a view of the ItemsSource. All I have to do is call the Items.Refresh() method, and it will rebind to the ItemsSource. Everything will be rebound, all updates will be visible. Selected item kept, visibility kept.

DispatcherPriority

2010-01-18T15:33:00.001+01:00

I had a very tough problem today. The following code did not work correctly:

var books = _bookRepository.All;

Dispatcher.Invoke(

    new ThreadStart(delegate

                            foreach (Book book in books)

                                CatalogItems.Add(new BookViewModel(book));

                            OnLoaded(this, EventArgs.Empty);

                            OnPropertyChanged("CatalogItems");

}),

    DispatcherPriority.ApplicationIdle);

When I run the code above the first time, the debugger didn’t even break into the dispatched code. The subsequent calls were fine.

Finally I realized that DispatcherPriority.ApplicationIdle should be changed to DispatcherPriority.Normal – and everything was fine. Don’t forget to check the DispatcherPriority value of the dispatcher! It’s hard to debug and hard to recognize.

These are the possible dispatcher priority levels:

Priority	Description
Inactive	Work items are queued but not processed.
SystemIdle	Work items are only dispatched to the UI thread when the system is idle. This is the lowest priority of items that are actually processed.
ApplicationIdle	Work items are only dispatched to the UI thread when the application itself is idle.
ContextIdle	Work items are only dispatched to the UI thread after higher-priority work items are processed.
Background	Work items are dispatched after all layout, rendering, and input items are processed.
Input	Work items are dispatched to the UI thread at the same priority as user input.
Loaded	Work items are dispatched to the UI thread after all layout and rendering are complete.
Render	Work items are dispatched to the UI thread at the same priority as the rendering engine.
DataBind	Work items are dispatched to the UI thread at the same priority as data binding.
Normal	Work items are dispatched to the UI thread with normal priority. This is the priority at which most application work items should be dispatched.
Send	Work items are dispatched to the UI thread with the highest priority.

Link: Build More Responsive Apps With The Dispatcher (MSDN)

Events with anonymous delegate

2010-01-11T10:55:00.001+01:00

I subscribed to an event with an anonymous delegate. Later I was in need for a solution to be able to unsubscribe this delegate. This is a simple solution for the problem:

public class ClassName

    MouseButtonEventHandler eventHandler;

    public ClassName()

        eventHandler = delegate

                                            // operations

};

    void Functionality()

        if (_subscribe)

            _object.MouseLeftButtonDown += eventHandler;

        else

            _object.MouseLeftButtonDown -= eventHandler;

NHibernate and SQLite in-memory database

2010-01-09T12:50:00.002+01:00

I’m implementing and in-memory database-based unit test framework for an application. I hope it speeds up unit tests. Unfortunately I have to redesign my entity repositories to support in-memory behavior. As far as I can learn from SUT behavior, SQLite will create a brand new database when

you close the session
you commit or close a transaction

It means you can’t use using(ISession) and using(ITransaction transaction){ … transaction.Commit() } constructs in the repository.

Web-style WPF popup

2009-12-16T13:47:00.001+01:00

I like modal web dialogs, especially when they dim the background. Here is an example:

The background is dimmed, not clickable, and the dialog box is in the foreground. The work area is visible at first site, you must focus on the current content.

I wanted something similar in WPF. Here is my example application:

How it works?

There are two parts of the window. There is a DataGrid in the left pane and a ListBox in the right pane. The same data is loaded into both controls. When you select an item in the grid, the popup will appear over the grid, displaying the selected name. Clicking on the popup will close that. You can’t click through the popup. The right pane demonstrates that you can do anything with other controls. The popup resizes itself (drag the grid splitter to test it).

About adorners

The key component to the popup control is the adorner class of WPF. The definition of adorners from MSDN:

An Adorner is a custom FrameworkElement that is bound to a UIElement. Adorners are rendered in an AdornerLayer, which is a rendering surface that is always on top of the adorned element or a collection of adorned elements. Rendering of an adorner is independent from rendering of the UIElement that the adorner is bound to. An adorner is typically positioned relative to the element to which it is bound, using the standard 2-D coordinate origin located at the upper-left of the adorned element.

There are three types of adorners:

Adorner: An abstract base class from which all concrete adorner implementations inherit.

AdornerLayer: A class representing a rendering layer for the adorner(s) of one or more adorned elements.

AdornerDecorator: A class that enables an adorner layer to be associated with a collection of elements.

The code

The code of the popup adorner is the following:

   1: using System.Windows;

   2: using System.Windows.Documents;

   3: using System.Windows.Media;

   4: using System.Windows.Controls;

5:

   6: namespace AdornerTest1

   7: {

   8:     public class PopUp : Adorner

   9:     {

  10:         private VisualCollection _Visuals;

  11:         private ContentPresenter _ContentPresenter;

12:

  13:         /// <summary>

  14:         /// Initializes a new instance of the <see cref="PopUp"/> class.

  15:         /// </summary>

  16:         /// <param name="adornedElement">The element to bind the adorner to.</param>

  17:         /// <exception cref="T:System.ArgumentNullException">Raised when adornedElement is null.</exception>

  18:         public PopUp(UIElement adornedElement)

  19:             : base(adornedElement)

  20:         {

  21:             _Visuals = new VisualCollection(this);

  22:             _ContentPresenter = new ContentPresenter();

  23:             _Visuals.Add(_ContentPresenter);

  24:         }

25:

  26:         /// <summary>

  27:         /// Initializes a new instance of the <see cref="PopUp"/> class.

  28:         /// </summary>

  29:         /// <param name="adornedElement">The adorned element.</param>

  30:         /// <param name="content">The content.</param>

  31:         public PopUp(UIElement adornedElement, Visual content)

  32:             : this(adornedElement)

  33:         { Content = content; }

34:

  35:         /// <summary>

  36:         /// Implements any custom measuring behavior for the adorner.

  37:         /// </summary>

  38:         /// <param name="constraint">A size to constrain the adorner to.</param>

  39:         /// <returns>

  40:         /// A <see cref="T:System.Windows.Size"/> object representing the amount of layout space needed by the adorner.

  41:         /// </returns>

  42:         protected override Size MeasureOverride(Size constraint)

  43:         {

  44:             _ContentPresenter.Measure(constraint);

  45:             return _ContentPresenter.DesiredSize;

  46:         }

47:

  48:         /// <summary>

  49:         /// When overridden in a derived class, positions child elements and determines a size for a <see cref="T:System.Windows.FrameworkElement"/> derived class.

  50:         /// </summary>

  51:         /// <param name="finalSize">The final area within the parent that this element should use to arrange itself and its children.</param>

  52:         /// <returns>The actual size used.</returns>

  53:         protected override Size ArrangeOverride(Size finalSize)

  54:         {

  55:             _ContentPresenter.Arrange(new Rect(0, 0,

  56:                  finalSize.Width, finalSize.Height));

  57:             return _ContentPresenter.RenderSize;

  58:         }

59:

  60:         /// <summary>

  61:         /// Overrides <see cref="M:System.Windows.Media.Visual.GetVisualChild(System.Int32)"/>, and returns a child at the specified index from a collection of child elements.

  62:         /// </summary>

  63:         /// <param name="index">The zero-based index of the requested child element in the collection.</param>

  64:         /// <returns>

  65:         /// The requested child element. This should not return null; if the provided index is out of range, an exception is thrown.

  66:         /// </returns>

  67:         protected override Visual GetVisualChild(int index)

  68:         { return _Visuals[index]; }

69:

  70:         protected override int VisualChildrenCount

  71:         { get { return _Visuals.Count; } }

72:

  73:         /// <summary>

  74:         /// Gets or sets the content.

  75:         /// </summary>

  76:         /// <value>The content.</value>

  77:         public object Content

  78:         {

  79:             get { return _ContentPresenter.Content; }

  80:             set { _ContentPresenter.Content = value; }

  81:         }

  82:     }

  83: }

You can set a content for the popup adorner, and that is all what I want. The VisualCollection is responsible for rendering the content on screen, and the ContentPresenter is responsible for storing the popup’s content.

There is a BackgroundShade user control to represent the dimmed background. The code is very short and simple:

   1: <UserControl

   2:     [...]

   3:     Background="Black"

   4:     Opacity="0.705">

5:

   6:     <Grid x:Name="LayoutRoot"/>

   7: </UserControl>

I set the background to black at line 3 and I set the opacity of the control to 70% at line 4.

The Main window layout:

   1: <Window

   2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:     xmlns:Custom="http://schemas.microsoft.com/wpf/2008/toolkit" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:AdornerTest1="clr-namespace:AdornerTest1"

   5:     x:Class="AdornerTest1.MainWindow"

   6:     x:Name="Window"

   7:     Title="Popup with shaded background sample"

   8:     Width="640" Height="480" mc:Ignorable="d">

9:

  10:     <Window.Resources>

  11:         <DataTemplate x:Key="ItemTemplate">

  12:             <StackPanel>

  13:                 <TextBlock Text="{Binding Name}" Background="Black" Foreground="White"/>

  14:                 <TextBlock Text="{Binding Phone}"/>

  15:                 <TextBlock Text="{Binding Note}" Margin="0 0 0 8"/>

  16:             </StackPanel>

  17:         </DataTemplate>

  18:     </Window.Resources>

19:

  20:     <Grid x:Name="LayoutRoot" DataContext="{Binding Source={StaticResource SampleDataSource}}">

  21:         <Grid.ColumnDefinitions>

  22:             <ColumnDefinition/>

  23:             <ColumnDefinition MinWidth="10" Width="Auto"/>

  24:             <ColumnDefinition/>

  25:         </Grid.ColumnDefinitions>

  26:         <Custom:DataGrid x:Name="Grid" ItemsSource="{Binding Collection}"  AutoGenerateColumns="True" SelectionChanged="Grid_SelectionChanged" />

  27:         <GridSplitter HorizontalAlignment="Stretch" Grid.Column="1"/>

  28:         <ListBox x:Name="List" Grid.Column="2" ItemTemplate="{DynamicResource ItemTemplate}" ItemsSource="{Binding Collection}" d:LayoutOverrides="GridBox"/>

  29:     </Grid>

  30: </Window>

There is a Grid as layout root with 3 columns. There is a DataGrid in the left pane, a GridSplitter in the middle pane, and a ListBox in the right pane.

The Main window code:

   1: using [...]

2:

   3: namespace AdornerTest1

   4: {

   5:     public partial class MainWindow : Window

   6:     {

   7:         public MainWindow()

   8:         { [...] }

9:

  10:         BackgroundShade shade;

  11:         PopUp adorner;

12:

  13:         private void Grid_SelectionChanged(

  14:             object sender, SelectionChangedEventArgs e)

  15:         {

  16:             // Create adorner

  17:             AdornerLayer layer = AdornerLayer.GetAdornerLayer(Grid);

  18:             adorner = new PopUp(Grid);

19:

  20:             // Close adorner

  21:             adorner.MouseLeftButtonDown += delegate

  22:                                        {

  23:                                            layer.Remove(adorner);

  24:                                        };

  25:             ((FrameworkElement) adorner.AdornedElement).

  26:                 SizeChanged += AdornedElement_SizeChanged;

27:

  28:             // Create shaded background

  29:             shade = new BackgroundShade();

  30:             AdornedElement_SizeChanged(this, null);

31:

  32:             // Create text

  33:             TextBlock text = new TextBlock();

  34:             text.Foreground = Brushes.White;

  35:             // Bind text to selected item

  36:             Binding binding = new Binding("Name");

  37:             binding.Source = Grid.SelectedItem;

  38:             text.SetBinding(TextBlock.TextProperty, binding);

  39:             // Register text

  40:             shade.LayoutRoot.Children.Add(text);

41:

  42:             // Display adorner

  43:             adorner.Content = shade;

  44:             layer.Add(adorner);

  45:         }

46:

  47:         /// <summary>

  48:         /// Adorned element's size changed

  49:         /// </summary>

  50:         void AdornedElement_SizeChanged(object sender, SizeChangedEventArgs e)

  51:         {

  52:             shade.Width = adorner.AdornedElement.RenderSize.Width;

  53:             shade.Height = adorner.AdornedElement.RenderSize.Height;

  54:         }

  55:     }

  56: }

The implementation details are in the comments. One interesting thing: I couldn’t simply bind the AdornedElement’s RenderSize to the shade’s width property, so it seems simpler to convert the AdornedElement to FrameworkElement and attach an event handler to the SizeChanged event.

You can download the source and the binaries from Google code, or you can simply browse source at the same place. Links are below.

Link: Demo source [Google Code]
Link: Demo executable [Google Code]
Link: Browse source [Google Code]

NUnit and Microsoft Contracts library

2009-12-13T13:41:00.001+01:00

I’m using NUnit and Microsoft Code Contracts library to implement unit tests and code contracts (mostly preconditions).

Unfortunately Contracts library throws a generated (internal) exception class that can’t be used as Assert.Throws<ContractException>(…).

Contracts documentation suggests the following code for MSTest framework:

[TestClass]

public  class  Test

    [AssemblyInitialize]

    public  static  void   AssemblyInitialize (TestContext tc)

        Contract. ContractFailed+= (sender, e) => {

            e.SetHandled();

            e.SetUnwind(); // cause code to  abort  after  event

            Assert.Fail(e.FailureKind.ToString() + ":" + e.DebugMessage);

};

I wrote the following code to mimic this functionality:

[TestFixtureSetUp]

public void SetUpFixture()

    Contract.ContractFailed +=

    (sender, e) =>

        e.SetHandled();

        e.SetUnwind();

        Assert.Fail(string.Format("{0}:{1}", e.FailureKind.ToString(), e.Message));

};

Well, it did not work, I couldn’t make the Assert.Throws structure work. I always got the ContractException exception. Finally I found a blog entry (in German) with a classic solution:

use try/catch block
check exception type name

So here is the working code:

try

    // Method under test

catch (Exception ex)

    Assert.True(ex.GetType().Name == "ContractException");

    return;

Assert.Fail("ContractException has not been thrown.");

NDepend

2009-12-07T13:05:00.001+01:00

I've started using NDepend Pro on my open-source project. I will try to outline some important features and explain some ideas that differenciate this tool from others like FXCop or ReSharper rules.

What is NDepend?

For me NDepend is a tool for monitoring and improving code quality. It uses software metrics and .NET IL characteristics to help us understand, analyze, visualize and compare different code bases and builds. We learnt code coverage, cohesion, coupling and other code metrics at university, but we hardly had the chance to employ this knowledge (or even understand deeper them). Who wants to calculate them for hundreds of code lines? Well, NDepend just does it instead of us. We can see the internals of code structure and dependencies with just one click!

Costs

NDepend is a free tool for academic and open-source projects. Unfortunately it comes with a cost: you will be restricted with CQL (creating custom code metrics queries) usage, won’t be able to compare builds, won’t be able to integrate test metrics into the dataset and (almost) won’t have Visual Studio integration. I think it’s OK for an open-source project.

Where to start?

NDepend is not an easy tool. Easy to use, but it takes time to learn and understand the metrics and find the proper threshold limits for your project. NDepend team knows it, so they set up a lot of preset thresholds and built-in CQL queries. There are useful demo videos and there is a metrics library. So it’s easy to start using it.

How do I use it?

I use NDepend as a guard. I use other tools (like Resharper, Team System Tools or FXCop) in Visual Studio to check against naming conventions and some other rules. Visual NDepend helps me to understand the structure of my application and recheck some rules, mainly with built-in CQL queries.

I found a circular call in one of my assemblies. It was not trivial to me, I couldn’t have found that without NDepend.

Link: NDepend
Link: software metrics
Link: Inheritance Depth in CQL

Pin m3u to taskbar

2009-11-15T17:33:00.001+01:00

I wanted to pin (keep permanently) some .m3u files to my taskbar. A lot of radios publish their live streams in .m3u files and I could have listened to them with just one click.

It is really simple in case of Windows 7. Just drag and drop the .m3u files to the taskbar (to an empty area) and these files will appear in the pin list of their default program. In my case this program is Media Player Classic.

This is a great feature of Windows 7!