SeeSharp

Anatomy of an ASP.NET MVC Control

2009-09-08T15:49:00.004+04:30

One of the great things about ASP.NET WebForms was that it wasy very easy to creat reuseable custom controls and components, but with appearance of ASP.NET MVC and lots of developers moving towards it – which is a good thing – what happens to component oriented development? Is is possible to create custom controls in MVC? Can we port our existing controls to MVC? ASP.NET MVC while may not be as good as WebForms when it comes to drag-and-drop style of using components, but it is fairly easy to use and to create custom controls in MVC! Let’s see how.

To create a control in WebForms world, you’d extend the existing “WebControl” class and override Render method which takes a HtmlTextWriter that you can use to output the desired HTML code to the browser. A control rendering “Hello World” on the screen would be as simple as this:

public class HelloWorldControl : WebControl
{
    protected override void Render(HtmlTextWriter writer)
    {
        base.Render(writer);

        writer.Write("<span>HelloWorld</span>");
    }
}

You’d put this on your web page and you’re all set. But what’s the best approach in MVC controls? There’s no WebControl or Control classes inside Mvc assemblies, so can either use any existing class you have as a base class or it from scratch.

public class WebControl
{
    /// <summary>
    /// Renders the control by writing the html code into the text writer.
    /// </summary>
    /// <param name="textWriter"></param>
    public virtual void Render(TextWriter textWriter)
    {
    }

    /// <summary>
    /// Renders the control and outputs the generated HTML code.
    /// </summary>
    /// <returns></returns>
    public string OnRender()
    {
        var tw = new StringWriter();

        Render(tw);

        return tw.ToString();
    }
}

With this, you have a ready to use base class for your controls. You need to override the Render method and construct the right HTML code. The code would look almost identical:

public class HelloWorldControl : WebControl
{
    public override void Render(TextWriter writer)
    {
        base.Render(writer);

        writer.Write("<span>Hello World!</span>");
    }
}

Note: There’s a catch here. We’d use existing methods on HtmlTextWriter in WebForms, which emitted correct HTML code per Browser. If you’re writing the HTML code manually (as I did in this example) you’d be careful in case you need to support different browsers.

The only thing remaining is, how do we use this in an MVC application? The way to do this, as it is already done in the MVC framework with other controls such as TextBox, CheckBox, etc. is to create an extension method on HtmlHelper class. HtmlHelper is just there as a waypoint for extension method and has no other uses:

public static class HelloWorldControlExtensions
{
    public static string HelloWorld(this HtmlHelper helper)
    {
        var control = new HelloWorldControl();

        return control.OnRender();
    }
}

Now you can add this controls to your views, as easy as other controls such as TextBoxes:

<%= Html.HelloWorld() %>

That’s almost it. The only thing remaining here is to implement control specific logic of your components and that part is left to you.

Caliburn = Less Code?

2009-09-02T11:59:00.003+04:30

Caliburn is an application framework for WPF / Silverlight. If you’re developing applications for these platforms, there are many reasons why you definitely need to be using this framework, but today, I noticed how using this framework resulted writing less code while doing more. Let’s see how writing a small WPF application using MVVM pattern is different when using Caliburn.
Note: There are many other ways to skin a cat. This is how I do things, there may be other, better ways to do the same thing.

Application Startup
When creating an application using MVVM and “ViewModel First” development, you’d create the root View and VM, bind them through DataContext and show the main window of the application.

///
/// Interaction logic for App.xaml
///
public partial class App : Application
{
   protected override void OnStartup(StartupEventArgs e)
   {
      base.OnStartup(e);

      var container = new WindsorContainer();
      var rootView = new RootView();
      var rootModel = new RootViewModel();

      rootView.DataContext = rootModel;
      this.MainWindow = rootView;
      this.MainWindow.Show();
   }
}

With caliburn, all you need to do is to create the root VM. There’s no trace of any View creation and binding the DataContext to VM. All this is done automatically by Caliburn. To do this, use “CaliburnApplication” as your base application class which will configure Caliburn framework upon startup. There are other ways to do the configuration but let’s stick to this simple configuration scenario that installs default implementations of Calburn “Components”.

///
/// Interaction logic for App.xaml
///
public partial class App : CaliburnApplication
{
   protected override IServiceLocator CreateContainer()
   {
      var container = new WindsorContainer();
      var adapter = new WindsorAdapter(container);

      return adapter;
   }

   protected override object CreateRootModel()
   {
      return new RootViewModel();
   }
}

One thing a little different is that Caliburn uses IServiceLocator insterface (from Common Service Locator) and has no direct dependency on a vendor specific IoC Container, which is a good thing. This means, you can choose various IoC containers and adapters for major IoC containers like Windsor, Ninject, Autofac, etc. are already included in Caliburn bits. If you're not a fan of IoC containers and won't be using one in your application (now, come on!), Caliburn uses a lightweight built-in container, in case you don't specify any other.

Actions and Commands
Should you bind an action to a ICommand instance on the VM, in pure MVVM application you would bind the Command property to an ICommand instance on the VM. You can specify the condition on which the command will be executable and you’ll also implement the action execute by the command.

<Button Command="{Binding ExitCommand}" Content="Exit Application">

public class RootViewModel : BaseViewModel
{
   private ICommand _exitCommand;
   public ICommand ExitCommand
   {
      get
      {
         if (_exitCommand == null)
           _exitCommand = new RelayCommand(this.Exit, this.CanExit);

         return _exitCommand;
      }
   }

   public bool CanExit()
   {
      return true;
   }

   public void Exit()
   {
      Application.Current.Shutdown();
   }
}

Notice there are other “hidden” code here too. You’ll need to create a new Command, or use RelayCommand (kudos to Josh) and you probably need a common layer supertype that implements INotifyPropertyChanged interface. Using Caliburn you'd bind the action directly to the VM and there's no dependency to ICommand instances. The good thing is, you’re not limited to Command property anymore and you can bind various other events such as Click, MouseOver, etc. to actions on your VM.

<Button cal:Message.Attach="[Event Click] = [Action Exit]" Content="Exit Application">

public class RootViewModel : Presenter
{
   public bool CanExit()
   {
      return true;
   }

   public void Exit()
   {
      Application.Current.Shutdown();
   }
}

There are lots of existing boilerplate functionalities already available in Caliburn, so you can drop BaseViewModel and use Presenter class (IPresenter implementation).

Displaying Views
To display other views in the RootView (e.g. Shell), we’d constructed a new VM and set it to a Content property of a ContentControl. This will actually pick up the view specified in the DataTemplate from Application Resources, and display it on the UI. You have to maintain a mapping between your Views and your VMs in a resource dictionary and as your application grows this gets harder to maintain.

<Application.Resources>
   <DataTemplate DataType="{x:Type vm:CustomerViewModel}">
      <view:CustomerView />
   </DataTemplate>
</Application.Resources>

<ContentControl Content="{Binding Path=CurrentView}"/>

public class RootViewModel : BaseViewModel
{
   public void ShowCustomer()
   {
      CurrentView = IoC.Resolve<Customerviewmodel>();
   }

   private BaseViewModel _currentView;
   public BaseViewModel CurrentView
   {
      get { return _currentView; }
      set
      {
         _currentView = value;
         RaisePropertyChanged("CurrentView");
      }
   }
}

Let’s see how we can do this using Caliburn. First off, we do not need to maintain any ViewModel mapping if we name our Views and ViewModels according to the Caliburn Conventions that is, your view names should ending in View, presenters / VMs ending in “ViewModel” or “Presenter” and each should be in a separate namespace, namingly “Views” and “ViewModels” or “Presenters”. This is just by convention and you can always override if you need to. Caliburn will automatically create the view for you, set the “CurrentPresenter” property on the main window (i.e. IPresenterHost) and do any required bindings. Did I mention you don’t need the whole mapping of View <-> DataTemplate in your Application / Form resource?

<ContentControl x:Name="CurrentPresenter" >

[Singleton("RootViewModel")]
public class RootViewModel : PresenterManager
{
   public void ShowCustomer()
   {
      var presenter = ServiceLocator.Current.GetInstance<Customerviewmodel>();
      this.Open(presenter);
   }
}

Conclusion
What’s the catch? How does Caliburn do this? Caliburn uses “Convention over Configuration” pattern, so if you do things according to the convention you’ll end up saving a lot of code. There’s always the possibility to change the default behavior too. By complying to these conventions, clearly you’ll end up writing less code, but more importantly the code you do write is cleaner, more robust and probably with better testabilty. With the help of “Binding Tests” utilities existing in Caliburn, you can test your bindings the easy way, which is some thought for later posts.

Windsor Registration : Service Interface

2009-08-20T12:08:00.002+04:30

Sometimes when registering classes on Windsor container, that extend an existing base class with an interface, using auto registration and FirstInterface method is useless, because first interface finds the interface implemented by base class:

[TestFixture]
public class RegistrationFixture : ContainerTest
{
   [Test]
   public void Can_Find_Service_Using_Interface()
   {
       var service = TryResolve<IService>();

       Assert.That(service, Is.Not.Null);
   }

   protected override void OnSetup()
   {
       base.OnSetup();

       Container.Register(AllTypes.From(typeof(ServiceImpl))
                .Where(null)
                .Configure(x => x.LifeStyle.Is(LifestyleType.Transient))
                .WithService.FirstInterface());
   }

   private interface IBaseService
   {
   }

   private interface IService
   {
   }

   private class BaseService : IBaseService
   {
   }

   private class ServiceImpl : BaseService, IService
   {
   }
}

If you run the test, it will fail, because ServiceImpl is registered with IBaseService interface, which is the first interface on the class hierarchy. But that is not what I intended to do. I wanted the to register it using the first interface on the same type, e.g. IService. Extension methods come to the rescue:

public static class ContainerExtensions
{
   public static BasedOnDescriptor FirstInterfaceOnClass(this ServiceDescriptor serviceDescriptor)
   {
       return serviceDescriptor.Select((t, bt) =>
       {
           var baseInterfaces = t.BaseType.GetInterfaces();
           var interfaces = t.GetInterfaces().Except(baseInterfaces);

           return interfaces.Count() != 0 ? new[] {interfaces.First()} : null;
       });
   }
}

Changing the registration to this would pass the failing test:

Container.Register(AllTypes.From(typeof(ServiceImpl))
        .Where(null)
        .Configure(x => x.LifeStyle.Is(LifestyleType.Transient))
        .WithService.FirstInterfaceOfClass());

LOB Application in WPF

2009-07-30T13:11:00.002+04:30

I’ve been working on a small LoB application to manage sales of a small sales office. I thought it’d be a good idea to put to use my WPF knowledge and use WPF to create this application. The reason is obvious : Programming in WPF is as easy as it gets, more testable (as in Unit Testing and Acceptance Testing) and more end-user friendly.

Following applicaiton components and patterns were used:

NHibernate
NHibernate Validator to validate both entities and ViewModels
FarsiLibrary (globalizing Dates, DatePickers, etc.)
MVVM pattern

One part that took more effort than expected was localization and globalization of the application. In general, there are three things you need to check to achieve full localization, if you provide both Left-To-Right reading order languages (English) as well as Right-To-Left (Farsi, Arabic) :

Flow Direction

Thanks to WPF engine, most of the calculation of LTR reading order to RTL for Forms, UserControls and even Custom Controls is done automagically, although in custom controls, you might need to add some triggers to switch things like shadows, etc. and if you use a 3rd party custom control or library, you need to make sure component vendor has take care of issue like that.

Texts

WPF uses LocaBaml to extract localizable properties’ values to an excel file and after translation (e.g. assigning values for other languages), puts them in a satelite assembly. This approach looks rough to maintain but there are lots of libraries on Codeplex that will help you do this with xml files or .resx files. My suggestion is to use WPF Localization Extension which supports localizing FlowDirection, Brush, Texts, Images, etc.

Dates

Not eveyone use Gregorian Calendar available in english language cultures. For example in Arabic language HijriCalendar is used and for Farsi, PersianCalendar is used and sometimes just setting thread’s culture to the language (e.g. Farsi) would not be enough. If you use dates in your applications (who doesn’t?) you need to use date controls that work fluently with various languages and cultures. I used my own FarsiLibrary control for WPF which allows you to work with PersianCalendar, HijriCalendar and GregorianCalendar seamlessly.

System Messages

With all the efforts and steps mentioned above, one part of the application still remains in native language of the Windows Installation. That is when using Windows’s MessageBox to alert user and display messages. Fortunately, I already have my Expression Clone styles which come with a Expression style messagebox that come with localizable icons / button texts.

Styling

No doubt one of the features that comes with WPF is the ability to style everything that makes sense to provide a better UX. I used my Expression styles which you can download here to style your WPF applications very easily to make it look like Expression series.

Before Styling

Using Expression Styles

XamDataGrid Validation with NHibernate Validator

2009-07-22T17:09:00.003+04:30

One of the good grid controls in WPF world belongs to Infragistics. With all the bells and whistles, there are still some limitation, some are WPF engine limitation and some are not. One thing that is very limiting is validation of data prior them being added to datasource. This is rather a broad subject, but I intended to use NHibernate entities (POCO objects) decorated with NHiberante validator attributes to do the validation for me.

NHibernate Validator

NHibernate Validator is a subproject in NHibernate Contrib which allows you validate plain business classes by using predefined set of validation attributes. The good thing is, as good as NHibernate uses POCO (Plain Old CLR Object) objects you can also validate any kind of simple classes using NHibernate validator. There are other validation frameworks out there but I didn’t wanted to clutter my object with the validation mechanism and I also didn’t want to write unnecessary properties on my domain objects (e.g. IsValid, etc.) so NHibernate Validator was a right choice for me. Let’s see how a POCO entity along with validation looks like:

public class Product
{
  public Product()
  {
  }

  public long ProductId
  {
      get;
      private set;
  }

  [NotNullNotEmpty]
  public string Title
  {
      get; set;
  }

  [NotNull]
  public Category Category
  {
      get; set;
  }

  public string Description
  {
      get; set;
  }

  [Min(0)]
  public long Quantity
  {
      get; set;
  }
}

Binding To XamDataGrid

XamDataGrid supports binding to IEnumerable interface, so an IList<Product> would work. Also, XamDataGrid needs a public parameterless constructor if you’re going to add to that collection from the grid control. If this requirement is not met, grid control will silently ignore the NewLine setting value. Here’s the xaml snippet to display a grid with predefined fields (columns) and a NewLine row:

<igdp:XamDataGrid DataSource="{Binding ProductList}">
  <igdp:XamDataGrid.FieldLayouts>
      <igdp:FieldLayout>
          <igdp:FieldLayout.Settings>
              <igdp:FieldLayoutSettings AddNewRecordLocation="OnTopFixed" AllowDelete="False"
                                        AllowAddNew="True" ExpansionIndicatorDisplayMode="Never"
                                        />
          </igdp:FieldLayout.Settings>
          <igdp:FieldLayout.Fields>
              <igdp:Field Name="Title"       Label="Product Name" />
              <igdp:Field Name="Category"    Label="Category" />
              <igdp:Field Name="Description" Label="Comment"/>
              <igdp:Field Name="Quantity"    Label="Qtty" />
              <igdp:Field Name="ProductId"   Visibility="Collapsed"/>
          </igdp:FieldLayout.Fields>
      </igdp:FieldLayout>
  </igdp:XamDataGrid.FieldLayouts>
</igdp:XamDataGrid>

Now when you run the application and add a new Product object to the datasource, there’s no way to check if all the predefined validation rules are okay. So, how do we change the behavior of the grid control to:

Validate the product object PRIOR being added to the datasource so if an object is not validate, it won’t get added to the data source.

No redundant validation code should be written. We need to use NHibernate Validator infrastructure we already have in place.

A reusable mechanism. Our application might end up with lots of grid controls.

One way would be to subclass the grid control which although might work, is a heavy handed solution to our rather little problem. It is not right to put the code in our ViewModel (I’m using MVVM pattern), which introduces coupling betwee UI and ViewModel. Fortunately, this grid control exposes good events we can tap into and change the default validation behavior and we can do this by creating a new Attached Behavior.

Validation Attached Behavior

Attaching a behavior to an object, as the name puts it, means making the object do something that it would not do by default. According to Josh Smith:

“The idea is that you set an attached property on an element so that you can gain access to the element from the class that exposes the attached property. Once that class has access to the element, it can hook events on it and, in response to those events firing, make the element do things that it normally would not do. It is a very convenient alternative to creating and using subclasses, and is very XAML-friendly.”

…and that’s exactly what we’re going to do. We’re going to listen to one event in particular : “RecordUpdating” which fires when the user had edited an item and the control wants to submit the changes back to the data source. Here’s the part that does the validation:

private static void OnRecordUpdating(object sender, RoutedEventArgs e)
{
  var arg = (RecordUpdatingEventArgs)e;
  var dataobject = arg.Record.DataItem;
  var rules = GetAllInvalidRules(dataobject);
  var grid = (XamDataGrid)sender;

  if (rules != null && rules.Count > 0)
  {
      var propertyName = rules[0].PropertyPath;
      var propertyTitle = grid.DefaultFieldLayout.Fields[propertyName].Label;

      arg.Action = RecordUpdatingAction.CancelUpdateRetainChanges;
      arg.Record.Tag = string.Format("Check Field : {0}", propertyTitle);
  }
  else
  {
      arg.Record.Tag = null;
  }

  e.Handled = true;
}

Note : We only display one error at a time. If you need to display all of them at once, you can do so by changing the code a little bit.

We place the error information on the Record object’s Tag information. In our little RecordSelector style, we’ll display an error icon in case Tag property is set to some error information:

<Style TargetType="{x:Type igdp:RecordSelector}">
  <Setter Property="Template">
      <Setter.Value>
          <ControlTemplate TargetType="{x:Type igdp:RecordSelector}">
              <Image x:Name="ErrorIcon" Source="pack://application:,,,/GridValidation;component/Images/FieldError.png"
                 Width="16" Height="16" Margin="4,0,0,0" Visibility="Collapsed" ToolTip="{Binding Tag}" />
              <ControlTemplate.Triggers>
                  <DataTrigger Binding="{Binding Path=Tag, Converter={StaticResource DefaultNullConverter}}" Value="False">
                      <Setter TargetName="ErrorIcon" Property="Visibility" Value="Visible" />
                  </DataTrigger>
              </ControlTemplate.Triggers>
          </ControlTemplate>
      </Setter.Value>
  </Setter>
</Style>

One last thing that is remaining, is to connect our attached behavior to our xamDataGrid control. The great thing about the attached behaviors (one of them, at least) is that you can use them from XAML code directly and no code-behind is required at all. So back to our xamDataGrid code, here’s how to do the trick:

<igdp:XamDataGrid DataSource="{Binding ProductList}" bhv:DataGridValidationBehavior.HasRowValidation="true">

Conclusion

The final application looks like this picture. If you try to enter something wrong, either when creating a new item or editing one, validation mechanism will automagically kick in and does the work for you. The very important point is that data is retained in the new line but is it not added to the datasource, because the data is not validated.

You can download the source code from here. In order to fully compile and run the application, you need to install Infragistics WPF components which you can download here.

Infragistics WPF Reporting

2009-07-13T15:18:00.003+04:30

I’ve been looking for flexible Reporting components for the WPF application I’m working on, and strangely enough, there are just a few. I think WPF component in general is still a work in progress, and even if you have the chance to find a working component, there ALL have a lot of short comings and lack design-mode features, developer-friendliness, etc. and when it comes down to reporting component, there is Infragistics with very basic feature set, ComponentOne with years of background in reporting tools and Stimulsoft with complete reporting set for WinForm, WPF and Web.

So, I start evaluating each one. Stimusoft WPF reporting looked very promising with all bells and whistles like end-user WPF designer and the whole UI (designer and preview) were in WPF, but If I’m going to buy a component I need more that just a reporting tool, how about having bunch of other controls as well? I skipped to ComponentOne and after downloading their package (around 100 MB download), the damn installation did not work and I was staring at the installation error message that had to do something with packaging. So in reality, I had only one more choice : Infragistics.

Infragistics Reporting

With very basic feature, Infragistics reporting is also easy to use. Since there is no designer (yet?) you have to code your report and create various report sections (Header, Footer, etc.) and add related stuff into that sections, all in code. The great thing about this reporting control (also a feature of ComponentOne) is that you can print any kind of UIElement, this means you can print your whole UserControl or Form which comes in handy.

The real power of Infragistics reporting is when combined with their “Data Presenter” or “XamDataGrid” control. End-user can apply filtering, grouping, sorting, etc. and just print the result, easy as that.

RightToLeft Issue

When evaluating my application which is a multi-lingual application that supports RightToLeft and LeftToRight reading ordered languages, I came across a problem when printing controls with RightToLeft flow direction. The problem was that the whole control is “Mirrored”. Not that this mirroring is an issue, but all the texts and values printed are also mirrored which makes the whole report useless.

Workaround

The workaround is, of course, not to print the control in RightToLeft and use LeftToRight for the time being until the bug is fixed. As easy as this sounds, it is not very easy to do for some reasons:

RightToLeft is usually set on the parent (Form), and controls just “inherit” the setting from their parent.
If you do change parent’s RightToLeft end-user will see the effect.

But you can always clone the object and change the behavior, right? But you can not do so with Visual Elements. There’s no Copy / Clone method on Visual elements in WPF, so how do we “clone” the control, change the FlowDirection, and hand it to the reporting?

Fortunately, WPF comes with two neglected classes : “XamlWriter” and “XamlReader” each of which do as exactly as the name puts it. Using “XamlWriter” you can write a Visual object (UIElement) into a string, then use “XamlReader” ton construct it back. This is just about the UI, so you’ll have to re-attach the “DataSource” and “DataContext” you might have. Here’s the snippet to do the trick:

public XamDataGrid Clone(XamDataGrid printable)
{
  //Clone the grid control
  var o = XamlWriter.Save(printable);
  var sr = new StringReader(o);
  var reader = XmlReader.Create(sr, new XmlReaderSettings());
  var result = (XamDataGrid)XamlReader.Load(reader);

  //It's a clone, need to reassign data source
  result.DataSource = printable.DataSource;

  //Set flow direction to LTR
  result.FlowDirection = FlowDirection.LeftToRight;

  return result;
}

You can download the whole sample that shows the issue and the workaround. To compile and run it you need to have Infragistics 2009.1 installed. You can download Infragistics package here.

Additional CallContext information in WCF

2009-07-05T12:07:00.002+04:30

Yeah, this might be a little old…but someone asked me how to send context information from client to the service with WCF.

Note: In general, you should not rely on client provided information about security, authentication, licensing, etc. Use this code and sample as an idea on how to implement your custom security. If you’re trying to send sensitive information over the network, use at your own risk.

WCF client and services might be (and probably are) in two separate AppDomain or even on separate machines across the network, so how do we send extra information from the client to the service when the service call is made? Fortunately, WCF provides enough extensibility points for us to participate in the action and change the default behavior. It is pretty much easy to add context information to the message header on the client side, and the on the server side extract the custom data from the message header. Added data to the message header can be a DataContract / Serialized class.

[DataContract]
public class MessageInfo
{
   public MessageInfo(Guid sessionId, CultureInfo culture, DateTime requestDate)
   {
       this.sessionId = sessionId;
       this.culture = culture;
       this.requestDate = requestDate;
   }

   [DataMember]
   public DateTime RequestDate
   {
       get;
       set;
   }

   [DataMember]
   public Guid SessionId
   {
       get;
       set;
   }

   [DataMember]
   public CultureInfo Culture
   {
       get;
       set;
   }
}

Client uses IClientMessageInspector to add context data before the message is handed over to WCF for the delivery.

/// <summary>
/// Flows the client's MessageInfo to the service.
/// </summary>
public class ClientMessageInfoInspector : IClientMessageInspector
{
   public object BeforeSendRequest(ref Message request, IClientChannel channel)
   {
       request.Headers.Add(MessageHeader.CreateHeader(MessageHeaderKeys.MessageInfoKey, string.Empty, GetInfo()));
       return null;
   }

   public void AfterReceiveReply(ref Message reply, object correlationState)
   {
   }

   private MessageInfo GetInfo()
   {
       return new MessageInfo(Guid.NewGuid(), Thread.CurrentThread.CurrentUICulture, DateTime.Now);
   }
}

On the other hand, the service side uses IDispatchMessageInspector interface to extract the data from message header.

/// <summary>
/// Reads the MessageInfo of client and updates the service.
/// </summary>
public class ServiceMessageInfoInspector : IDispatchMessageInspector
{
   public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
   {
       int headerIndex = request.Headers.FindHeader(MessageHeaderKeys.MessageInfoKey, string.Empty);
       if (headerIndex != -1)
       {
           MessageInfo ui = request.Headers.GetHeader<MessageInfo>(headerIndex);
          
           Thread.CurrentThread.CurrentUICulture = ui.Culture;
           Thread.CurrentThread.CurrentCulture = ui.Culture;

            Console.WriteLine("Request recieved on {0}", ui.RequestDate);
       }

       return null;
   }

   public void BeforeSendReply(ref Message reply, object correlationState)
   {
   }
}

To wire things up, you also need to create a new behavior by implementing IEndpointBehavior and registering it with your endpoint, either by code, or configuration. Should you use a single behavior for both client and server, here’s how to do it:

public class MessageInfoBehavior : IEndpointBehavior
{
   public void Validate(ServiceEndpoint endpoint)
   {
   }

   public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
   {
   }

   public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
   {
       ServiceMessageInfoInspector inspector = new ServiceMessageInfoInspector();
       endpointDispatcher.DispatchRuntime.MessageInspectors.Add(inspector);
   }

   public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
   {
       ClientMessageInfoInspector inspector = new ClientMessageInfoInspector();
       clientRuntime.MessageInspectors.Add(inspector);
   }
}

Hope this helps.

File Download with ASP.NET MVC

2009-06-23T10:45:00.002+04:30

One of the things that might be less obvious when doing applications with ASP.NET MVC, is the ability to download files without exposing your files directly and possibly applying other mechanisms such as authentication or registering emails before allowing someone download your files. This is pretty much easy. The “Controller” class has a File method which returns a “FilePathResult”.

public class DownloadsController : Controller
{
    private readonly IProductService _productService;

    public DownloadsController(IProductService productService)
    {
        _productService = productService;
    }

    [SessionPerRequest]
    public ActionResult Index()
    {
        var products = _productService.GetDownloadableProducts();
        var model = new DownloadViewModel(products);

        return View(model);
    }

    [SessionPerRequest]
    public ActionResult File(int id)
    {
        var download = _productService.FindDownload(id);

        if (download != null)
        {
            var path = Server.MapPath(download.URL);
            var file = new FileInfo(path);
            if (file.Exists)
            {
                return File(download.URL, "application/binary", download.FileName);
            }
        }

        return RedirectToAction("Index");
    }
}

<table>
   
    <% foreach (var p in Model.Products) { %>
         <tr>
           <td>
             <strong><%= p.Title %></strong><br />
              
             <%foreach(var d in p.Downloads) { %>
               
                <a href="/Downloads/File/<%= d.Id %>">
                   Version: <%= d.Version %>- <%= d.DownloadSize %> KB
                </a>
                <br />
            <%} %>
               
           </td>
        </tr>
     <% } %>
    
</table>

NHibernate JetDriver : Another Issue

2009-05-26T10:50:00.003+04:30

There is another issue with NHibernate and JetDriver I encountered yesterday. It seems that a select query containing “Order By”, will gets its “From” keyword cut off at some stage by the Jet Driver. It means simple object querying won’t work:

public IList<Account> GetAllAccounts()
{
  using (UnitOfWork.Start())
  {
      var repository = new NHRepository<Account>();
      var orders = new[] { new Order("Firstname", true), new Order("Lastname", true) };

      return repository.FindAll(orders).ToList();
  }
}

To fix it, let’s first pin point the problem by creating a failing test. It was a good thing I was already running everything from the trunk build, so I opened up the JetDriver project (from NHContrib) and luckily there is already a test project. Note that, since I didn’t want to actually change any object / method visibility, I used reflection to call the private methods that fails this test:

[TestFixture]
public class JetOrderByFixture
{
  [Test]
  public void Select_Statement_With_OrderBy_Should_Run()
  {
      SqlString sql = new SqlString("SELECT * FROM ACCOUNTS ORDER BY Firstname ASC, Lastname ASC");
      JetDriver driver = new JetDriver();

      SqlString processedSql = driver.GetType()
                                     .GetMethod("FinalizeJoins", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod)
                                     .Invoke(driver, new object[] { sql }) as SqlString;

      Assert.That(processedSql, Is.Not.Null);
      Assert.That(processedSql.LastIndexOfCaseInsensitive("FROM"), Is.GreaterThan(0));
  }
}

The problem is the private FinalizeJoins method, so the test, to no surprise, fails. I have created a task in NHibernate’s Jira and the patch to fix this is attached, if you need it.

Unit Testing with TypeMock

2009-05-21T13:31:00.001+04:30

Unit Testing ASP.NET? ASP.NET unit testing has never been this easy.

Typemock is launching a new product for ASP.NET developers – the ASP.NET Bundle - and for the launch will be giving out FREE licenses to bloggers and their readers.

The ASP.NET Bundle is the ultimate ASP.NET unit testing solution, and offers both Typemock Isolator, a unit test tool and Ivonna, the Isolator add-on for ASP.NET unit testing, for a bargain price.

Typemock Isolator is a leading .NET unit testing tool (C# and VB.NET) for many ‘hard to test’ technologies such as SharePoint, ASP.NET, MVC, WCF, WPF, Silverlight and more. Note that for unit testing Silverlight there is an open source Isolator add-on called SilverUnit.

The first 60 bloggers who will blog this text in their blog and tell us about it, will get a Free Isolator ASP.NET Bundle license (Typemock Isolator + Ivonna). If you post this in an ASP.NET dedicated blog, you'll get a license automatically (even if more than 60 submit) during the first week of this announcement.

Also 8 bloggers will get an additional 2 licenses (each) to give away to their readers / friends.

Go ahead, click the following link for more information on how to get your free license.

NHibernate and DateTime

2009-05-20T16:20:00.003+04:30

I’ve been working on a WPF application which is maybe another post. The work is done and I have started localizing the applications. Localization was mostly chanding the FlowDirection and lables / texts for other languages, but when testing the application, I came across an intresting problem with Nhibernate. The application worked correctly in default (en-us) culture, but not in fa-ir, as NHibernate reported problems when running the working query. Here’s the problem:

[Test]
public void Can_Run_Query_In_Persian_Culture()
{
  using(new CultureContext(new PersianCultureInfo()))
  {
      using (UnitOfWork.Start())
      {
          var todayStart = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 0, 0, 0, CultureHelper.DefaultCalendar);
          var todayEnd = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 23, 59, 59, CultureHelper.DefaultCalendar);

          var queryable = UnitOfWork.CurrentSession.Linq<Purchase>();
          var query = from sales in queryable
                      where sales.PurchaseDate >= todayStart && sales.PurchaseDate <= todayEnd
                      select sales;

          Assert.DoesNotThrow(() => query.ToList());
      }
  }
}

The test which is totally working on other cultures, fails miserably in fa-ir. The reason is somewhere in the criteria parameter being converted to string. Here’s the output of the query being run on the database:

[SELECT this_.PurchaseId as PurchaseId4_0_, this_.PaidValue as PaidValue4_0_, this_.PurchaseDate as Purchase3_4_0_, this_.Quantity as Quantity4_0_, this_.IsOwed as IsOwed4_0_, this_.Product_id as Product6_4_0_, this_.PurchaseRegisteredBy_id as Purchase7_4_0_, this_.Purchaser_id as Purchaser8_4_0_ from `Purchase` this_ WHERE (this_.PurchaseDate >= ? and this_.PurchaseDate <= ?) ]

Positional parameters: #0>1388/02/30 12:00:00 ق.ظ #1>1388/02/30 11:59:59 ب.ظ

It is obvious that date values are converted to String using current Culture of the running thread, while the conversion should use invariant culture instead:

WRONG:

var dateValue = todayStart.ToString();

RIGHT:

var dateValue = todayStart.ToString(CultureInfo.InvariantCulture);

Any workaround for this? I haven’t found any yet. In fact I still do not exactly know if this is NH core problem or the Linq extensions and since I’m running from the trunk, I’m not sure if this is reproducible on released versions.

Update : The problem was actually related to JET Driver of NHibernate Contrib project. A patch is created and sent to authorities.

MVVM Validation With NHibernate Validator

2009-05-16T13:19:00.003+04:30

Simplest way to do Validation in WPF is usually implementing IDataErrorInfo interface, and do the validation in the indexer’s getter. It turns out to be ugly and gets out of hand when your model gets a little larger. Implementing the IDataErrorInfo is as simple as this:

public string this[string propertyName]
{
  get
  {
      //Validate property that is being set,
      //and return an error message if there's
      //any error.

      return null;
  }
}

public string Error
{
  get { return string.Empty; }
}

I intend to use NHibernate Validator attributes to add non-intrusive validation to my ViewModel classes. So you’d just decorate properties of your ViewModel and let WPF and NHibernate Validator do the rest for you. Before we do that, let’s create a more elegant way to show the errors by restyling the TextBox control and add an Error Icon and tooltip to it in case of an error existing:

<Style TargetType="{x:Type TextBox}">
   <Setter Property="Validation.ErrorTemplate">
       <Setter.Value>
           <ControlTemplate>
               <DockPanel LastChildFill="True">
                   <Image x:Name="ErrorIcon" Source="Images/FieldError.png" DockPanel.Dock="Right" Width="16" Height="16" Margin="4,0,0,0" />
                   <Border BorderBrush="Red" BorderThickness="1">
                       <AdornedElementPlaceholder />
                   </Border>
               </DockPanel>
           </ControlTemplate>
       </Setter.Value>
   </Setter>
   <Style.Triggers>
       <Trigger Property="Validation.HasError" Value="true">
           <Setter Property="ToolTip" Value="{Binding RelativeSource={RelativeSource Self}, Path=(Validation.Errors)[0].ErrorContent}"/>
       </Trigger>
   </Style.Triggers>
</Style>

Now that styles are all set, let’s configure NHibenrate Validator’s engine on application startup. Nothing fancy, just straightforeward configuration. We’ll use a shared validation engine:

public void RegisterValidatorEngine()
{
  var config = new NHVConfigurationBase();

  config.Properties[Environment.ApplyToDDL] = "false";
  config.Properties[Environment.AutoregisterListeners] = "true";
  config.Properties[Environment.ValidatorMode] = "UseAttribute";
  config.Properties[Environment.SharedEngineClass] = typeof(ValidatorEngine).FullName;
  config.Mappings.Add(new MappingConfiguration(DomainAssemblyName, null));

  Environment.SharedEngineProvider = new NHibernateSharedEngineProvider();
  Environment.SharedEngineProvider.GetEngine().Configure(config);

  ValidatorInitializer.Initialize(NHibernateConfig);
}

And to make things reusable, why not create a base ViewModel:

public abstract class ValidatableViewModel : IDataErrorInfo
{
  private readonly ValidatorEngine validation;

  protected ValidatableViewModel()
  {
      validation = Environment.SharedEngineProvider.GetEngine();
  }

  public string this[string propertyName]
  {
      get
      {
          var rules = GetInvalidRules(propertyName);
          if (rules != null && rules.Count > 0)
          {
              return rules[0].Message;
          }

          return null;
      }
  }

  public string Error
  {
      get { return string.Empty; }
  }

  public IList<InvalidValue> GetInvalidRules(string propertyName)
  {
      var type = this.GetType();

      return validation.ValidatePropertyValue(type, propertyName, GetPropertyValue(type, propertyName));
  }

  public IList<InvalidValue> GetAllInvalidRules()
  {
      return validation.Validate(this);
  }

  private object GetPropertyValue(Type objectType, string properyName)
  {
      return objectType.GetProperty(properyName).GetValue(this, null);
  }
}

The rest is just to inherit the ValidatableViewModel and add necessary attributes to our binded properties. A sample ViewModel containing a Save command, which is invocable only when there’s no error on the model and a couple of other business properties would look like this:

public class NewAccountViewModel : ValidatableViewModel, INotifyPropertyChanged
{
  private string _firstName;
  private string _lastName;
  private string _currentBalance;

  [NotNullNotEmpty]
  public string Firstname
  {
      get { return _firstName; }
      set
      {
          _firstName = value;
          this.Notify(this.PropertyChanged, o => o.Firstname);
      }
  }

  [NotNullNotEmpty]
  public string Lastname
  {
      get { return _lastName; }
      set
      {
          _lastName = value;
          this.Notify(this.PropertyChanged, o => o.Lastname);
      }
  }

  [IsNumeric]
  [NotNullNotEmpty]
  public string CurrentBalance
  {
      get { return _currentBalance; }
      set
      {
          _currentBalance = value;
          this.Notify(this.PropertyChanged, o => o.CurrentBalance);
      }
  }

  public event PropertyChangedEventHandler PropertyChanged = delegate { };

  private ICommand _cmdSave;
  public ICommand SaveCommand
  {
      get
      {
          if (_cmdSave == null)
              _cmdSave = new RelayCommand(Save, CanSave);

          return _cmdSave;
      }
  }

  public void Save()
  {
      MessageBox.Show("Save");
  }

  public bool CanSave()
  {
      return GetAllInvalidRules().Count == 0;
  }
}

<UserControl x:Class="Jimba.UI.View.NewAccountView"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

  <StackPanel>
    
      <StackPanel Orientation="Horizontal">
          <Label Width="100">Firstname:</Label>
          <TextBox Text="{Binding Path=Firstname, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />
      </StackPanel>

      <StackPanel Orientation="Horizontal">
          <Label Width="100">Lastname:</Label>
          <TextBox Text="{Binding Path=Lastname, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />
      </StackPanel>

      <StackPanel Orientation="Horizontal">
          <Label Width="100">Current Balance:</Label>
          <TextBox Text="{Binding Path=CurrentBalance, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />
      </StackPanel>
    
  </StackPanel>

</UserControl>

ASP.NET MVC Validation with Ajax and Json

2009-05-03T14:42:00.004+04:30

ASP.NET MVC has greate ajax integration with no doubt. Simply by using ajax forms you can use partial page rendering and controller callbacks. One thing that will break if you switch to Ajax / JsonResult is the built-in Validation result (ModelErrors) rendering of the MVC engine.

It won’t work because of a simple fact: The built-in validation will take place when the page is being rendered on the server. When you use ajax and callbacks page will not re-render on the server-side, hence validation can not mark fields with error and add validation information to the already rendered page.

Let’s see how you can do this, without using a client-side validation framework.

Creating a Contact Form

First, let's create a form using Ajax.BeginForm and provide a javascript action to process the results. You can get rid of the ValidationMessage and ValidationSummary, since we don’t need it anymore:

<% using (Ajax.BeginForm(new AjaxOptions { OnComplete = "ProcessResult" })) { %>
    <p>
   <label for="Name" class="contactLabel">Your Name:</label>
   <%= Html.TextBox("SenderName", Model.SenderName)%>
    </p>
<p>
   <label for="Email" class="contactLabel">Your Email:</label>
   <%= Html.TextBox("Email", Model.Email)%>
    </p>
<p>
   <label for="Subject" class="contactLabel">Subject:</label>
   <%= Html.TextBox("Subject", Model.Subject)%>
    </p>
<p>
   <label for="Message" class="contactLabel">Message:</label>
   <%= Html.TextBox("Message", Model.Message)%>
    </p>
<p>
   <br />
   <input type="submit" value="Send" class="inputButton" />
   <br />
</p>
<div id="operationMessage"><ul></ul></div>
<% } %>

Notice that there is a div at the bottom which acts as an error placeholder and will be used to display validation information.

To actually bind these fields to data, we need to create an POCO class acting as a backing entity. In this example, I’ve used a poco class and decorate it with NHibernate Validator's attributes to do the validation. See here for more info on how to configure NHibernate Validator using ASP.NET MVC:

public class ContactMessage : IValidatable
{
public ContactMessage()
{
   MessageDate = DateTime.Today;
}

public virtual int Id
{
   get; private set;
}

[NotNullNotEmpty]
public virtual string SenderName
{
   get; set;
}

[NotNullNotEmpty]
[Email]
public virtual string Email
{
   get; set;
}

[NotNullNotEmpty]
public virtual string Subject
{
   get; set;
}

[NotNullNotEmpty]
public virtual string Message
{
   get; set;
}

public virtual DateTime MessageDate
{
   get; private set;
}
}

Controller Action

Two methods are needed to handle to Post / Get separately. Our Get method returns a new instance of our contact entity to the view, and Post method is where the operation results is returned to the client using Json. The OperationResultInfo class containing the elaborate error information is what returned as Json to the client:

public class OperationResultInfo
{
public OperationResultInfo()
{
   Errors = new List<ErrorReasonInfo>();
}

public bool Successfull { get; set; }

public string Message { get; set; }

public IList<ErrorReasonInfo> Errors { get; set; }
}

public class ErrorReasonInfo
{
public string PropertyName { get; set; }

public string Error { get; set; }
}

[AcceptVerbs(HttpVerbs.Get)]
public ActionResult Contact()
{
return View(new ContactMessage());
}

[AcceptVerbs(HttpVerbs.Post)]
[AutoValidate]
public ActionResult Contact(ContactMessage msg)
{
if (ModelState.IsValid)
{
   try
   {
       this.messengerService.SendMail(msg);

       return Json(new OperationResultInfo
                   {
                       Successfull = true,
                       Message = "Thank you. Your message was sent successfully."
                   });
   }
   catch (Exception ex)
   {
       ModelState.AddUnhandledError(ex);
       return Json(new OperationResultInfo
                   {
                       Successfull = false,
                       Message = "There was an error processing your request. Retry later."
                   });
   }
}

return Json(new OperationResultInfo
           {
               Successfull = false,
               Message = "Could not send your information.",
               Errors = ModelState.GetAllErrors()
           });
}

public static class ModelStateExtensions
{
public static IList<ErrorReasonInfo> GetAllErrors(this ModelStateDictionary modelState)
{
   var errors = new List<ErrorReasonInfo>();

   foreach (var state in modelState)
   {
       if (state.Value.Errors.Count > 0)
       {
           var err = new ErrorReasonInfo {PropertyName = state.Key};
           state.Value.Errors.ForEach(x => err.Error += x.ErrorMessage);

           errors.Add(err);
       }
   }

   return errors;
}
}

Displaying The Json Result
The Json result returned to the client contains all the fields having errors and the related error message. A typical result would look like this:

{
"Successfull":false,
"Message":"Could not send your information:",
"Errors":[
{"PropertyName":"SenderName",
"Error":"may not be null or empty"},
{"PropertyName":"Email",
"Error":"may not be null or empty"},
{"PropertyName":"Subject",
"Error":"may not be null or empty"},
{"PropertyName":"Message",
"Error":"may not be null or empty"}]
}

How do we format this data on the client and display it in a user-friendly fashion on our page? Let’s process the Json object using javascript and add the result to the error place holder using jQuery:

<script type="text/javascript">
function ProcessResult(content) {

   var json = content.get_response().get_object();
   var result = eval(json);

   $("#operationMessage > span").empty();
   $("#operationMessage > ul").empty();
   $(':input').removeClass('input-validation-error');

   if (result.Successfull) {
       $('#operationMessage').append('<span>' + result.Message + '</span>')
                             .removeClass('error')
                             .addClass('success');
   }
   else {

       $('#operationMessage').append('<span><br>' + result.Message + '</span>')
                             .removeClass('success')
                             .addClass('error');

       for (var err in result.Errors) {
           var propertyName = result.Errors[err].PropertyName;
           var errorMessage = result.Errors[err].Error;
           var message = propertyName + ' ' + errorMessage;

           $('#' + propertyName).addClass('input-validation-error');
           $('#operationMessage > ul').append('<li># ' + message + '</li>');
       }
   }
}
</script>

Pretty neat, ha? Hope this helps.

Google Analytics in Silverlight

2009-04-29T12:26:00.002+04:30

I’ve been trying to setup Google Analytics Event Tracking in a Silverlight application for a while and despite all the how-tos and artilces on the web, I just couldn’t get it running. I kept doing everything proposed, but when the application was run on IE, a javascript error was occurred. Firefox didn’t even bother reporting the JS error. So, if you happen to have the same problem, here’s how you should do it to get it working.

Event Tracking is when you want to track users accessing various parts of you RIA application, which works differently comparing to html based websites. The basic setup is almost the same: include ga.js javascript on your page hosting the Silverlight application. Include this snippet before </body> tag:

<script type="text/javascript">
   var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
   document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>

Next step would be to create a helper javascript function which we’ll call in our silverlight application. The script would help us track events on our silverlight application. Add this just below the above script:

<script type="text/javascript">
   function trackPage(category, action, label) {
       try {
           var pageTracker = _gat._getTracker("xx-xxxxxxxx-x");
           pageTracker._trackPageview();
           pageTracker._trackEvent(category, action, label);
       }
       catch (err) {
       }
   }
</script>

It is essential that calls to_trackPageview is made prior to calling _trackEvent.

Notice how the function is wrapped in a try-catch block so if there is any issues with ga.js loading, we silently ignore the tracking. Strangely, when there was any javascript error in IE 8, some parts of my silverlight application didn’t work properly. This helped getting around it.

Usually, you’d call an existing javascript in your silverlight app by calling it this way:

HtmlPage.Window.Invoke("functionName", new[] { args });

But to make things easier, let’s create an extension method to help us calling the tracking function:

public static class ViewExtension
{
   public static void Track(this UserControl view, string action, string page, string label)
   {
       HtmlPage.Window.Invoke("trackPage", new string[] { action, page, label });
   }
}

Just need to start tracking now!

NHibernate Automatic Validation

2009-04-28T13:15:00.004+04:30

NHibernate is for sure one of the prodigy childs of the .NET open-source movement, yet there are some other great libraries and frameworks. One of them is NHibernate Validator which belongs to NHibernate Contrib project. What it does is to validate your domain entities that supposedly are being persisted using NHibernate, but it provides so much flexibility that you can validate almost every POCO class using attributes.

I’m using it in an ASP.NET MVC project, so first let’s see how to configure and make it work here.

Note: I’m using the trunk build of the Castle Project.

First thing you need to do is to initialize Validator’s engine. Since I’m using it on a web application, let’s initialize and use a shared engine. I’m using the attribute based validation, but you can write the validation logic in your .hbm mapping files.

public class MvcApplication : System.Web.HttpApplication, IMvcApplication
{
  protected void Application_Start()
  {
      RegisterRoutes(RouteTable.Routes);
      CreateDependencyInjectionContainer();
      RegisterControllerFactory();
      RegisterSessionFactory();
      RegisterValidatorEngine();
  }

  private void RegisterValidatorEngine()
  {
      var config = new NHVConfigurationBase();

      config.Properties[Environment.ApplyToDDL] = "false";
      config.Properties[Environment.AutoregisterListeners] = "true";
      config.Properties[Environment.ValidatorMode] = "UseAttribute";
      config.Properties[Environment.SharedEngineClass] = typeof (ValidatorEngine).FullName;
      config.Mappings.Add(new MappingConfiguration("MyApp.Domain", null));

      Environment.SharedEngineProvider = new NHibernateSharedEngineProvider();
      Environment.SharedEngineProvider.GetEngine().Configure(config);

      ValidatorInitializer.Initialize(NHibernateConfig);
  }
}

and that’s it. You can validate entities passed to your controller’s action by creating a extension method which simplifies things and automatically adds all the errors to ModelState:

public static class ControllerExtensions
{
  /// <summary>
  /// Validates an entity
  /// </summary>
  /// <param name="controller"></param>
  /// <param name="entity"></param>
  public static void Validate(this Controller controller, IValidatable entity)
  {
      var engine = Environment.SharedEngineProvider.GetEngine();
      var errors = engine.Validate(entity);

      foreach (var error in errors)
      {
          controller.ModelState.AddModelError(error.PropertyName, error.Message);
      }
  }
}

Note that IValidatable is just a marker interface. To call this method and do the actual validation, you need to call the validate method:

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Contact(ContactMessage msg)
{
  try
  {
      this.Validate(msg);

      if (ModelState.IsValid)
      {
          this.messengerService.SendMail(msg);
          return RedirectToAction("Index");
      }
  }
  catch (Exception ex)
  {
      ModelState.AddUnhandledError(ex);
  }

  return View(msg);
}

Easy, right? but it can even get easier! Let’s create an ActionFilter to automagically validate our parameters when the action is invoked:

/// <summary>
/// Automatically validates all the action
/// parameters of type IValidatable.
/// </summary>
public class AutoValidate : ActionFilterAttribute
{
  public override void OnActionExecuting(ActionExecutingContext filterContext)
  {
      var controller = filterContext.Controller as Controller;
      if(controller == null)
          return;

      foreach (var entity in GetEntitiesFromParameters(filterContext.ActionParameters))
      {
          controller.Validate(entity);
      }
  }

  private static IEnumerable<IValidatable> GetEntitiesFromParameters(IEnumerable<KeyValuePair<string, object>> dictionary)
  {
      var validatableParameters = new List<IValidatable>();

      foreach (var keyValue in dictionary)
      {
          if(keyValue.Value is IValidatable)
          {
              validatableParameters.Add((IValidatable)keyValue.Value);
          }
      }

      return validatableParameters;
  }
}

and your action method looks as simple as this:

[AcceptVerbs(HttpVerbs.Post)]
[AutoValidate]
public ActionResult Contact(ContactMessage msg)
{
  if(ModelState.IsValid)
  {
      try
      {
          this.messengerService.SendMail(msg);
          return RedirectToAction("Index");
      }
      catch (Exception ex)
      {
          ModelState.AddUnhandledError(ex);
      }
  }

  return View(msg);
}

Have fun validating!

Code Review No. N, or Do chimps write code better than us?

2009-04-28T11:33:00.002+04:30

Well, this is not actually my first code review, but this is supposed to be a copycat of “Code Review WTF, Number N” series by Ayende Rahien.

I was inspecting an open-source code base which is a medical business application. So why am I reviewing the code base? I had a request to add persian calendar support to this application and I was trying to figure out how much time does this take and if it is possible.

There are very serious issues here, I even don’t know where to start! For a open-source project at its 6th version, I was hoping things to be pretty much solid. Apparantly with all the bells and whistles on developer’s website, it is not.

Using a strange naming convension for your project like xCodeBase, xODR is BAD.
Having A LOT of commented code in your code base is BAD.
Exposing class fields as public is BAD. use properties.
Using IFs to check for database type EVERYWHERE is VERY BAD.
Obfuscated class and method names are BAD. (as in Lan class which does the string translation job with public methods named g, F and C)!!
Wrapping remote method names in an ENUM. What are you thinking?!

After going through some of the classes, I think I’m going crazy! Okay, let’s see how’s the business logic being handled. That’s the major part of the application, right?

Data is accessed by DataCore class in server AND client side (depending if remoting is used), which retrieves the data in an UnTyped dataset. To make things easier(?) there’s one single method to invoke remote BusinessLayer implementation methods:

public static DataSet GetDsByMethod(MethodNameDS methodName, object[] parameters)
{
   switch (methodName)
   {
       default:
           throw new ApplicationException("MethodName not found");
       case MethodNameDS.AccountModule_GetAll:
           return AccountModules.GetAll((int)parameters[0], (bool)parameters[1], (DateTime)parameters[2], (DateTime)parameters[3], (bool)parameters[4]);
       case MethodNameDS.Appointment_GetApptEdit:
           return Appointments.GetApptEdit((int)parameters[0]);
       case MethodNameDS.Cache_Refresh:
           return Cache.Refresh((string)parameters[0]);
       case MethodNameDS.CovCats_RefreshCache:
           return CovCats.RefreshCache();
   }
}

public enum MethodNameDS
{
   AccountModule_GetAll,
   Appointment_GetApptEdit,
   Cache_Refresh,
   CovCats_RefreshCache,
}

Dude! WTF is that?! and then there’s a similar method to work with DataTables!

On the server where client requests are processed, data is being serialized / deserialzed by a “WorkerClass” class. The code to perform the client’s request is what makes me wonder!

public class WorkerClass
{
   private NetworkStream netStream;

   // The constructor obtains the state information.
   public WorkerClass(NetworkStream stream)
   {
       netStream = stream;
   }

   public void DoWork()
   {
   while(true) {//Each loop gets and returns one message pair.
       byte[] data =  null;
       // Retrieve data from client
       try {
           data = RemotingClient.ReadDataFromStream(netStream);
       }
       catch {//if connection was closed by client.
           break;
       }
       DataTransferObject dto=DataTransferObject.Deserialize(data);
       //Process and send response to client--------------------------------------
       XmlSerializer serializer;
       using (MemoryStream memStream = new MemoryStream()) {
           try {
               Type type = dto.GetType();
               if (type == typeof(DtoGetDS)) {
                   DataSet ds = DataCore.GetDsByMethod(((DtoGetDS)dto).MethodNameDS, ((DtoGetDS)dto).Parameters);
                   serializer = new XmlSerializer(typeof(DataSet));
                   serializer.Serialize(memStream, ds);
               }
               else if (type == typeof(DtoGetTable)) {
                   DataTable tb = DataCore.GetTableByMethod(((DtoGetTable)dto).MethodNameTable, ((DtoGetTable)dto).Parameters);
                   serializer = new XmlSerializer(typeof(DataTable));
                   serializer.Serialize(memStream, tb);
               }
               else if (type.BaseType == typeof(DtoCommandBase)) {
                   int result = BusinessLayer.ProcessCommand((DtoCommandBase)dto);
                   DtoServerAck ack = new DtoServerAck();
                   ack.IDorRows = result;
                   serializer = new XmlSerializer(typeof(DtoServerAck));
                   serializer.Serialize(memStream, ack);
               }
               else if (type.BaseType == typeof(DtoQueryBase)) {
                   DataSet ds = BusinessLayer.ProcessQuery((DtoQueryBase)dto);
                   serializer = new XmlSerializer(typeof(DataSet));
                   serializer.Serialize(memStream, ds);
               }
               else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(FactoryTransferObject<>)) {
                   // Pass the DTO to the FactoryServer<T>
                   Type factoryServerType = typeof(FactoryServer<>);
                   factoryServerType = factoryServerType.MakeGenericType(type.GetGenericArguments());

                   MethodInfo processCommandMethod = factoryServerType.GetMethod("ProcessCommand", BindingFlags.Public | BindingFlags.Static);
                   processCommandMethod.Invoke(null, new object[] { memStream, dto });
               }
               else {
                   throw new NotSupportedException(string.Format(Resources.DtoNotSupportedException, type.FullName));
               }
           }
           catch (Exception e) {
               DtoException exception = new DtoException();
               exception.Message = e.Message;
               serializer = new XmlSerializer(typeof(DtoException));
               serializer.Serialize(memStream, exception);
           }
           data = memStream.ToArray();
           RemotingClient.WriteDataToStream(netStream, data);
       }
   }//wait for the next message
   //connection was lost.  Client probably closed program
   netStream.Close();
}

The code is so full of anti-patterns that I wonder how it even works. But wait…I just saw a Unit Test project! Something good, finally, eh? But nah….It is a WinForm application and the test code looks like this:

private void FormUnitTests_Load(object sender, EventArgs e)
{
   BenefitComputeRenewDate();
   ToothFormatRanges();
   //LabDueDate();
   textResults.Text += "Done.";
   textResults.SelectionStart = textResults.Text.Length;
}

private void BenefitComputeRenewDate()
{
   DateTime asofDate = new DateTime(2006, 3, 19);
   bool isCalendarYear = true;
   DateTime insStartDate = new DateTime(2003, 3, 1);
   DateTime result = BenefitLogic.ComputeRenewDate(asofDate, isCalendarYear, insStartDate);
   if (result != new DateTime(2006, 1, 1))
   {
       textResults.Text += "BenefitComputeRenewDate 1 failed.\r\n";
   }
   isCalendarYear = false; //for the remaining tests
   //earlier in same month
   result = BenefitLogic.ComputeRenewDate(asofDate, isCalendarYear, insStartDate);
   if (result != new DateTime(2006, 3, 1))
   {
       textResults.Text += "BenefitComputeRenewDate 2 failed.\r\n";
   }
   //earlier month in year
   asofDate = new DateTime(2006, 5, 1);
   result = BenefitLogic.ComputeRenewDate(asofDate, isCalendarYear, insStartDate);
   if (result != new DateTime(2006, 3, 1))
   {
       textResults.Text += "BenefitComputeRenewDate 3 failed.\r\n";
   }
}

I think that’s enough proof for one day. You probably have heard the saying: “Even a chimp can write code”, but sometimes it’s like: “Even chimp writes code better than that”.

Dynamically Generated Images with ASP.NET MVC

2009-04-26T15:57:00.002+04:30

For a site I’m working on using ASP.NET MVC, I intended to place a Date badge beside the blog and news posts I’m writing. Since in ASP.NET MVC there’s no notion of custom controls (well, at least not like in WebForms) you’ll have to do this manually, but as it turned out it was pretty easy to do.

What I needed to do was to convert a Date instance, e.g. 04.23.2009 to a user friendly calendar icon like this one:

I’ve seen blogs and site using different icon for each day of the month or a similar trick to do this, but why not actually render it using Graphics API and a picture?

The first step was to decide what should be returned in you Controller’s action method, as the action result? Since there’s nothing that returns an Image as the result, let’s create one:

public class ImageResult : ActionResult
{
  public Image Image
  {
      get; set;
  }

  public ImageFormat ImageFormat
  {
      get; set;
  }

  private static Dictionary<ImageFormat, string> FormatMap
  {
      get; set;
  }

  static ImageResult()
  {
      CreateContentTypeMap();
  }

  public override void ExecuteResult(ControllerContext context)
  {
      if (Image == null) throw new ArgumentNullException("Image");
      if (ImageFormat == null) throw new ArgumentNullException("ImageFormat");

      context.HttpContext.Response.Clear();
      context.HttpContext.Response.ContentType = FormatMap[ImageFormat];

      Image.Save(context.HttpContext.Response.OutputStream, ImageFormat);
  }

  private static void CreateContentTypeMap()
  {
      FormatMap = new Dictionary<ImageFormat, string>
      {
          { ImageFormat.Bmp,  "image/bmp"                },
          { ImageFormat.Gif,  "image/gif"                },
          { ImageFormat.Icon, "image/vnd.microsoft.icon" },
          { ImageFormat.Jpeg, "image/Jpeg"               },
          { ImageFormat.Png,  "image/png"                },
          { ImageFormat.Tiff, "image/tiff"               },
          { ImageFormat.Wmf,  "image/wmf"                }
      };
  }
}

pretty easy, ha? You just need to specify the image and the format and it is rendered to the HttpContext as an image. The controller action to render the text would something like this:

public ActionResult GetCalendarBadge(DateTime displayDate)
{
  Graphics graphics = ?;
  Bitmap bmp = ?;

  //Draw using graphics

  //Direct the output to the bitmap

  return new ImageResult { Image = bmp, ImageFormat = ImageFormat.Png };
}

and on the view:

<% foreach(var item in this.Model.News) %>
     <%= Html.Image<NewsController>(o => o.GetCalendarBadge(item.DisplayDate), 100, 100) %>

<% } %>

Now, to make things easier, let’s use an existing bitmap as our canvas and just draw the values on it. To do this, add an existing image to your project and load it. The rest is just GDI API that renders the date values according to user’s Cultural setting.

public ActionResult GetCalendarBadge(DateTime displayDate)
{
  var bmp = Images.Calendar;
  var g = Graphics.FromImage(bmp);

  using (var genericFormat = GetStringFormat())
  {
      var yearRect = new Rectangle(24, 13, 40, 15);
      var dayOfMonthRect = new Rectangle(10, 29, 70, 44);
      var dayNameRect = new Rectangle(10, 30, 70, 10);
      var monthNameRect = new Rectangle(10, 61, 70, 10);

      using(var headerFont = new Font("Tahoma", 7.5f, FontStyle.Regular))
      using(var footerFont = new Font("Tahoma", 7.5f, FontStyle.Regular))
      using (var dayFont = new Font("Tahoma", 14, FontStyle.Bold))
      {
          var day = CurrentCulture.Calendar.GetDayOfMonth(displayDate).ToString();
          var month = CurrentCulture.Calendar.GetMonth(displayDate);
          var year = CurrentCulture.Calendar.GetYear(displayDate).ToString();
        
          var weekDay = CurrentCulture.Calendar.GetDayOfWeek(displayDate);
          var dayName = CurrentCulture.DateTimeFormat.GetDayName(weekDay);
          var monthName = CurrentCulture.DateTimeFormat.GetAbbreviatedMonthName(month);
        
          g.DrawString(year, headerFont, Brushes.White, yearRect, genericFormat);
          g.DrawString(day, dayFont, Brushes.Black, dayOfMonthRect, genericFormat);
          g.DrawString(dayName, footerFont, Brushes.Black, dayNameRect, genericFormat);
          g.DrawString(monthName, footerFont, Brushes.Black, monthNameRect, genericFormat);
      }
  }

  return new ImageResult { Image = bmp, ImageFormat = ImageFormat.Png };
}

Note that CurrentCulture property returns the running user’s CultureInfo which will help “translating” the date value correctly for different Cultures. What we achieved is a nice calendar badge with render date values and it is not even constrained to our Canvas size. Hope this helps.

Using Windsor IoC in ASP.NET MVC

2009-04-26T15:30:00.001+04:30

With the power of an IoC engine, you can inject your repositories, services, etc. when building applications using ASP.NET MVC framework. Since one of the best IoC engines out there IMHO is Castle Windsor using it has become natural more than ever, but as soon as I did, strange problems occurred when testing very simple scenarios. Two major pains were:

Model Binders
ModelBinders automatically bind form values to your object properties. When using Windsor, I noticed that almost all the parameter values are null when passed to the controller action.

Parameter Values
When a controller action was called with a parameter for the first time, all subsequent calls somehow cached the parameter values. Type and Value of the parameter has no effect, and even disabling caching didn’t work.

I’ve been pulling my hair for a couple of days (yeah, I kinda went bald because of this) before I figure this out, and when I thinking about it, the reason of this behavior is clearly obvious!

Windsor uses Singleton lifetime for registered services. All you need to do when registering controllers, is to use Transient lifetime!

Container.Register(AllTypes.FromAssemblyContaining<MvcApplication>()
                           .Where(o => o.Namespace == typeof(HomeController).Namespace)
                           .Configure(o => o.LifeStyle.Is(LifestyleType.Transient)));

Problem solved, Case closed!

ASP.NET MVC : Best way to go?

2009-04-23T11:17:00.001+04:30

With total control over html rendering in ASP.NET MVC there are a lot of things you can do, and this actually is correct the other way around, meaning you have to do a lot of things yourself: No fancy ASP.NET Custom Controls. It somehow reminds me of the old days, when you had to do everything to display a list of data. Back then, everything seemed manual. You had to emit html, control page state, etc. but with the rise of ASP.NET everything was amazingly done for you behind the scene. You no longer had to waste your time on the basics and you could focus on the problem at hand. Great, right?

Now with ASP.NET MVC, you might think we’re back where we started, but I wouldn’t go that far. While ASP.NET MVC offers control, maintainability and simplicity it also provides you Separation of Concerns which [ is one of the things that] was lacking in Classic ASP.

The question is, should you use it, instead of well established ASP.NET WebForms? That depends. Are you working on a greenfield project? Are you eager to learn the new stuff? Are you looking for more control and power on what the actual html outcome is? If you answer yes to these questions then you definitely need to use ASP.NET MVC for your project.

ASP.NET MVC and Testing FilterActions

2009-04-22T12:50:00.002+04:30

I’m preparing my website, which benefits NHibernate and ASP.NET MVC so I finally got a chance to actually do something with this nice pair. Since the pattern of SessionPerRequest and TransactionPerRequest is useful, I intended to automagically create a new session upon activating my Controller’s action, where necessary, since this will make your session management code separate from your controller’s code and you no longer need to worry about it. This part is very easy to do thanks to ActionFilterAttributes in ASP.NET MVC:

public class TransactionPerRequest : ActionFilterAttribute
{
   public override void OnActionExecuting(ActionExecutingContext filterContext)
   {
       NHibernateSessionHolder.Current.BeginTransaction();
   }

   public override void OnResultExecuted(ResultExecutedContext filterContext)
   {
       if(filterContext.Exception == null)
       {
           Commit();
       }
       else
       {
           Rollback();
       }
   }

   protected virtual void Commit()
   {
       if (NHibernateSessionHolder.Current.Transaction.IsActive)
       {
           NHibernateSessionHolder.Current.Transaction.Commit();
       }
   }

   protected virtual void Rollback()
   {
       if (NHibernateSessionHolder.Current.Transaction.IsActive)
       {
           NHibernateSessionHolder.Current.Transaction.Rollback();
       }           
   }
}

NHibernateSessionHolder is actually a static class and is initialized in Global.asax when application is started. Is stores the session in current HttpContext object.

So, how do we test this, you might ask? This leads to another question that how do you generally test ActionFilterAttributes? There are two ways to achieve this.

If you can test the filter attribute’s behavior in your controller, the easiest way would be to directly call the action on the controller. You need to create the route values and use the ControllerActionInvoker to call the action of your controller. Also mocking HttpContext is preferred for obvious reasons. My test case would look like this:

[TestMethod]
public void Transaction_Is_Automatically_Opened_Using_Transaction_Per_Request()
{
   var httpContext = new Mock<HttpContextBase>().Object;
   var controller = new AccountController();
   var controllerContext = new ControllerContext(httpContext, controller.GetCreateActionRouteData(), controller);
   var controllerInvoker = new ControllerActionInvoker();
  
   controllerInvoker.InvokeAction(controllerContext, "Create");

   Assert.IsTrue(controller.TransactinWasCreated);
}

But sometimes, you need to test the internal behavior of your filter attribute and it would not be possible doing so in your Controller classes. Let’s say, you want to check if the OnResultExecuted method handles exception properly by rolling back the transaction. To do it this way, you need to create or mock ActionExecutingContext and ResultExecutedContext:

[TestMethod]
public void Transaction_Is_Automatically_Rolled_Back_If_Exception_Thrown()
{
   var httpContext = new Mock<HttpContextBase>().Object;
   var actionDescriptor = new Mock<ActionDescriptor>().Object;
   var actionResult = new Mock<ActionResult>().Object;

   var controller = new AccountController();
   var controllerContext = new ControllerContext(httpContext, new RouteData(), controller);
   var filterContext = new ActionExecutingContext(controllerContext, actionDescriptor, new RouteValueDictionary());
   var resultContext = new ResultExecutedContext(controllerContext, actionResult, false, new Exception("an exception is thrown"));
   var transactionAttrib = new TestableTransactionAttribute();

   transactionAttrib.OnActionExecuting(filterContext);
   transactionAttrib.OnResultExecuted(resultContext);

   Assert.IsFalse(NHibernateSessionHolder.Current.Transaction.IsActive);
   Assert.IsFalse(transactionAttrib.IsCommitted);
   Assert.IsTrue(transactionAttrib.IsRolledback);
}

Key-Gen for .NET Apps!

2009-04-13T17:31:00.005+04:30

You all know that .NET generated application convert the high-level codes from source language (e.g. C#) and converts them to IL. Basically, if you could convert the IL code back to the high-level language, you’d have the original source code of the application, and to some extent, you can do this, but this is the story for another post. Today, I’d want to show you how your public licensing API would provide a very easy way to crack open your own application.

Note: I take no responsibility for how you use the piece of information. By reading these instructions you accept the sole responsibility of any illegal use. The names and information provided here are changed to save the innocent.

Suppose you’ve put a lot of energy and time and written your state-of-the-art application and you’ve released it to the market. After a while some junior software developer tries to inspect your assembly to see how you’ve managed to do a special tricks or two. (Mind you, that’s not what I’d suggest you do, dear reader, because you might end-up facing copyright infringement lawsuits). Now when he’s inspecting the API, he encounters your licensing API, and even worst, those API are public:

public class RSALicenseCodec : IEncoder, IDecoder
{
}

public class License
{
   public Guid LicenseId = Guid.NewGuid();
   public DateTime EndTime;   public string LicensedTo;
   public DateTime PurchaseDate;
   public LicenseType Type;
   public DateTime StartTime;
}

public static string LicenseToKey(IEncoder encoder, License license)
{
}

public static License KeyToLicense(IDecoder decoder, string key)
{
}

Note: Actual implementation was cut off!

Now with all these public API, only thing between a novice developer with bad intensions and a perfect key-gen to for application, is the copyright infringement lawsuit! Do you think that alone is enough?

I don’t want to give you the idea that by only making these API private you’re safe, no. There are a lot of things you should do before you’re even close to being safe with hackers and crackers, but in my opinion taking all the care would no save you either. Almost nothing can stop a motivated cracker.

Resharper 4.5 Released

2009-04-09T09:31:00.001+04:30

Great guys at JetBrains have release next version of their productivity tool, Resharper. It seems this release fixes performance and memory usage issues and performance is tuned for big projects. According to JetBrains, following features are significantly faster now:

Renaming Symbols
Finding Usages
Creating Symbol from Usage
Analyzing large XAML files

I’ve been using their nightly builds for a while and there are a couple of nice new features added to version 4.5. Things like enforcing a naming convention, native support for MSTest unit testing, and copying XML comment from existing (base class / interfaces) sources are some of them. To give it a try, download a trial copy here.

Windows Seven and Sidebar Gadgets

2009-04-05T15:37:00.001+04:30

I’ve been using Windows 7 for a while now and my test experience is nearly great, with some exceptions like for occasional NVidia driver crashing the kernel and a few restarts because of it. The other day, I found something new : my sidebar gadget was missing completely! After searching for it and googling, it turns out disable UAC altogether (setting to “Never Notify”) will make sidebar completely disappear and as soon as you bring it up only one notch (setting it to “do not dim my desktop”) will automagically bring it back after a restart.

Luckily for me, guys on My Digital Life forum have a hack to get this going :

1- Close all gadgets.

2- Take the ownership of the Gadget folder and grant permission to Administrators (folder is located on “WindowsDrive:\Program Files\Windows Sidebar)

3- There are a couple of file here, create a backup copy.

4- Download the patched files here.

5- Overwrite the existing files with the ones in the zip file.

6- Re-add all your gadgets to your desktop.

Note that this is a patch. It worked on my machine but use it at your own risk.

FarsiLibrary 2.1 Released

2009-03-16T16:19:00.001+03:30

Finally the 2.1 version of FarsiLibrary is released. Here are the changes made into this version:

- Fixed : Rendering of controls in non-official themes or when a 3rd party windows skinning (e.g. WindowsBlinds) is installed.
- Fixed : Problem when setting SelectedDateTime property of FXDatePicker control to null value.
- Fixed : Painting of FADatePicker in readonly mode when Readonly property is set fixed.
- Fixed : Problem of setting ForeColor and BackColor in FADatePicker
- Fixed : Certain usage of WinForms control resulted wrong display of Week Of Day in header part of the FAMonthView.
- Fixed : Certain usage of FAMonthView resulted in wrong displaying of date when culture is invariant.

- Added : Methods SetTodayDate and SetEmptyDate added to FXDatePicker and FXMonthView which lets you call the code that represents Today and Empty buttons clicks respectively.
- Added : PersianCultureInfo which is a FA-IR Culture with correct PersianCalendar and DateTimeFormatInfo.
- Added : PersianDateTimeFormatInfo that represents datetime formatting information for FA-IR culture.
- Added : DateTimeExtensions to help convert between PersianDate and DateTime instances via extension methods.
- Added : XmlnsDefinition is added to WPF namespaces. You can reference the controls assembly with http://schemas.hightech.ir/wpf/2008/FarsiLibrary namespace.
- Added : Methods to add / remove validation errors on BaseControl.
- Added : PersianDateValueConverter which can be used in WPF applications to convert strings representing DateTime to their PersianDate equivalant.
- Added : WPF Demo to show usage of custom date converters.
- Added : Ability to show and hide Today and Empty buttons on FAMonthView.
- Added : VisualStudio designer for WPF and actions for WinForm controls is added.

- Modified : Localization of WPF controls are using mechanism like WinForm controls (using StringIDs). Redundant .resx files are removed.
- Modified : Merged WinForm and WPF controls into one solution.
- Modified : ValueValidatingEventArgs now passes HasErrors property of the control when raising event.
- Modified : PersianWeekDayNames and PersianMonthNames have became internal. Use PersianDateTimeFormatInfo class instead.
- Modified : When parsing a string representation of PersianDate e.g. 1382/08/23 time part was initialized from system time, but now initialized to 00:00 to be consistent with DateTime behavior.
- Modified : PersianDateConverter is changed access modifier to Internal. You should not use this class, and instead either cast instances of DateTime / PersianDate or use newly provided extension methods.
- Modified : Strings representing DateTime is now parsed using InvariantCulture when parsed to DateTime instance.
- Modified : Static Parse and TryParse method accepting DateTime instance is removed. Use constructor overload instead.
- Modified : "Readonly" property in FAContainerComboBox is made obsolete. Use IsReadonly property.
- Modified : Border color of control in Office2000 and WindowsXP was near white color. Now uses SystemColors.ControlDarkDark value.
- Modified : Created a new base class for FAMonthView, which will be base of other upcoming controls.
- Modified : CurrentMonthName property from FAMonthView is made obsolete. You can use the GetMonthName method on BaseCulturedControl class instead.
- Modified : Arrows of the FAMonthView will gray-out if the control is in disabled state. Change of selected date is not available if the control is disabled.

Notice that “Modified” entries might be breaking your existing code base, but you are encouraged to use this latest version as there were some rather important bugs fixed and some useful features is added.

Like always, get the files from my web sky-drive here.

Unit Testing : Fact or Fantasy?

2009-03-09T10:55:00.002+03:30

I proposed a poll to CodeProject web site a while ago to see how community is embracing the TDD and agile. There are a lot of talks in .NET community regarding writing tests (Unit Tests, Acceptance Tests, etc.) and even Microsoft is taking this seriously by providing new frameworks and tools to support the idea. I could argue that ASP.NET MVC, supporting TDD in VisualStudio 2010 and lots of other things coming from the “Bosses” is a sign of this, don’t you agree? But how community in general and specifically developers are embracing this? That’s what I intended to find out.

Here’s the result:

Interesting, right? You can see that 18% not know what unit testing is! and this makes almost half of 1000 voted people (exactly 42%) not testing their code! What do you make of it? I’d say it is a disaster! How could the application developers have a night’s sleep if they have absolutely ZERO testing code? I’m sure they say unit testing is not for us, we just write business applications. Well, writing a business application with 50,000 – 70,000 LoC should have SOME bugs in it, right? How do you make sure there’s no bug at least in your core functionality!?

Thanks Chris for shedding some lights on this. What about you, dear reader? Do you find unit testing important? Do you test the code you’ve written?

Design-Time Properties

2009-03-05T10:35:00.000+03:30

Ever wanted to have a Designer-Only properties, whose only purpose is to do something in Visual Studio? I guess you already almost know how to do this. Simply create a property with Getters / Setters and assign an Editor to it, but there are a few things you can do to enhance it.

Let’s say we want to create a property that will be shown on PropertyEditor and assign it an editor so that when the editor is activated we get an About dialog about our control / component. Fancy enough?

so let’s create our basic property. After thinking about it, we don’t need a setter at all and since this is a design time property the return value and return type are also unimportant. So we’re down to this:

public object About
{
    get { return null; }
}

Assigning an property Editor is relatively easy. Create a new class and inherit from UITypeEditor override a couple of methods and you’re all set:

[EditorBrowsable(EditorBrowsableState.Never)]
internal sealed class AboutDialogEditor : UITypeEditor
{
    public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
    {
        return UITypeEditorEditStyle.Modal;
    }

    public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
    {
        About about = new About();
        about.ShowDialog();
        about.Dispose();

        return null;
    }
}

What we’re doing here is first to specify our editor should be opened in Modal mode, and second when the value is requested for that property (Editor is invoked), we just display our about dialog. So, by assigning this editor to our property, it should work:

[Editor(typeof(AboutDialogEditor), typeof(UITypeEditor))]
public object About
{
    get { return null; }
}

There are some other things to do. First, our property is displayed “somewhere” in the PropertyEditor. That’s not what we want for an About dialog, is it? We need the property to appear always first and we need to somehow distinct it from other normal properties. What we can do about it is to use ParenthesizePropertyNameAttribute which simply signifies what our property should be treated specially, just like the standard Name property which is displayed above the others and is in parentheses. Also, to explicitly declare that our property is only a design-time property we’ll add a DesignOnlyAttribute:

[DesignOnly(true)]
[ParenthesizePropertyName(true)]
[Editor(typeof(AboutDialogEditor), typeof(UITypeEditor))]
public object About
{
    get { return null; }
}

The only thing left here is that we don’t want developers working with our controls see this property, because of the fact that it is a design-time property. To do this we add a EditorBrowsableAttribute and make our property Hidden in the texteditor of Visual Studio. So here’s how our final property looks like:

[DesignOnly(true)]
[EditorBrowsable(EditorBrowsableState.Never)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[ParenthesizePropertyName(true)]
[Editor(typeof(AboutDialogEditor), typeof(UITypeEditor))]
public object About
{
    get { return null; }
}

Gmail on IE8

2009-02-15T14:25:00.001+03:30

Looks like Gmail guys don’t like my new browser. Sometimes (notice, just sometimes) things get broken in IE8 beta when using Gmail resulting strange layout problems. Even in turning compatibility mode to on has no effect on this.

VS.NET Designer Errors

2009-02-14T15:01:00.002+03:30

Maintaining old applications has always been something painful for me. Old application, for me, means Winform applications using DataSets for binding operations. When converting and opening an old application, the least thing you want on your hands is to open a form and see Designer screen of death. This is due to the fact that in the WinForm world when you open a form, all the extra codes in the constructor and Load events will get executed, and this where things can go hairdo. Think about a pieced of code in constructor of a form doing something innocent in nature like saving / loading data from registry, connecting to a service. Almost always VS.NET shows a cryptic message. How would you know which code / form / usercontrol is causing this?

Debugging the Designer

There are just a few steps to catch the buggy piece of code ruining your day. Open up your visual studio solution containing your application’s code and compile. Locate the form that is breaking the designer. Open another instance of VS.NET and Goto “Tools” –> "Attach To Process” and locate the process named “Devend.exe” which is Visual Studio’s process name. There are two processes named “Devenv”. Make sure you select the one with loaded solution. To catch all the thrown exceptions go to “Debug” –> “Exceptions” and check the column “Thrown” in front of “Common Language Runtime Exceptions”. This will tell the VS.NET to catch all the exception thrown by CLR. At this point you’re good to go. Switch to your VS.NET containing the solution and open the Form / Usercontrol. The exception will be caught so you can have a very good idea what the problem is.

It is very easy to avoid this.

Make sure the codes written in Form and Usercontrol constructors / OnLoaded / Loaded event (except for InitializeComponents in constructors) will not get executed.
Use the DesignMode property

If you’re extending functionalities of a custom control you need to be aware of this problem. The constrcutors of custom controls will be called in InitializeComponent anyway, so if there’s something wrong with the code in there, you’ll end up with this problem.

There's also an issue with the DesignMode property in UserControls. The design mode only works when the user control is Sited so you may be in design mode and get a False value when checking DesignMode property. The trick is to use a property on System.ComponentModel.LicenseManager which is more reliable.

MIX 10K

2009-02-14T13:06:00.000+03:30

There’s been a new competition around for WPFers. You need to submit an application created with WPF technology (being a WPF app or Silverlight) which should not exceed 10 KB in size. Tricky, eh? What kind of an app can be 10 K? Check out the gallery to see for yourself. You can vote on your favorite app until 16th of February.

Windsor and Automatic Properties

2009-02-06T20:19:00.002+03:30

When maintaining an old application that uses Windsor as DI framework, a strange NullReferenceException throwed when trying to resolve an instance of a specific class. Our project has been recently upgraded to VS 2008 so it was natural to use C# 3.0 specific features. One thing I used in the failing class was Automated Properties. The implementation looked like this :

public class GridRepositoryFactory : IGridRepositoryFactory
{
   public GridRepositoryFactory(IDynamicFormDataService dataService)
   {
       this.Service = dataService;
   }

   public IDynamicFormDataService Service
   {
       get;
       private set;
   }
}

as the stacktrace showed, Castle Windsor version 1.0.3.4333 does not work correctly with inject automated properties. I had to use properties with backing field to solve this, but updating to a more recent version may also get it fixed.

Error Messages in Silverlight

2009-02-03T15:14:00.002+03:30

Can you guess what’s wrong with this Xaml code, on the first look?

<Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             x:Class="Test.UI.App"
             >
    <Application.Resources>

        <Color x:Key="HeaderRectangleStrokeColor">#FF777676</Color>
        <Color x:Key="AppInvertTitleForegroundColor">#16FFFFFF</Color>
        <Color x:Key="AppTitleForegroundColor">FFFFF8F8</Color>
        <Color x:Key="PageBackground">#FF000000</Color>

        <SolidColorBrush x:Key="HeaderRectangleStrokeBrush" Color="{StaticResource HeaderRectangleStrokeColor}" />
        <SolidColorBrush x:Key="AppInvertTitleForegroundBrush" Color="{StaticResource AppInvertTitleForegroundColor}" />
        <SolidColorBrush x:Key="AppTitleForegroundBrush" Color="{StaticResource AppTitleForegroundColor}" />

        <LinearGradientBrush x:Key="HeaderRectangleBrush" EndPoint="0.5,1.011" StartPoint="0.5,-0.011">
            <GradientStop Color="#FF343333" Offset="0"/>
            <GradientStop Color="#FF3E3E3E" Offset="1"/>
        </LinearGradientBrush>
         
    </Application.Resources>
</Application>

Application compiles just fine. Even Resharper can not detect a problem in it. But when you running it a hard error happens that fails the Silverlight plug-in! What’s worse, is that the error message is cryptic as can be :

My Application resource had more Colors and Brushes than the example here, so it was much harder to find the needle in haystack. Luckily I found out what the problem was. The Color value for one of the resource has missing # mark. Shouldn’t there be a more explicit error message?

Efficient Code

2009-01-30T12:22:00.003+03:30

Writing code may look easy to some and hard to others, but some programmers always tend to write messy, smelling, ugly-looking, inefficient code. Here’s one :

protected override AppointmentForm CreateAppointmentForm(SchedulerControl control, Appointment apt, bool openRecurrenceForm)
{
  //return new CustomAppointmentForm(control, apt, openRecurrenceForm);
  if (Thread.CurrentThread.CurrentUICulture.Name == "fa-IR")
  {
      if (openRecurrenceForm)
          return new CustomAppointmentForm(control, apt,openRecurrenceForm);
      else
      return new CustomAppointmentForm(control, apt);
  }

  if (openRecurrenceForm)
      return new AppointmentForm(control, apt,openRecurrenceForm);
  else
      return new AppointmentForm(control, apt);
}

What’s wrong with it you might say? Other than the logic implemented wrong (for specific culture insteam of all RTL cultures), “A lot”, I’d answer.

Commenting out code instead of deleting it will leave a lot of ‘Ghost’ codes in your source. If you have a source-control in place why do you need to keep old code as commented out? it is always available in your source control, isn’t it??

Embedding culture-specific code in not a good idea. What we want to achieve here can be easily achieved using factory patterns.

Control flow is very important for other programmers to understand what you wanted to achieve. Writing nested if / else and multiple returns in a method tend to make this harder.

Having braces in C style programmings is more a matter of style, but always be consistent.

Efficiently use constructor / method overloads. Know what are the default values for overloaded parameters.

The above code could be refactored into this :

protected override AppointmentForm CreateAppointmentForm(SchedulerControl control, Appointment apt, bool openRecurrenceForm)
{
  AppointmentForm form = null;

  if (CultureHelper.IsCultureRightToLeft)
  {
      form = new CustomAppointmentForm(control, apt, openRecurrenceForm);
  }
  else
  {
      form = new AppointmentForm(control, apt, openRecurrenceForm);
  }

  return form;
}

Silverlight + RESTful POX

2009-01-28T15:45:00.005+03:30

I’m working on a small project for a Swedish company. They need their application be available via web, so it’s time to put that Silverlight knowledge at work, so I decided to use Silverlight for UI technology and have a REST service layer to provide the required data. After all Silverlight and REST services should have no problem. Silverlight experience was great. You have LINQ at your disposal to process the REST results and although the set of available commands in Silverlight is less than WPF, but this makes it is easier at the same time. There was a couple of gatchas along the way, so I’m writing this as a note-to-self.

Service Contract vs. Object Model
The domain model is very simple and consist of a couple of entities, so what REST Services expose as data contracts are more or less the same as what I use in application layer. Silverlight’s class library is not the same as a normal class library so I can not reuse the domain model available in my Silverlight library. This will lead to two set of object models. One for the domain model and the other for the service layer as data contracts. This separation or concern is a good idea, but for this small application it is overkill, but there’s nothing I can do with it. With the help of LINQ2XML the best choice for exposing the contract model is POX (Plain old XML) so result of our services would be in XML parse by LINQ and converted to our domain model.

Unit Testing
Also because of different class library outputs, you can not use unit testing frameworks the way you usually do. This means you can not use xUnit, nUnit, etc. Hopefully there’s a test harness to allow both UI and API level testing when developing Silverlight and it works just like MSTest does. Download the binary files here and read this to know how to add templates to your VS.NET to easily create a test application.

RESTful POX
To achieve this the service contract is decorated with REST attributes, That is a WebGetAttribute if you’re exposing the operation via GET verb or a WebInvokeAttribute if you’re exposing it via POST.

Note : The thing was that exposing IList<T> as a returned result of a service resulted a non functioning service with the following message : “Request Error : The server encountered an error processing the request. See server logs for more details.”. It turned out exposing the List<T> worked. The reason behind this is probably the same thing as exposing an object’s interface via normal (Soap) WCF service which also doesn’t work due to interfaces not being serializable.

So here’s the service contract :

[ServiceContract]
public interface IDataServices
{
    [OperationContract]
    [WebGet(ResponseFormat = WebMessageFormat.Xml, BodyStyle = WebMessageBodyStyle.Bare, UriTemplate = "/Advertisers")]
    List<Advertiser> GetAdvertisers();
}

and the implementation is self explanatory. What you get is a service exposed at a URL like http://localhost/Services/DataServices.svc/Advertisers. In order to get rid of the nasty .svc extension you either need to use IIS URL Rewriting Module which is only available on IIS 7 or use IIS Wildcard Mapping plus a HttpModule to make this happen. Read here for complete information.

Note : The .svc extension does not matter from operational perspective. It is computer applications that connect to these URLs after all, but from purists point of view it does matter.

The final part is the configuration which is standard WCF configuration like identifying service and contract, exposing EndPoints, etc. :

<system.serviceModel>
   <serviceHostingEnvironment aspNetCompatibilityEnabled="true" />
   <behaviors>
     <endpointBehaviors>
       <behavior name="WebBehavior">
         <webHttp/>
       </behavior>
     </endpointBehaviors>
   </behaviors>

   <services>
     <service name="Reklam.UI.Web.Services.DataServices">
       <endpoint behaviorConfiguration="WebBehavior"
                 binding="webHttpBinding"
                 contract="Reklam.UI.Web.Services.IDataServices" />
     </service>
   </services>
</system.serviceModel>

Using Windows Seven Beta

2009-01-28T10:47:00.001+03:30

It’s been a few weeks since I’ve installed Windows 7 on my work development box. During the installation everything went fine and all the applications I had on my Windows Vista installed and worked fine under new windows 7, except for Skype for which I had to download and install their version 4.0 Beta. As a Vista user, I found myself immediately familiar with the environment but there are a lot of goodies here and there which made me say “Nice” loud and clear. Performance gain is totally noticeable compared to Vista and memory usage is as low as it can be. Fresh installation of Windows 7 occupies just 700 MB of memory which is obviously way lower than Vista.

I had very few problems using it. The disastrous one was two occasional system crashes when I was designing WPF apps in Visual Studio 2008. The design screen of my WPF UI was frozen and with just a mouse click system had a hard crash. The other issue is using Virtual PC. When windows overlap the VPC window, it goes black and I have to move the window a little bit to see the content (I’m using VPN in Windowed mode, not fullscreen). This too is very annoying because Windows are overlapping each other all the time and its giving me a hard time.

I know this is beta stuff and things may be broken and not working, but I see that guys at Windows 7 team have done a great job.

Update : If you have a Nvidia graphic card, upgrading the driver via Windows Update will solve the VPC going black.

Paint API on Vista

2009-01-08T19:09:00.002+03:30

I was testing bunch of custom controls using Managed paint API on Windows Vista. Basically, managed and unmanaged paint API use native resources of the OS to paint controls, so if you run your controls on Windows XP you’ll get XP look and feel and if you run it on Vista, you get new vistaish look and feel, right? All control parts I’ve tested seems to work, but there is a catch! If you draw a disabled TextBox, it looks strange in Windows Vista, but looks right in XP :

VisualStyleRenderer renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Disabled);
renderer.DrawBackground(e.Graphics, ClientRectangle);

While this code looks fine in XP, it produces a flat blue textbox on Vista :

As far as I could tell, this is an issue with textbox only and other controls like buttons, etc render correctly in both OSes.

I wonder why?! From end-user’s perspective this doesnot look like disabled piece of UI and even worse it doesn’t look like a native disabled texbox on Vista. I still don’t know about any workarounds and I doubt it if native calls to UxTheme API would solve this.

OutOfIdeasException!

2009-01-01T14:51:00.001+03:30

Today I got a funny error message! Showing a simpel Form I got an OutOfMemoryException! Further investigation showed that an actual NullReferenceException is the cause of this. The question is, why a NullReferenceException would convert to an OutOfMemoryException!!!

ATM with NHibernate

2008-12-31T10:50:00.003+03:30

It is cool what you can achieve using anonymous methods and lambdas. Usually to persist an entity to datastore, you would do something like this with NHiberante:

public void SaveOrder()
{
  using (var session = IoC.Resolve<ISessionFactory>().OpenSession())
  {
      var transaction = session.BeginTransaction();

      try
      {
          var o = new Order
          {
              ProductName = "Ice Creams",
              Description = "Lots of strawberry ice creams"
            };

          session.Save(o);
          session.Flush();
          transaction.Commit();
      }
      catch (Exception)
      {
          transaction.Rollback();
          throw;
      }
  }
}

but now you can abstract away the whole transaction creation and commit / rollback thing. Transactions will be rolledback automagically in case an exception occurs :

public void SaveOrder()
{
  With.Transaction(() =>
  {
      var o = new Order
      {
          ProductName = "Ice Creams",
          Description = "Lots of ice strawberry creams"
        };

      UnitOfWork.CurrentSession.Save(o);
  });
}

hmmmmm…how is that possible? all the magic is in the With class and UnitOfWork implementation which are available with lots of other stull in Rhino Tools as free as it can be. In brief here’s how it works :

public static class Using
{
  public static void Transaction(Action action)
  {
      using (UnitOfWork.Start())
       using (var tx = UnitOfWork.Current.BeginTransaction())
      {
          try
          {
              action.Invoke();
              tx.Commit();
          }
          catch
          {
              tx.Rollback();
              throw;
          }
      }
  }
}

You should note that this stuff will still work with pre .NET 3.5 via anonymous methods. This one was a real eye-opener! This provides centeral exception handling, automatic transaction management, etc. which will lead to much cleaner design. What else do you need?! Ideas?

NH + Rhino ESB = Headache?

2008-12-29T15:07:00.003+03:30

I was to make Rhino Service Bus work with NHibernate the other day. Although, Nhibernate and Rhino Service Bus each work flawlessly, when coupled together the problem started. What I wanted to do was simple. Gather some orders to make a package large enough for shipment gateway to process :

As soon as I hit the database to check if I have enough orders to create a shipment package, strange errors occured. Here’s what I did when a new order is recieved :

public class ShipmentSaga : ConsumerOf<NewOrderMessage>
{
   public const int PackageLimit = 5;

   public ShipmentSaga(IServiceBus bus)
   {
       this.Bus = bus;
   }

   public IServiceBus Bus
   {
       get;
       private set;
   }

   public void Consume(NewOrderMessage orderMessage)
   {
       var packagefull = HasEnoughOrders();
       if (packagefull)
       {
           var message = new PrepareShipmentMessage();
           Bus.Send(message);
       }
   }

   private bool HasEnoughOrders()
   {
       using(var session = IoC.Resolve<ISessionFactory>().OpenSession())
       {
           var todayOrders = session.CreateCriteria(typeof(Order))
                                    .Add(Expression.Eq("OrderDate", DateTime.Now.Date))
                                    .Add(Expression.Eq("IsShipped", false))
                                    .List<Order>();

           return todayOrders.Count >= PackageLimit;
       }
   }
}

As soon as the execution of HasEnoughOrders finished and system tried to dispose and close the session, an exception occured saying : “Disconnect cannot be called while a transaction is in progress”. Ayende says this is the problem of NHibernate handling TransactionScopes. NH registers the session for DTC transactions but it does not defer the transaction’s disposal the way it should. Hopefully the bug will be fixed in future releases of NH and there is a workaround. To “temporarily” avoid this problem, do not explicitly dispose the session :

private bool HasEnoughOrders()
{
  var session = IoC.Resolve<ISessionFactory>().OpenSession();

  var todayOrders = session.CreateCriteria(typeof(Order))
                           .Add(Expression.Eq("OrderDate", DateTime.Now.Date))
                           .Add(Expression.Eq("IsShipped", false))
                           .List<Order>();

  return todayOrders.Count >= PackageLimit;
}

Rhino Service Bus is still under development so there might be other minor issues when used together with other technologies and frameworks, but it is a great piece of software. If you’re not familiar with Rhino Tool set, you definitely need to take a look. Thank you Ayende for creating such a great toolkit.

TransactionScope and DTC

2008-12-27T14:01:00.001+03:30

When working with Rhino Service Bus, the application kept crashing as I hit the database. The exception message says that MSDTC is disabled. It turns out this is because of the tightened security on Windows XP SP2 and DTC services and the problem would manifest if your running your data acess services on a separate machine other than your DB and instanciate a new transaction using TransactionScope in your services.

To solve the issue, first you need to check if DTC is properly configured. Do the following steps :

Go to “Control Panel” –> “Administrative Tools” –> “Component Services”
On the “Console Root” open the “Component Servcies” until you see “My Computer”
Right-Click “My Computer” node and select “Properties”
In “MSDTC” tab click “Security Configuration”
Make sure “Allow Remote Clients”, “Enable XA Transactions” and “Enable TIP Transactions” have check marks.

Try again to see if the problem is solved. If not, check if the firewall is blocking any calls to DTC by a utility called DTCPing.

Farsi Library for the Web

2008-12-26T14:50:00.001+03:30

There’s been a lot of request for web controls supporting multiple cultures and calendars, like the already existing WinForm Controls of Farsi Library. The existing ASP.NET Calendar control does not render correctly when used in other cultures and this is the case when you’re using FA-IR culture. Although this problem is partially because FA-IR has a wrong calendar set for its default calendar (GregorianCalendar instead of PersianCalendar), there’s no workaround. What I did was to create a new control to correctly render the calendar information in Gregorian Calendar, Persian Calendar and Hijri Calendar.

The control currently works exactly as ASP.NET calendar, meaning it supports all the use cases of standard ASP.NET calendar control like styling, using on update panels, etc. This control with a complementary DatePicker control will be added to the Farsi Library project as I’m planning for the next major release. The pre-beta sources will soon be available in case you are intrested.

Cleanup that Console

2008-12-20T12:33:00.002+03:30

In the middle of investigating the new Rhino Service Bus (more on this on later posts), I was trying to create a console application that’d act like a Console Application Server. Using a console app as a development application service is very common, because running it is a breeze and you can get the log output directly on your screen. But what I didn’t know was that you can actually close the console application by pressing CTRL + C or CTRL + Break without properly closing the application and this sometime will results to very bad things happening like your port being left open and you won’t be able to re-run the application because the port is not properly closed. To my surprise you can not use any managed code to listen to those events!

My initial console startup code was like this :

public class Program
{
   private static readonly ILog logger = LogManager.GetLogger(typeof(DefaultHost));

   public static void Main(string[] args)
   {
       var host = new DefaultHost();
       host.Start(Assembly.GetExecutingAssembly().FullName);

       logger.Debug("Press CTRL+C to exit...");
       bool shouldexit = false;
       while(!shouldexit)
       {
           ConsoleKeyInfo key = Console.ReadKey(true);
           if (key.Modifiers == ConsoleModifiers.Control && key.Key == ConsoleKey.C)
           {
               logger.Debug("Closing the Service Bus");
               host.Close();

               logger.Debug("Exiting the application");
               shouldexit = true;
           }
       }
   }
}

…and surprisingly application closed before I could run the code in the if block! Time to do a little unmanaged magic. There is existing functionality in Kernel32.dll to listen to console events but those are not exposed as .NET Console events. So first, let’s import that functionality into our managed world :

public enum ConsoleEventTypes
{
   CtrlC = 0,
   Break = 1,
   Close = 2,
   Logoff = 5,
   Shutdown = 6
}

public delegate void ConsoleEventHandler(ConsoleEventTypes consoleEvent);

public class ConsoleController
{
   public event ConsoleEventHandler ConsoleEvent;

   public ConsoleController()
   {
       SetConsoleCtrlHandler(Handler, true);
   }

   private void Handler(ConsoleEventTypes consoleEvent)
   {
       if (ConsoleEvent != null)
           ConsoleEvent(consoleEvent);
   }

   [DllImport("kernel32.dll")]
   private static extern bool SetConsoleCtrlHandler(ConsoleEventHandler e, bool add);
}

With this, the startup code looks like this :

public class Program
{
   private static readonly ILog logger = LogManager.GetLogger(typeof(DefaultHost));
   private static DefaultHost host;
   private static ConsoleController console;

   public static void Main(string[] args)
   {
       console = new ConsoleController();
       console.ConsoleEvent += ConsoleEventRaised;

       host = new DefaultHost();
       host.Start(Assembly.GetExecutingAssembly().FullName);

       logger.Debug("Press CTRL+C to exit...");
       while (true)
       {
           Console.ReadKey(true);
       }
   }

   private static void ConsoleEventRaised(ConsoleEventTypes consoleEvent)
   {
       if(consoleEvent == ConsoleEventTypes.CtrlC || consoleEvent == ConsoleEventTypes.Break)
       {
           logger.Debug("Closing the service bus");
           host.Close();

           logger.Debug("Exiting the application now");
           Environment.Exit(-1);
       }
   }
}

There actual attached code differs somehow. You need to keep the reference of ConsoleEventHandler in case of a garbage collection so the code has a couple of line of code to property handle disposing of the ConsoleController. You can download the source code here. Hope it helps.

Blog Feed Changes

2008-12-18T12:26:00.002+03:30

I just switched to FeedBurner. If you are one of the people subscribed to this blog's feed, this is just a reminder for you to re-subscribe as you may not get the posts in your blog reader using the old address. Here's the link to subscribe. Sorry for the caused inconvenience.

WPF Controls : Design-Time Integration

2008-12-16T12:09:00.000+03:30

One of the things that affects the overall friendliness of your custom WPF controls - but you may not consider implementing it - is the design-time integration. With Cider continuing to exist in VS 2010, there’s a lot of design-time functionality at your disposal. Since the model is different in Cider than creating designers for WinForm controls, I’m trying to shed some light on the subject. To demonstrate this, I’ll show some simple steps on adding design-time capabilities to my FarsiLibrary controls which are a pack of date related controls (DatePickers, MonthView, etc.) freely available here. This is not meant to be a complete guide but will let you build a basic designer if you need to.

Note: In order for your designer to get loaded by the design-time host, it is essential that you name like YourProjectName.VisualStudio.Design. Guess this is to force developers move out their design-time logic out of main control’s dll (as was encouraged in WinForms).

Preparing MetaData
First thing you should do, is to plug into meta-data registration mechanism. We do this by creating any class and implementing IRegisterMetadata interface. Then we need to create our various attributes on a Attribute Table. Here’s how you might do it :

public class VisualStudioMetadata : IRegisterMetadata
{
   public void Register()
   {
       AttributeTableBuilder builder = new FarsiLibraryVisualStudioAttributeTableBuilder();
       MetadataStore.AddAttributeTable(builder.CreateTable());
   }
}

internal class FarsiLibraryVisualStudioAttributeTableBuilder : AttributeTableBuilder
{
   internal FarsiLibraryVisualStudioAttributeTableBuilder()
   {
   }
}

In order to get this metadata loaded, you need to have the assembly containing this interface beside your Controls assembly and it will eventually gets loaded when needed. Also when updating the design-time assembly, VS.NET unloads the old one and uses the updated assembly. This will bring you a lot of performance gain and ease when creating designers for your controls because you no longer need to exit the current instance of VS.NET and run a new one to get the changes loaded.

In fact, unlike WinForm model where design attributes were added to the actual control’s source code, in VS.NET 2008 (and later?) the new model allows you to switch designer assemblies at a later stage or even create a designer for a control you don’t have access to the source code.

Toolbox Integration
WPF controls are usually consisted of various primitive type controls, like shapes, buttons, labels, content controls, etc. These parts are composed to build the actual Control. When the final control’s assembly is loaded in design-time environment, (e.g. VS.NET), control parts will be added to the toolbox but this may not be appropriate since you don’t want your control’s building blocks to appear on the toolbox. However, contols will disappear if a proper toolbox attribute is to them.

internal class FarsiLibraryVisualStudioAttributeTableBuilder : AttributeTableBuilder
{
   internal FarsiLibraryVisualStudioAttributeTableBuilder()
   {
       AddToolboxBrowsableAttributes();
   }

   private void AddToolboxBrowsableAttributes()
   {
       var builder = new AttributeTableBuilder();

       builder.AddCustomAttributes(typeof(FXMonthViewButton),            ToolboxBrowsableAttribute.No);
       builder.AddCustomAttributes(typeof(FXMonthViewContainer),         ToolboxBrowsableAttribute.No);
       builder.AddCustomAttributes(typeof(FXMonthViewHeader),            ToolboxBrowsableAttribute.No);
       builder.AddCustomAttributes(typeof(FXMonthViewItem),              ToolboxBrowsableAttribute.No);
       builder.AddCustomAttributes(typeof(FXMonthViewWeekDayHeaderCell), ToolboxBrowsableAttribute.No);

       MetadataStore.AddAttributeTable(builder.CreateTable());
   }
}

This will result your controls not being visible when the toolbox is loaded. In case you to show your custom icons appear in the toolbox you should create a BMP icon and place it on your main control’s assembly (not design-time assembly), and give it a proper name. The name should be YourControl.Icon.bmp and you should set the bitmap’s action to “Embedded Resource”.

Property Grid Integration
You can specify where and how the control’s property will be shown in PropertyGrid of VS.NET when the control is opened in the design-mode.

To hide properties similar to BrowsableAttribute in WinForms you can use the following snippet :

builder.AddCustomAttributes(FXMonthView.ButtonStyleProperty, BrowsableAttribute.No);

and to specify the category of the Control’s property similar to CategoryAttribute in WinForms:

var behaviorCategory = new CategoryAttribute("Behavior");
builder.AddCustomAttributes(FXMonthView.ViewDateTimeProperty, behaviorCategory);

Some attributes still work in WPF world. For example you can use the EditorBrowsableAtribute on your properties to make them show in Advanced section of the new WPF Property Grid. The usage is the same as before :

[EditorBrowsable(EditorBrowsableState.Advanced)]
public DateTime MaxDate
{
    get { return (DateTime)GetValue(MaxDateProperty); }
   set { SetValue(MaxDateProperty, value); }
}

Note: Visual Studio WPF Designer supports the full extensibility framework, but Expression Blend only supports property editors, metadata loading, and licensing. and it does not support menu actions and adorners.

Fig. 1 – How advanced properties look on property grid

Menu Actions
Another way to change your control’s design-time behavior is to add actions to VS.NET Context-menu which will appear when the control is right-clicked upon. Unlike WinForm’s Designer Verbs which also appeared on the bottom of the Property Grid, these menu actions will only appear when the control is selected on the design surface.

You can add your menu actions by extending PrimarySelectionContextMenuProvider class and load it with your IRegisterMetadata instance :

private void AddMonthViewMenuItems()
{
   AddCallback(typeof (FXMonthView), builder => builder.AddCustomAttributes(new FeatureAttribute(typeof (MonthViewDesignMenuProvider))));
}

public class MonthViewDesignMenuProvider : PrimarySelectionContextMenuProvider
{
   private readonly MenuAction aboutMenuAction;

   public MonthViewDesignMenuProvider()
   {
       var grp = new MenuGroup("FarsiLibrary", "Farsi Library");
       aboutMenuAction = new MenuAction("About...");
       aboutMenuAction.Execute += OnAboutActionExecuted;

       grp.Items.Add(aboutMenuAction);
       Items.Add(grp);
   }

   private void OnAboutActionExecuted(object sender, MenuActionEventArgs e)
   {
       var dialog = new AboutUI();
       dialog.WindowStartupLocation = WindowStartupLocation.CenterScreen;
       dialog.Topmost = true;
       dialog.ShowDialog();
   }
}

Design-Time Adorners
To have more control on how users interact with your custom control and to provide them an elaborated experience, you can benefit control adorners to create a more robus design-time functionality. You can create WPF UserControls that manipulate your control in a developer friendly way. You can create a Design-Time Control Adorner by extending PrimarySelectionAdornerProvider class which resides in Microsoft.Windows.Design.Extensibility assembly. Just a couple of methods to override and you’re all set here. Here’s the method’s skeleton to show you what to do :

public class MonthViewDesignAdorner : PrimarySelectionAdornerProvider
{
   private MonthViewDesignerUI designerUI;
   private AdornerPanel adornersPanel;
   private ModelItem calendarModelItem;

   public MonthViewDesignAdorner()
   {
       designerUI = new MonthViewDesignerUI();
   }

   protected override void Activate(ModelItem item, DependencyObject view)
   {
       calendarModelItem = item;

       CreateAdornerPanel();
       PlaceAdornerPanel();
       SubscribeDesignerEvents();

       base.Activate(item, view);
   }

   protected override void Deactivate()
   {
       UnsubscribeDesignerEvents();

       base.Deactivate();
   }

   private void OnDesignerUIPropertyChanged(object sender, PropertyChangedEventArgs e)
   {
        //Set the actual control's property with the updated value
   }

   private void PlaceAdornerPanel()
   {
      //Create an AdornerPanel and set it’s placement
      //to display whereever you like when your contol gets selected
      //on design surface.
   }

   private void OnDesignerUILoaded(object sender, RoutedEventArgs e)
   {
        //When the control designer is loaded we need to synchronoze the designer’s
       //properties with actual property values of the control and set the
       //element that displays this value on the designer accordingly.
   }

   private void SubscribeDesignerEvents()
   {
       designerUI.Loaded += OnDesignerUILoaded;
       designerUI.PropertyChanged += OnDesignerUIPropertyChanged;
   }

   private void UnsubscribeDesignerEvents()
   {
       designerUI.Loaded -= OnDesignerUILoaded;
       designerUI.PropertyChanged -= OnDesignerUIPropertyChanged;
   }

   private void CreateAdornerPanel()
   {
        //Create a new AdornerPanel and set our
       //DesignerUI as its child.
   }
}

To synchronize the values between our Designer and Control, the designer should implement INotifyPropertyChanged interface to report back when a property value is change in design-time and we set property on the control accordingly. Control’s properties are accessible via our ModelItem instance which is set in OnActivate method. For example to access a dependency property on our control and set it’s value we need to do the following :

ModelProperty prop = calendarModelItem.Properties["SelectedDateTime"];
prop.SetValue(DateTime.Now);

As for our designer goes, you can create a WPF user interface, a WinForm dialog or even both (through WPF and WinForm Integration mechanism). Here, I’ve created a UserControl to act as my designer and added some simple controls to edit the properties of my actual controls. To handle editing of SelectedDateTime property (which is of nullable DateTime type), I have used another instance of my FXDatePicker on the design surface (the design-time control’s are skinned). Here’s the designer’s XAML :

<UserControl x:Class="FarsiLibrary.WPF.VisualStudio.Design.MonthViewDesignerUI"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:Controls="clr-namespace:FarsiLibrary.WPF.Controls;assembly=FarsiLibrary.WPF">
      
   <Expander IsExpanded="False" Margin="10" Padding="10" Header="Options...">
       <StackPanel x:Name="ContentPanel" SnapsToDevicePixels="True">
           <CheckBox Content="Show Today Button" IsChecked="{Binding Path=ShowTodayButton}" />
           <CheckBox Content="Show Empty Button" IsChecked="{Binding Path=ShowEmptyButton}" />
           <CheckBox Content="Show WeekDay Names" IsChecked="{Binding Path=ShowWeekDayNames}" />

           <Rectangle Fill="{DynamicResource Text1Brush}" Height="1" SnapsToDevicePixels="True" Margin="-5,5,-5,5" />
          
           <StackPanel Orientation="Horizontal">
               <TextBlock Text="Selected Date : " Width="150" />
               <Controls:FXDatePicker SelectedDateTime="{Binding Path=SelectedDateTime}" Width="120" />
           </StackPanel>
          
           <Rectangle Fill="{DynamicResource Text1Brush}" Height="1" SnapsToDevicePixels="True" Margin="-5,5,-5,5" />

           <StackPanel Orientation="Horizontal">
               <TextBlock Text="Maximum Selectable Date : " Width="150" />
               <Controls:FXDatePicker SelectedDateTime="{Binding Path=MaxDate}" Width="120" />
           </StackPanel>
           <StackPanel Orientation="Horizontal">
               <TextBlock Text="Minimum Selectable Date : " Width="150" />
               <Controls:FXDatePicker SelectedDateTime="{Binding Path=MinDate}" Width="120" />
           </StackPanel>
       </StackPanel>
   </Expander>
</UserControl>

Basically, when a property is changed on our designer, we’ll raise the INotifyPropertyChanged event with the newly changed value and matching property name on the control that should be changed. You could directly bind your designer’s control to the actual control’s properties and it would work but this gives you more control. The code-behind looks very simple :

/// <summary>
/// Designer control to visually set FXMonthView's
/// properties on design-time.
/// </summary>
public partial class MonthViewDesignerUI : INotifyPropertyChanged
{
   public event PropertyChangedEventHandler PropertyChanged;

   private bool _ShowEmptyButton;
   private DateTime? _SelectedDateTime;

   public MonthViewDesignerUI()
   {
       InitializeComponent();

       this.Loaded += OnLoaded;
   }

   private void OnLoaded(object sender, RoutedEventArgs e)
   {
       this.DataContext = this;
   }

   public bool ShowEmptyButton
   {
       get { return _ShowEmptyButton; }
       set
       {
           _ShowEmptyButton = value;
           RaisePropertyChanged("ShowEmptyButton", value);
       }
   }

   public DateTime? SelectedDateTime
   {
       get { return _SelectedDateTime; }
       set
       {
           _SelectedDateTime = value;
           RaisePropertyChanged("SelectedDateTime", value);
       }
   }

   protected void RaisePropertyChanged(string propertyName, object value)
   {
       if(PropertyChanged != null)
       {
           PropertyChanged(this, new DesignerPropertyChangedEventArgs(propertyName, value));
       }
   }
}

Now, PropertyChangedEventArgs sent by INotifyPropertyChanged does not send the actual value (though you can read it through the sender). To easily read the changed value I’m using an extension to PropertyChangedEventArgs named DesignerPropertyChangedEventArgs (works just like PropertyChangedEventArgs but also has the value inside). With this, our synchronization code looks like this :

private void OnDesignerUIPropertyChanged(object sender, PropertyChangedEventArgs e)
{
   ModelProperty prop = calendarModelItem.Properties[e.PropertyName];
   var args = e as DesignerPropertyChangedEventArgs;

   if(prop != null && args != null)
   {
       prop.SetValue(args.Value);
   }
}

Conclusion
Designer integration with seems way better than WinForm world and with WPF powers you can create very sophisticated designers. The only drawback is that Cider and Expression Blend designers are different, both in how they work and what functionality they provide so you might need to create separate design assemblies one for each environment which is an unnecessary burden to me. This is just a scratch in the surface of what you can achieve by creating custom designers for WPF Controls.

Java & .NET Integration : Who is Who?

2008-12-16T11:26:00.001+03:30

There’s a new kid on the block! An affort to port Java frameworks to .NET is not a new thing and it’s been around since the early days of .NET 1, but integration of .NET Framework and Java Development Kit (JDK) is something I’m not used to see everyday! The new project named “Ja.NET” enables you to use first class development and runtime environment for .NET in which you use supposedly can use your existing Java SE code base and knowledge but also leverage existing functionalities available .NET Framework!

Ja.NET provides you with equivalance of Java 5 SE SDK implemented from scrach, JDK tools, class libraries and .NET CLR runtime environment. Also you can use available functionalities in .NET world such as Custom Attributes, Value Types, Extension Methods, etc. The question is : Are we back on J# days? Definetly no. I’m talking about an open-source community here and the roadmap says there will be release comparable to J2ME and J2EE sometime in the future.

Java Interoperability

2008-12-11T12:00:00.000+03:30

One thing we’ve learned the hard way when developing large scale applications, was to use incomparable existing functionalities in Java world! Things like Message Queues, Task Scheduling, Load Balancing and fail over, etc, and yes, that means connecting your .NET application to a Java application server on the backend. I’ve been working on a PoC for this on the last couple of weeks, so there’ll be yet another enterprise comparison between what new EJB 3.0 and .NET can offer you. Stay tuned.

Resharper : The Most frequently used feature

2008-11-17T16:49:00.000+03:30

A while a go, Rory asked me to blog about Resharper add-in for Visual Studio.NET and which shortcut keys I use the most. This one has been waiting on my draft list for a couple of weeks now. This post is about Resharper shortcuts I mostly use.

Resharper is one the most advanced and useful add-in available for Visual Studio .NET. I've started using the tool when they published their release for Visual Studi 2003. Back then, Resharper added lots of feature and brought productivity to the IDE which without them, your programming life would have been a nightmare.

The problem with Resharper though, is that it has become so big and featurefull, that is won't be possible to use it in large scale projects. We have a bloated Solution containing about 80 projects that started back in 2003 with only 10-12 projects. When I open the project in VS with Resharper running, the files with 2-3K LOC make Resharper run out of memory. 2-3K LOC might sound unrealistic to you, but automatically generated codes like DataSets or Forms code behinds are usually this large. So, it'd be a good idea if we could disable some Resharper features to gain some more speed, e.g. disabling code analysis in .Designer files, disabling XAML analysis, etc.

As said before, there are a lot of features in Resharper, which makes your programming experience a pleasant one. Here I’m only pointing to some of the ShortCut keys I mostly use.

Find Usage Window (Alt + F7)
I’m Sure you've tried to figure out how / where an interface is implemented, or where instance of a certain class is being used, or other similar scenarios. If you use plain VS, you have no other choice than to use "Find All References". That will work, but it takes time every time you do a search like this. This is due to the fact that VS does not keep an index of your application structure, but since Resharper does, you'll gain a lot of speed when doing these kind of operation.

Also, the "Find Usage Window" is more rich in Resharper than VS. You can sort and group the results based on Namespace, Usage, File, Folder, etc. and filter by Read, Writer, Invocation, etc. but in VS all you see is a flat search result. One of the great things about Find Usage function is that it actually finds the usage in Xaml code too!

Using Hints and Red / Yellow Bulb (Alt + Enter)
Resharper has a good way of letting you know that you can do something better, by displaying "Hints". Hints let you know if you've forgotten to import a namespace, if there's a refactoring available or suggest a context action. There are lots of things you can do in Resharper, just by pressing Alt + Enter! Some of them are :

Change scope of the Class or Method
Create overload for a method / Check if the variable is null
Create derived types
Import missing namespace / remove unused namespace
Implement an interface / abstract class
Change property to Automated property and vice versa
Invert if statement / Convert to conditional statement and vice versa
Join / Split declaration and assignment of the variable
Introduce variable / use var keyword
Generate body of the switch statement

…and a lot more. Depending on where the cursor is in the editor, where you click and the code you have written, you may get different options.

Goto Type / File (Ctrl + N, Ctrl + Shift + N)
If you're looking for a specific file in your large project or if you're using multiple class per file strategy, you might get lost easily. If you need to know where that file is located, or in which file you class resides, you can use these shortcuts to get you there. The "Goto Type" function has support for a feature called CammleHumps. Using this feature, if you're looking for OrderApprovalService, you can search for OAS instead and Resharper will find it for you.

Code Completion and Type Lookup (Ctrl + Space, Ctrl + Alt + Space)
When you’re working with large libraries you may easily get lost. Sometimes you know the name of type you’re going to use, but can’t remember the darn namespace! This shortcut will help you find the type you are looking for in ALL the namespaces in an easy to use fasion.

Code Generation (ALT + Ins, Ctrl + J)
The code generation feature in Resharper is just great. You can use the primary code generation function by ALT + Ins that will let you generate :

Constructors
Properties / Readonly Properties from backing fields
Implement Method / Property stubs for an Interface
Override base class Methods
Provide equality implementation (Equality Operators, IEquatable<T> interface, overriding Equals and GetHashCode methods)

While this is great, Resharper gives you the power to write your own snippets! A lot of people have already created snippet templates for Resharper to create Unit tests, Mocks, NHibernate, ActiveRecord and WPF stuff, etc.

You can download Resharper templates on Joey Beninghove’s blog, or see what other people use on StackOverflow page.

Summary
There is a document on JetBrain’s website that shows all the ShortCut keys you’ll ever need to know. Intense Resharper users might need to hang it on their wall. There are lots of other features I use like Unit Test Runner, Stack Trace browser, File Structure window, and ToDo List, but that’s for another post. Do you use productivity tools too? Which one? Which feature do you use the most?

Visual Studio 2010 CTP Test Drive

2008-11-11T15:25:00.001+03:30

It's been a couple of week that the CTP version of Visual Studio 2010 and .NET Framework 4.0 is out, but I finally got mine (and some free time of course), so I dived to see what's new.

First thing I expected to see, but didn't, was the new WPF shell. Although some modifications are made in the current release shell, it is obvious that it is not entirely a WPF shell. The first thing that is obvious in current release is the WPF TextEditor that looks like an enhanced version of Expression Blend Xaml editor! Turns out, there is a registery key to notify the IDE to show the WPF version of the Shell, but that is not recommended. I Guess there are more work to do in that area and it didn't make it to the CTP version, so you'd better wait for next releases. This CTP release is a Team System edition, and there are lots of features to play with, but some of them might not be in other editions like Professional when the final version is out.

UML Diagrams

In previous versions of Visual Studio diagram designs were limited to a Class Designer, and of course custom designers for the late Linq2Sql, etc. but in this release there are more UML designing powers at your disposal that makes VS into a CASE tool. You don’t have to leave your IDE or bug another product just to use UML Diagrams and since it built into the IDE, extension and integration with it is very easy. Available diagrams are Activity Diagram, Sequence Diagram, Use Case Diagram, Component Diagram and our old Class Diagram.

Call Hierarchies

The IDE now has a new feature to find other references to a Variable, Method, or Constructor. This feature, while IS useful, does not come close to Navigations of productivity tools such as Resharper, where you can find *everything* about a reference you may think of, but again, this is just CTP and things may get better in the final release. I tested this feature on the “Dinner Now” demo project and the Call Hierarchy window didn’t take long to appear, but I have no idea how much time it takes in large scale projects.

Quick Search

There is a new search tool available that lets you find various types. The new search tool is named Quick Search. By entering a keyword in the search dialog, the IDE finds all the types matching that name. I think a simple search dialog would not be enough and more control on the type that is being searched (e.g. Interface, Class, etc.) and the ability to group the search result (e.g. by namespace, folder, assembly) is necessary.

Background Compilation

VS now uses a background compiler to compile the code as you write. As you write your code the IDE marks the errors so you don't have to compile your big project to find out about small typos here and there. You can use this feature in parallel with the other feature named “Create from usage”.

Create From Usage

Visual Studio now offers to create your types based on their usages. This is something mostly used in TDD with Test First approach and tools like Resharper had something even better than this, ages ago! As you write code (test?), VS checks it with the new background compiler and marks it as error, so you get an option to fix the error by creating the missing Class, interface or even Methods and Properties.

Wix Integration

Finally WiX, which was initially an open source project, got integrated with Visual Studio. For those not heard of it, Wix is an installation maker that is flexible, simple, and powerful. Creating setup files with WiX is simple : Create an XML file describing your files, and installation package (where is an .XSD available which can be used as intellisense helper or to validate your XML file), then the WiX engine will create working MSI files. Back when I tested WiX 2.0, you had to manually write the XML file, but now there are commercial and free WiX designers to help you create the XML files. The version of WiX that will ship with Visual Studio apparently is WiX 3.0.

Overall

Depending on your point of view, changes in the TextEditor and Extensibility of the IDE might or might not be an issue, but so far I didn’t see a BIG change in the IDE, though there may be more changes in the next releases. Newly added feature seem somewhat unfinished, but this is pre-beta stuff so this is natural. These are just IDE features and there are great stull in the .NET Framework 4.0 that also come with the CTP version.