Victor Stodell

The Cornball goes to Brunch with Chaplin

2014-07-24T11:50:00.001+02:00

Lately I've been working pretty hard on different projects but not really stumbling upon anything blogworthy. The most recent project is quite interesting though, a single page, touch friendly, web application using the latest and greatest technologies. We've ended up with using Brunch with Chaplin, which is a very neat way of setting up a Backbone based single page web project with Brunch and Chaplin.

Aside from this, I have my own little project that has lived on for almost 15 years already, The Cornball. From being a plain Windows application written i C an Win32 API, it has been ported to .NET using WPF, and is currently a Silverlight application hosted on Windows Azure.

I could not find a better time to reanimate this project and create a new web based version, touch friendly, super optimized, awesome in any way. So I did... So please follow my journey at Github. It's going to take a while, I assure you, but I already have some ground work done.

Meanwhile, check out the current Silverlight version at http://lantisen.stodell.se/

jQuery file upload with Bootstrap progress bar

2014-02-18T15:29:00.001+01:00

Performing an asynchronous file upload from the browser is a common problem with almost as many solutions as there are developers. The following solution is the best fit for my needs, and also works well with most popular browsers. Backwards compatibility is not an issue in this case which is great, because I can use the new technologies as they are supposed to be used.

Everything is put together in JSFiddle for a working example. I will continue to explain the parts below...

First, the input field needs to be styled as a button. The form tag is only present for us to be able to reset the file input field later on.

<form>
    <span class="fileUpload btn btn-default">
        <span class="glyphicon glyphicon-upload"></span> Upload file
        <input type="file" id="uploadFile" />
    </span>
</form>

.fileUpload {
    position: relative;
    overflow: hidden;
}
.fileUpload input {
    position: absolute;
    top: 0;
    right: 0;
    margin: 0;
    padding: 0;
    cursor: pointer;
    opacity: 0;
}

The Javascript is contained within one method which is executed when the file input is changed.

$("#uploadFile").change(function() {
    var formData = new FormData();
    formData.append('file', this.files[0]);
   
    $("#files").append($("#fileUploadProgressTemplate").tmpl());
    $("#fileUploadError").addClass("hide");
   
    $.ajax({
        url: '/url/json/',
        type: 'POST',
        xhr: function() {
            var xhr = $.ajaxSettings.xhr();
            if (xhr.upload) {
                xhr.upload.addEventListener('progress', function(evt) {
                    var percent = (evt.loaded / evt.total) * 100;
                    $("#files").find(".progress-bar").width(percent + "%");
                }, false);
            }
            return xhr;
        },
        success: function(data) {
            $("#files").children().last().remove();
            $("#files").append($("#fileUploadItemTemplate").tmpl(data));
            $("#uploadFile").closest("form").trigger("reset");
        },
        error: function() {
            $("#fileUploadError").removeClass("hide").text("An error occured!");
            $("#files").children().last().remove();
            $("#uploadFile").closest("form").trigger("reset");
        },
        data: formData,
        cache: false,
        contentType: false,
        processData: false
    }, 'json');
});

When selecting a file for upload, a new AJAX request is performed. I use the FormData object to pass on the file to the backend as multipart/form-data. By attaching an event handler to the progress event I can set the width of the progress bar to the calculated percentage.

The error and success methods are simple handlers that hide the progress bar and either adds the file to the list on success or displays an error message on error.

In this particular case I am using jQuery templating, but since that project is abandoned I would recommend chosing another template engine...

Using ASP.NET MVC with MEF

2014-02-17T13:37:00.000+01:00

I wrote this post almost a year ago, but never published it for some reason. Anyway, here is a little MVC/MEF magic.

By default a controller in MVC must have a parameterless constructor. When using MEF a good practice is to inject the services via constructor parameters. These two in combination obviously creates an issue where the following scenario will not work out of the box, since there is no parameterless constructor for MVC to use.

Note that the PartCreationPolicy is set to NonShared since a new controller have to be initialized for each request.

[Export]
[PartCreationPolicy(CreationPolicy.NonShared)]
public class HomeController : Controller
{
    private readonly IServiceClient _service;

    [ImportingConstructor]
    public HomeController(IServiceClient service)
    {
        _service = service;
    }

    public ActionResult Index()
    {
        return View();
    }
}

For this scenario to work we need to override the default controller factory with a custom implementation. This class basically just gets initialized with our MEF container and the overridden GetControllerInstance uses this container to get an appropriate controller for the current request.

public class MefControllerFactory : DefaultControllerFactory
{
    private readonly CompositionContainer _compositionContainer;

    public MefControllerFactory(CompositionContainer compositionContainer)
    {
        _compositionContainer = compositionContainer;
    }

    protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
    {
        var export = _compositionContainer.GetExports(controllerType, null, null).SingleOrDefault();

        IController result;

        if (export != null)
        {
            result = export.Value as IController;
        }
        else
        {
            result = base.GetControllerInstance(requestContext, controllerType);
            _compositionContainer.ComposeParts(result);
        }

        return result;
    }
}

The only thing left to do now is to tell MVC to use our custom controller factory with the SetControllerFactory method in Global.asax with our container as an argument to the MefControllerFactory.

protected void Application_Start()
{
    ControllerBuilder.Current.SetControllerFactory(new MefControllerFactory(_container));
}

When this is set up an empty constructor is no longer necessary in our controllers since MEF will be responsible for instantiation of the controllers.

Bindable RichTextBox with HTML conversion in WPF

2014-01-16T14:51:00.000+01:00

In WPF, the RichTextBox control is not really like other controls. Due to its flexible nature, there is no built in way of binding a property to the content. In this case, I wanted a simple RichTextBox control with a binding to an HTML formatted string to be able to use the built-in formatting features of the RichTextBox and allow users to create simple HTML formatted content.

First, doing the conversion on-the-fly proved to have major performance issues, so I ended up binding the content to a XAML string. The XAML to HTML conversion can be performed at any time.

I created a UserControl with a bindable Text-property. The view contains a RichTextBox control.

<RichTextBox x:Name="richTextBox" TextChanged="OnRichTextBoxChanged">

The source code for the user control contains the Text property and the methods to handle the binding.

public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
    "Text", typeof(string), typeof(TextEditor),
    new FrameworkPropertyMetadata(string.Empty, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTextPropertyChanged));

private static void OnTextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    textEditor.richTextBox.Document = GetDocumentFromXaml((string) e.NewValue);
}

private void OnRichTextBoxChanged(object sender, TextChangedEventArgs e)
{
    Text = GetXamlFromDocument(richTextBox.Document);
}

private static string GetXamlFromDocument(FlowDocument document)
{
    return XamlWriter.Save(document);
}

private static FlowDocument GetDocumentFromXaml(string xaml)
{
    if (string.IsNullOrEmpty(xaml))
        return new FlowDocument();

    return (FlowDocument)XamlReader.Parse(xaml);
}

Putting this together as a custom control either derived from RichTextBox or just as a simple UserControl as above both works fine. I choose this method since I have exended the control to be more than just a bindable RichTextBox, so this made more sense. When it comes to comverting the XAML to HTML, Microsoft have put together a sample library which does a great job. I haven't had to do any changes to their original code for my scenarios to work, but there might be scenarios where modification is necessary.

Using Bootstrap Tooltip to show Parsley validation errors

2013-12-18T15:12:00.002+01:00

I'm currently working on a web application using a variety of different frameworks, such as Backbone for the back-end, Bootstrap for the front-end and Parsley for client side form validation. Parsley is a really powerful validation toolkit, but it takes some tweaking to make it blend with the Bootstrap front-end. Fortunately this is a one time fix, which can be re-used all over our project.

Since there will be some custom options in our Parsley object, we can't use the default parsley-validate attribute on the form. Instead we have to initialize the validation with the jQuery syntax:

$('#my-form').parsley(parsleyOptions);

The options are were the magic happens, and in our case we have a global options object that our forms use to get the same experience all over the application. Here's what it looks like:

var parsleyOptions = {
  // Sets success and error class to Bootstrap class names
  successClass: 'has-success',
  errorClass: 'has-error',

  // Bootsrap needs success/error class to be set on parent element
  errors: {
    classHandler: function(el) {
      return el.parent();
    },
    // Set these to empty to make sure the default Parsley elements are not rendered
    errorsWrapper: '',
    errorElem: ''
  },
  listeners: {
    // Show a tooltip when a validation error occurs
    onFieldError: function (elem, constraints, parsleyField) {
      elem.tooltip({
        animation: false,
        container: 'body',
        placement: 'top',
        title: elem.data('error-message')
      });
    },
    // Hide validation tooltip if field is validated
    onFieldSuccess: function(elem, constraints, parsleyField) {
      elem.tooltip('destroy');
    }
  }
};

There are, of course, some caveats with this approach. By default, Parsley has a fallback to some default error messages and multiple validation errors is normally shown if there are multiple errors. The approach above reguires the data-error-message attribute on all validated fields and only one message for each field will be displayed.

Proper initialize/dispose with WCF and MEF

2013-08-26T14:42:00.001+02:00

Initialization and disposing of services in a WCF application is a bit of a hassle to control when running on an IIS instance, since the application starts and stops every now and then based on server requests. It doesnt make it easier when using an IOC, as in our case MEF.

To have total control of the startup and shutdown events we began with adding a service factory to all our WCF services.

<%@ ServiceHost Language="C#" Debug="true" Service="WcfService" Factory="CustomServiceHostFactory" %>

When ever the application gets woke up by a request to any of the services, the service factory will be used to instantiate the service. This means we can add any logic to these methods to have full control of the WCF application initialization. Here is what a service factory class could look like. (Composition is a static class containing a reference to the MEF container)

public class CustomServiceHostFactory : ServiceHostFactory
{
    private static readonly object SynchronizationContext = new object();

    public CustomServiceHostFactory ()
    {
        ApplicationInitialize();
    }

    protected override ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses)
    {
        var serviceHost = base.CreateServiceHost(serviceType, baseAddresses);
        serviceHost.Opened += (s, a) => ApplicationStarted();
        serviceHost.Closed += (s, a) => ApplicationDispose();
        return serviceHost;
    }

    private void ApplicationInitialize()
    {
        if (Composition.Container != null) return;

        lock (SynchronizationContext)
        {
            if (Composition.Container == null)
            {
                // Initialize container
                Composition.Initialize();
            }
        }
    }

    private void ApplicationStarted()
    {
        // Do anything after application has been started
    }

    private void ApplicationDispose()
    {
        lock (SynchronizationContext)
        {
            if (Composition.Container != null)
                Composition.Dispose();
        }
    }
}

Since there are more than one service running we have to make sure the factory is thread safe and only does the initialization and disposing once. You should also note the order in which the methods are executed. The initialization are done in the constructor, but if you want something done when initialization is completed you should use the ServiceHost.Opened event, which is accessible by overriding the CreateServiceHost method.

Custom DataAnnotation validation on multiple properties

2013-08-08T12:45:00.000+02:00

There are a few cases where you want to be able to validate a property value based on the value of another property. As always there are a bunch of different solutions to this problem, but the cleanest way of doing so is to create a custom DataAnnotaion validation attribute.

It is as easy as creating a class derived from ValidationAttribute and overriding the IsValid-method, but instead of the usual IsValid(object value) we will be overriding the IsValid(object value, ValidationContext validationContext) method.

The ValidationContext contains information about the current object beeing validated and makes it possible to get the values of related properties. By including the related properties and values in our validation class constructor. All in all, it could look like this, even though the validation logic does not really make sense in a real world context it explains the idea pretty good.

[AttributeUsage(AttributeTargets.Property)]
public class CustomValidationAttribute : ValidationAttribute
{
    public string PropertyName { get; private set; }

    public CustomValidationAttribute(string propertyName)
    {
        PropertyName = propertyName;
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        if(validationContext == null)
            return null;

        var property = validationContext.ObjectType.GetProperty(PropertyName);
        if (property == null)
            return new ValidationResult(string.Format(CultureInfo.CurrentCulture, "Unknown property " + PropertyName));
            
        var propertyValue = property.GetValue(validationContext.ObjectInstance, null);
        if(string.IsNullOrWhiteSpace((string)propertyValue))
            return new ValidationResult(string.Format(CultureInfo.CurrentCulture, PropertyName + " value is null"));

        if (string.IsNullOrWhiteSpace((string)value))
            return new ValidationResult(ErrorMessage);

        return null;
    }
}

When using the attribute we will simply atach it to the property with the related property name as an argument.

[CustomValidation("FirstName", ErrorMessage = "FirstName must not be null or empty")]
public string LastName { get; set; }

Using this technique it is easy to create extremely flexible and advanced validation based on several property values on any object.

Binding Enum with DescriptionAttribute in WPF

2012-07-03T21:21:00.001+02:00

Binding an enumeration to a ComboBox can be done in several ways. In most cases you don't want to display the value itself, but a more user friendly description. One common approach is to use the DescriptionAttribute on the Enum values to supply a description for each value. This is all possible in a very MVVM friendly way.

First step is to add the DescriptionAttribute to the values of the enumeration.

public enum MyValues
{
    [Description("First value")]
    First,

    [Description("Second value")]
    Second
}

To retrieve the description from the enum we use a simple extension method. This method returns the value of the DescriptionAttribute if it exists, otherwise the string representation of the enum value is returned.

public static string GetDescription(this Enum value)
{
    var fieldInfo = value.GetType().GetField(value.ToString());
    var attribute = fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false).FirstOrDefault() as DescriptionAttribute;

    return attribute != null ? attribute.Description : value.ToString();
}

With this extension method it is really easy to write a generic enum description converter to use where ever an enum value is presented to the user. But the more interesting case is where we want to present the enumeration in a ComboBox or a similar control. To accomplish this you can use a MarkupExtension. (Please note that this code is stripped from all type validation and such to be easier to read.)

public class EnumExtension : MarkupExtension
{
    private readonly Type _enumType;

    public EnumExtension(Type enumType)
    {
        _enumType = enumType;
    }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return (from object enumValue in Enum.GetValues(_enumType)
                select new EnumMember {Value = enumValue, Description = ((Enum)enumValue).GetDescription()}).ToArray();
    }

    public class EnumMember
    {
        public string Description { get; set; }
        public object Value { get; set; }
    }
}

The DescriptionAttribute together with these extensions gives us a really neat way of populating the values of an enum into a ComboBox.

<ComboBox SelectedValue="{Binding MyValue}"
          ItemsSource="{Binding Source={my:EnumExtension {x:Type MyValues}}}"
          DisplayMemberPath="Description" SelectedValuePath="Value" />

LEAP Sweden in Redmond

2012-06-03T00:00:00.000+02:00

Well, there is not very much to say about the trip to Redmond, except that it was awesome! It has been a week filled with seminars and social activities in Microsoft Conference Center and closeby venues. We even paid a visit to The Flight Museum outside Seattle and actually got a private tour from Clemens Vasters, who knew surprisingly much about airplanes.

Not only have I been able to meet other extremely talented developers and architects who participated in the LEAP program, I've also had the chance to meet some of the most involved people at Microsoft and got to hear about the latest and hottest topics in IT today.

The speakers included Jonathan de Halleux, Stuart Kwan, Scott Guthrie, Miha Kralj, Clemens Vasters, Cihan Biyikoglu, Bryan Agnetta and more. The topics were everything from theoretical architectural lectures to deep product previews and technical discussions. Overall it was a great schedule packed with so much information I almost don't know what to do with all of it.

There will be announcements in the near future for some of the previews we got to see. For instance the new Azure improvements will be announced June 7th and as you might know we got the Release Preview of Windows 8 just a couple of days ago. There sure are a lot going on right now and I know I'm going to stay alert to keep up!

Here are some other interesting stuff that was mentioned during the seminars:

Meyers Briggs Type Indicator: "A good architect should be at least N and T" - Miha Kralj
Pex is a Microsoft Research project which aims to automatically generate test suites with high code coverage tests. Pex4Fun takes the Pex engine and makes it into a fun programming game.
Moles is a cool isolation framework which makes it possible to replace system methods with your own delegates, for instance replace DateTime.Now with a custom date. This framework will be included in .NET 4.5, named Fakes.

I really hope that there will be a continuation of LEAP next year and I would recommend (almost) anyone to attend. I would also like to give a big handout to Björn Eriksen who made this arrangement possible, and did it really well!

LEAP Sweden - Windows 8 and Windows Server 2012

2012-05-03T18:30:00.000+02:00

I am back home in the couch filled with enthusiasm from the last gathering of LEAP Sweden before the trip to Redmond in the end of May. Todays topic was the new versions of Windows (server and client) as well as the Business Intelligence product suite from Microsoft.

The Business Intelligence suite basically is a really nice integration between products that already exist. With SQL Server 2012, SharePoint 2010 and Excel 2010 tightly integrated Microsoft offers a really attractive package.

Mikael Nyström showed off some of the new features in Windows Server 2012. To say the least this is an impressive release. There is a heavy focus on virtualization, storage and terminal services which makes Microsoft a strong competitor against both VMWare and Citrix in the small to medium sized business segment. One of the coolest features has to be conditional permissions.

Johan Lindfors gave a demo on Windows 8 development. He showed some samples of how easy it is to develop Metro style applications on the WinRT. We have already seen some new cool features in Visual Studio 11 and .NET 4.5, but the new async features coming sometime in the future (CTP currently available) is absolutely awesome! Especially the async/await keywords, which simply is an extremely clean way of dealing with asynchronous calls.

At last we got a presentation from Chris Klug who had prepared a neat cross framework demo built with the Portable Class Libraries. This makes it quite simple to create a shared code base for Windows Phone 7, Windows 8, Silverlight and WPF.

In about a month we will be heading to Redmond for the last three days of the Lead Enterprise Architect Program, which I am sure will be awesome!

Connecting to SOAP service with certificate authentication

2012-04-19T21:34:00.001+02:00

I have rarely worked with certificate based authentication, so when I got this neat little SOAP service with certificate authentication in my hands I gladly accepted the challenge. All I got was the URL to the service with a certificate and the password. I also got an example written in PHP:

$client = new SoapClient("https://url.to.service/", array(
        'local_cert' => 'client_certificate.pem', 'passphrase' => 'PASSPHRASE',
        'cache_wsdl' => WSDL_CACHE_NONE
));

This of course looks very easy, but we all know that it's not really that easy if I want to use .NET and WCF. First of all the PEM-certificate cannot natively be used in .NET. Second of all I don't have the WSDL for the service. Here are the steps I had to go through to be able to successfully connect to the SOAP service.

Convert the certificate
The certificate I received was a PEM certificate which included both the private and public key. .NET does not natively support the PEM format, so I had to convert the certificate to a type that is usable in my application. For this purpose I used Win32OpenSSL and the command is really straight forward:

openssl pkcs12 -export -in client_certificate.pem -out client_certificate.pfx

I was prompted for the current password and then prompted to enter a password for the new certificate. This results in a PFX certificate ready to use in .NET and that is compatible with the SOAP service.

Connecting to the service
By installing the PFX-certificate in the certificate store on my computer I am able to connect to the service URL. This also means that I can use the Add service reference Wizard in Visual Studio to generate the service client classes. However, I don't want to make the users install the certificate on their computers, but instead include the certificate in the application that will consume the service.

Another issue is that the SSL-certificate is not issued by a trusted source. This means that a secure connection cannot be established. An ugly but surely effective hack is to override the ServerCertificateValidationCallback and simply returning true for all certificates on validation. Note that this override is effective for the entire application!

ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;

When that little obstacle is overcome, it is actually a very straight path to connect to the service. First we will have to add the certificate to the solution and set it as Embedded Resource. The next step is to read the resource and add the certificate to the service binding.

var resource = typeof(MyService).Assembly.GetManifestResourceStream("client_certificate.pfx");
using(var stream = new MemoryStream())
{
    resource.CopyTo(stream);
    _certificate = new X509Certificate2(stream.ToArray(), "PASSWORD");
}

When connecting all we need to do is create a BasicHttpBinding and setting the ClientCredentialType to Certificate. We also have to add the certificate to the ClientCertificate property on the service.

public void Connect()
{
    var binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport);
    binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Certificate;

    var endpointAddress = new EndpointAddress("https://url.to.service/");

    _service = new ServiceClient(binding, endpointAddress);
    _service.ClientCredentials.ClientCertificate.Certificate = _certificate;
    _service.Open();
}

That is about everything that needs to be done. With the certificate added to the project and to the binding the authentication is handled with the certificate and the supplied password. The service works great on any computer without having to install the certificate or entering any credentials. Of course this is not the most secure solution out there, but it sure gets the job done!

Quartz.NET and MEF

2012-03-23T10:34:00.001+01:00

I have been implementing a scheduler service for several different jobs on several difference schedules, which led me into using Quartz.NET. This is a really nice framework, but since we're using MEF I ran into some issues.

Quartz.NET basically consists of the scheduler engine which runs jobs implementing the IJob interface. The interface simply consists of an Execute method. I export each job with the IJob interface using MEF.

[Export(typeof(IJob))]
public class MyJob : IJob
{
    public void Execute(JobExecutionContext context)
    {
        ...
    }
}

In my scheduler implementation the jobs are imported into an IEnumerable<IJob>.

[ImportMany(typeof(IJob))]
public IEnumerable<IJob> Jobs { get; set; }

The initialization of the scheduled tasks is pretty straight forward. A standard scheduler factory is initialized which in turn gives us a scheduler instance. Each job that was imported by MEF is then added to the scheduler, here with a simple 10 minute trigger just to make things easier.

var factory = new StdSchedulerFactory();
var scheduler = factory.GetScheduler();
foreach (var job in Jobs)
{
    var jobDetail = new JobDetail("Job name", job.GetType());
    var trigger = TriggerUtils.MakeMinutelyTrigger("Trigger name", 10, SimpleTrigger.RepeatIndefinitely);
    scheduler.ScheduleJob(jobDetail, trigger);
}

That is about everything we need to get the jobs going. The issue with MEF however is that each time a job is triggered to run the scheduler creates a new instance of the job. To prevent this behaviour we must create a custom implementation of the scheduler. The IJobFactory interface contains a NewJob method that is run each time a job is about to be run. We would like to return the same instance every time.

public class MefJobFactory : IJobFactory
{
    public IJob NewJob(TriggerFiredBundle bundle)
    {
        try
        {
            var jobs = Bootstrapper.Instance.Container.GetExports<IJob>();
            return jobs.First(job => job.GetType() == bundle.JobDetail.JobType).Value;
        }
        catch (Exception exception)
        {
            throw new SchedulerException("Problem instantiating class " + bundle.JobDetail.JobType, exception);
        }
    }
}

There is one last thing to do to actually implement this custom job factory. Nothing in the code above needs to be changed. All we have to do is to add a few lines to the app.config to instruct Quartz.NET to use our custom implementation instead of the default.

<configuration>
    <configSections>
        <section name="quartz" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />
    </configSections>
    ...
    <quartz>
        <add key="quartz.scheduler.jobFactory.type" value="MyScheduler.MefJobFactory, MyScheduler" />
    </quartz>
</configuration>

And thats it! Instead of creating a new instance of the job on each run, my custom implementation is used to get the MEF exported job.

LEAP Sweden - Identity & Access Management

2012-03-08T19:30:00.000+01:00

Today was the third day of the Swedish Lead Enterprise Architect Program at Microsoft in Kista. It has been a day filled with sessions on security and identity with a kind of unavoidable focus on federated identities in the cloud.

Overall it has been an awesome day with seminars from Henrik Nilsson, Barry O'Reilly and Sergio Molero among others. A lot of Microsoft technologies was mentioned, Forefront Identity Manager, Active Directory Federation Services 2.0, Forefront Unified Access Gateway, Direct Access, Windows Identity Framework and of course Azure Access Control Service.

Microsoft really has a great suite of applications regarding Identity & Access Management. I just wish there was a project or two where I could utilize all of these amazing technologies. I have had a plan to add a login feature to the Cornball using federated identities, so that might happen in the near future.

Besides, Björn Eriksen provided a tip for all of us thursty for education. Microsoft have collected a wide range of white papers, videos and links into what they call Microsoft Virtual Academy. Learn, explore and collect education points as you do it!

First gathering of LEAP Sweden 2012

2012-02-16T19:00:00.000+01:00

I am back home in the couch after the second day on the first gathering of Microsoft LEAP Sweden 2012.

It has been two days packed with lectures on architecture and cloud computing. Without giving away too much, here are some short notes from this first gathering:

In software arcitecture, knowing your patterns and practices is always a good thing. The same goes for best practices. SOLID is not a new concept, but it bears repeating!

The future is all about bring-you-own-device, the cloud in general and Azure in particular. Also, the future is now!

The Windows Azure HPC Scheduler is awesome for high performance computing scenarios where an extra boost is needed. You gotta love the elastic cloud!

I will start working on a Rock Paper Azure bot this weekend and try to conquer the world.

The speakers that shared this information with us were among others Patrik Löwendahl, Brian Prince and of course Björn Eriksen that is organizing all of this.

I am already looking forward to the next gathering in march when the topic will be Identity & Access Management.

Binding a HTML-formatted string to a WPF WebBrowser control

2012-02-07T10:19:00.000+01:00

Sometimes there is a need to display a HTML formatted string in a WPF application. There are a couple of ways to do this, but the most stright forward is to use a WebBrowser control and the NavigateToString method.

This approach has one big flaw, you cannot use binding to a string out of the box, but I found a great solution through Stack Overflow which adds a bindable property to the WebBrowser control using NavigateToString.

The following class is all that is needed to add that behavior. A new depencency property named Html is introduced to the WebBrowser and the proper change action is performed in the OnHtmlChanged method.

public class BrowserBehavior
{
    public static readonly DependencyProperty HtmlProperty = DependencyProperty.RegisterAttached(
        "Html", typeof(string), typeof(BrowserBehavior), new FrameworkPropertyMetadata(OnHtmlChanged));

    [AttachedPropertyBrowsableForType(typeof(WebBrowser))]
    public static string GetHtml(WebBrowser browser)
    {
        return (string)browser.GetValue(HtmlProperty);
    }

    public static void SetHtml(WebBrowser browser, string value)
    {
        browser.SetValue(HtmlProperty, value);
    }

    static void OnHtmlChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
    {
        var browser = dependencyObject as WebBrowser;
        if (browser != null)
        {
            browser.NavigateToString(e.NewValue);
        }
    }
}

To bind this property the XAML looks like this:

<WebBrowser local:BrowserBehavior.Html="{Binding Path=HtmlText}"></WebBrowser>

Since we are printing some swedish characters the encoding got a little bit funky. This is nothing that the WebBrowser control itself affects, but it has to be set with an encoding meta tag in the HTML. So simply add the following meta tag to the head section of the HTML to be shown in the browser control:

<meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />

Another thing that does not seem to be able to affect on the WebBrowser control is the context menu. The default context menu is the same as you would get in an Internet Explorer window. When using the NavigateToString method to add the content the navigation in the browser control will not work. Hence we would like to hide the context menu. The easiest way to do so is with a litte javascript in the rendered HTML:

<body oncontextmenu="return false;">

By adding these little hacks we have an easy way to show HTML content in a bindable fashion. Sure there are still some caveats to this solution, for instance an F5 keystroke will refresh the browser window. But we cannot use WebBrowserShortcutsEnabled since we want the users to be able to copy text from the browser using the Ctrl-C shortcut.

New Silverlight 5 features in The Cornball

2012-01-21T20:10:00.000+01:00

The release of Silverlight 5 is allegedly the last major release of Silverlight, but it brought some great stuff that I have now incorporated in the latest release of The Cornball.

There are a lot of good descriptions and even video samples of the new features in What's new in Silverlight 5. These are the two new features that I am using in The Cornball.

Mouse Button Double Click
Previously I have used a custom implementation with a timer to capture double clicks on the cards. But since this feature finally is included in the framework I decided to use that instead. The MouseButtonEventArgs now has a ClickCount property which simply indicates the number of times the mouse button was clicked. That leaves us with a much cleaner implementation of the single and double click scenario.

private void CardMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    switch (e.ClickCount)
    {
    case 1:
        // Handle single click
        break;
    case 2:
        // Handle double click
        break;
    }
}

Low-Latency Sound Effects
I have had plans to include sound effects before, but there haven't really been a good enough solution to do so. The MediaElement tag made it possible to play video and audio, but was never really meant to play sound effects in this matter. In Silverlight 5 a couple of classes from the XNA framework are included, SoundEffect and SoundEffectInstance.

Instead of showing any of my code I would like to recommend the video sample by Pete Brown that displays these new features in a very good way.

To see the results of what I accomplished, please visit The Cornball and try to beat the high score!

Microsoft LEAP Sweden 2012

2012-01-18T09:30:00.002+01:00

I have been privileged to participate in the Lead Enterprise Architect Program at Microsoft this spring.

The Lead Enterprise Architect Program (LEAP) is a program that aims to give understanding of the strategic core components of the Microsoft platform.

LEAP consists of five master class training sessions as well as three days of sessions at Microsoft headquarters in Redmond, Seattle.

The direction of the classes are extremely appealing and I really hope that they will live up to my expectations:

Application architecture on the Microsoft Platform
Cloud computing for Architects
Identity & Access Management
Integration on premises and in the cloud
Business Intelligence and Enterprise Search

The program starts in February and ends with the trip to Redmond in the end of May. During this time I will try to write as much as possible about this whole experience, which I hope will be amazing!

My experience with TFS Preview

2012-01-11T10:58:00.000+01:00

I have been using the Team Foundation Services preview for a while now, and the least I can say is that I am impressed! The web interface has a nice Metro style design and gives a high quality experience overall.

By installing the KB2581206 hotfix I can also access my TFS account from Visual Studio, which is absolutely fantastic. I might even sound a bit fanatic by saying that it is like a dream come true... The server appears as a traditional Team Foundation Server in Visual Studio apart from the logon process (a Windows Live popup window). Read more and try it out yourself!

Besides playing around with the user interface I have actually tried to work a little seriously with the service as well. Partly by uploading my project the Cornball and developing against the TFS in Visual Studio. So far this experience is very positive and I have not found any issues or oddities at all, except that the environment is kind of slow. This whole thing also takes me one step further out in the world of clouds. Particularly the Cornball, since hardly anything of that is left on my computer.

Here is a snapshot of the start page in my Cornball project, which is very empty at the time...

Google Search Appliance .NET solution

2012-01-03T18:02:00.000+01:00

I recently worked on a project to integrate the search results from a Google Search Appliance into a .NET application. Although it seems like a pretty straight forward task, there were some small issues that I thought I might share.

Background
The communication with the Google Search Appliance is made simply with a HTTP GET request, which returns an XML formatted response. As for the Suggest service, the request looks about the same but the result returned is JSON encoded. For more information, please see the Google Search Appliance documentation, which is very extensive.

Internationalization
Since this solution was to incorporate several languages, the .NET application had to support and differentiate the languages. The GSA has very good built-in language support but there were at least one thing that was not completely obvious.

The GSA uses either HTTP headers or query string parameters to determine in which language the request is made. If neither of these are supplied the GSA may not return a correct response. This was the issue in our case, where we got unpredictable results in the spelling suggestions.

Summary: Always send an appropriate Accept-Charset and Accept-Language HTTP header.

XPath or LINQ to Xml?
There is already a publicly available .NET library (GSALib) to communicate with the Google Search Appliance, but for several reasons I chose not to use that library and build our own customized library. Since all responses from the GSA is XML formatted a key element in the communication is the XML parsing.

In .NET today there are basically two different choices, XPath or LINQ to XML. In the decision making process there were two key features to consider, ease of use and performance. MSDN published an article on this subject, Comparison of XPath and LINQ to XML. The following blog even took their time to make a little performance test, XPath vs LINQ to XML.

Summary: I chose LINQ to XML mostly because of its composition, which produces code that is easier to read and modify since we practically always read all elements in the XML file.

Changes in my life, and on my blog

2011-12-01T20:20:00.000+01:00

Yesterday I did my last working day at my previous employer and the next week I will begin my employment as a Microsoft consultant at Connecta in Stockholm. Of course this means that things will change, but only for the better I hope. Leaving a position that you like on a workplace that you like is a tough decision. But in my case there are some amazing possibilities and challenges that I just cannot turn down.

The type of work I will be doing differs a bit from my previous position. I will be more focused on development, which also means that I will try to change the direction of this blog to be more development oriented. At the same time, I have come to realize that by blogging in Swedish I do not really contribute to the community as much as I could. Therefore I have chosen to translate my previous posts to English and continue to blog in English from now on.

Furthermore I have decided to focus more on my blog. I have some interesting projects ahead, both personal and professional, which mean that could I easily increase my blogging frequency. Because the more challenges I run into, the more I will have to write about. Hopefully this will all turn out well and if so, it will be a great 2012!

Google+ finally for everyone!

2011-11-03T17:50:00.003+01:00

There have been a lot of whining on Google from their Apps-users since the launch of Google+ for everyone with a regular Google-account. The Apps-users have not been able to use Google+, until now! (actually october 27)

As usual I am impressed with most of the things Google accomplishes, but now when all of their services have gotten a visual and functional touchup I am getting really impressed.

As someone at an early stage pointed out it is really sweet of Google to play naive and let me fill in my profile information when I create my profile (as if Google did not already know), but after a few clicks I am on the go. My albums from Picasa is automatically integrated and even the pictures I have uploaded to this blog is shown in Google+.

But what happens next? Practically no one of my friends are on Google+ so what do I use it for? I guess we will see. Hopefully there will be even more integration between the social networks in the future. I am anyhow very satified with the fact that you now can find me on Facebook, LinkedIn, Twitter, this blog and now also Google+!

User.Identity returns old login name after name change

2011-08-19T11:23:00.002+02:00

When a person gets married or makes a name change for some other reason this usually means that the login name for the Active Directory-account changes as well. This is rarely a problem, but it turned out to cause some issues on our web server, where the User.Identity property was still returning the old login name.

The user logged on with the new login name, but was identified by the web application as the old login name. The reason this occurs is because the User.Identity property relies on the LsaLookupSids method to convert the user SID to a login name. The method first calls the local LSA-cache, which is not synchronized with the Active Directory.

For this purpose a simple reboot of the web server to clear the LSA-cache propably would have sufficed. But since we didn't want to take the application offline rebooting was not an option. Instead, it is possible to set the registry value LsaLookupCacheMaxSize in HKLM\SYSTEM\CurrentControlSet\Control\Lsa. If this value is set to 0 the LSA-cache is cleared. It is recommended that the setting is reset after the cache is cleared, since the main purpose of the LSA-cache is to enhance performance.

Read more about this issue and the solution here: http://support.microsoft.com/kb/946358

Windows Server 2008 R2 DNS issues

2011-08-11T14:28:00.003+02:00

This week we stumbled upon some weirdness in our new 2008 R2 DNS servers. A couple of URLs, for example www.smhi.se and www.stockholm.se could not be resolved from a 2008 R2 server. The existing 2003 servers with the same configuration worked perfectly.

After thorough troubleshooting we found out that there is a new default setting in Windows Server 2008 R2 regarding the EDNS-protocol that caused the issues. Not all of the DNS servers around the internet are able to handle EDNS, but in 2008 R2 this protocol is enabled by default. Normally you would think there is a fallback mechanism to standard DNS protocol if an EDNS request fails, but Windows Server does not have that.

The solution was simply to disable EDNS by using the command: dnscmd /config /EnableEDNSProbes 0

Scott Forsyth has written more about this issue and how he found the solution:
http://weblogs.asp.net/owscott/archive/2009/09/15/windows-server-2008-r2-dns-issues.aspx

Configure static ports for Exchange

2011-08-03T11:28:00.000+02:00

In a firewalled Exchange environment it is always easier if Exchange communicates on static ports. Normally RPC on port 135 is used to initialize the communication. Any further communication is made through a port dynamically selected by each service on the Exchange-server.

I will not go deeper into how this is made, because it has been described very well in this blog:
http://www.proexchange.be/blogs/exchange2007/archive/2009/05/18/configuring-static-ports-for-exchange-2007.aspx

Except from the traditional bribes to the network guys, there were just a couple of registry settings on the Exchange-server and some of the clients to make everything work as a charm, even through the firewalls.

Moving to the cloud - part 4

2011-06-21T08:25:00.004+02:00

When e-mail, files and blog are already in the cloud the Cornball is the only application left on my hosting provider. It is now getting really exciting because there is no doubt that the Corball should move to the Microsoft cloud, Windows Azure.

The Cornball is a Silverlight application which communicates through a WCF service with a MySQL database, all on the same hosting provider. This is about to be converted into a Silverlight application which communicates through a WCF service on Windows Azure that in turn communicates with an SQL Azure database.

Microsoft have published a lot of information to get started with Windows Azure, but basically it is quite simple. After downloading the tools and SDK it is just to get on with the development. Through my MSDN subscription I have got some free Azure capacity so just by logging on to the Windows Azure portal I am ready to configure my cloud.

The Windows Azure Management Portal is a Silverlight based user interface which is very easy to use an intuitive. There is a wide variety of settings and possibilities, but the things I needed for my application was to create a Data Store, a database and also a Hosted Service. Once these components were created I could easily set up a connection in Visual Studion which enabled me to Deploy my application directly to the cloud.

SQL Azure has a Silverlight based user interface as well, and it works perfectly for my simple needs. I have only got two tables and a couple of stored procedures. There are some limitations in SQL Azure compared to SQL Server but since I was moving from a MySQL server that was nothing I really thought about.

So, now I have moved e-mail, files, web sites and databases to the cloud and I could not be more happy! Everything has been running as clockwork and I have saved some money each year as well. I have also gained a lot of experience and set myself free from some worries.