BloggingAbout.NET

Documents.Open returns null, running Word automation under ASP.NET on x64

Rick van den Bosch — Thu, 02 Feb 2012 04:53:00 GMT

When building an ASPapplication that generates Word documents, it was working fine on the local machine. A windows XP installation with Office 2007. When we deployed it to windows 2008 (64 bit) and Word 2007 we saw that Documents.Open returned null. Other than this, there are no exceptions.

The code that returned the error (simplified):

Application app = new Application();
Document doc = app.Documents.Open(ref name);

As it turns out, a 64 bit system stores temporary files in "C:\Windows\SysWOW64\config\systemprofile\Desktop" folder. The solution: create a new directory called "Desktop" inside "C:\Windows\SysWOW64\config\systemprofile\"

Hope this helps.

Tech to try in 2012

Mischa Kroon — Tue, 31 Jan 2012 23:10:00 GMT

February is already here and I've been meaning to write this for quite a while. This year I want to have tried some new tech by the end of the year, it's very common for me to want to try different technologies but a little less common that I actually give myself a goal with a deadline. So I guess this will be the first time. The tech I want to have tried: Monogame : I want to have made a game with this, not sure on which platforms I want to be able to run it yet. So what tech do you think...(read more)

nServiceBus synchronously

Dennis van der Stelt — Tue, 31 Jan 2012 15:03:17 GMT

When you read a title like this, everything that makes you a developer should start worrying. Because nServiceBus is build on top of the concept of asynchronous messaging. Normally, it does not support the request/reply communication pattern as you would normally understand this pattern. You are able to send a reply message to the originator, the application that initially sent you the message. But this is inherently asynchronous.

However… With the company I work for, we’re investing a lot of time on messaging. One application needed to call a component that supported this asynchronous messaging. The application itself however is very linear and was very, very hard to interrupt, send a message and have a message handler wait for the result. This really required a Saga and this was too much work at the time. We already had plans for a refactoring where we’d introduce a Saga, but we needed the functionality that called out this other component now. So we created a small piece of code that actually waits for nServiceBus te receive the reply. After this the normal flow of the application can continue.

Again, I really need to clarify that this was a temporary solution and eventually we fixed this by refactoring the code and support a Saga, a long running process that was persisted while waiting for the response.

Here’s the code to do it though

DataResponseMessage response = null;

RequestDataMessage message = new RequestDataMessage() { DataId = g, SomeMessage = "Whatever" };

var synchronousHandle = Bus.Send(message)
                            .Register(asyncResult =>
                            {
                                NServiceBus.CompletionResult completionResult = asyncResult.AsyncState as NServiceBus.CompletionResult;
                                if (completionResult != null && completionResult.Messages.Length > 0)
                                {
                                    // Always expecting one IMessage as reply
                                    response = completionResult.Messages[0] as DataResponseMessage;
                                }
                            }
                            , null);

synchronousHandle.AsyncWaitHandle.WaitOne();

Console.WriteLine("Reply : {0}", response.ResponseMessage);

For completeness, I’ll include the message handler from the component the message was sent to. This is normal nServiceBus code.

public class RequestDataMessageHandler : IHandleMessages<RequestDataMessage>
{
    public IBus Bus { get; set; }

    public void Handle(RequestDataMessage message)
    {
        var response = Bus.CreateInstance<DataResponseMessage>(m => 
        { 
            m.DataId = message.DataId;
            m.ResponseMessage = "I got the message : " + message.SomeMessage;
        });

        Bus.Reply(response);
    }
}

Unhandled exception installing SQL Server 2008 R2 on a Windows XP machine

Rick van den Bosch — Fri, 27 Jan 2012 04:46:00 GMT

When installing SQL Server 2008 R2 on a Windows XP development machine that has been around for quite some time, I got an error stating an unhandled exception occured in the application (see image). The error showed up directly upon startup and read:

An error occurred creating the configuration section handler for userSettings/Microsoft.SqlServer.Configuration.LandingPage.Properties.Settings: Could not load file or assembly 'System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' or one of its dependencies.

Repairing the .NET 4.0 framework didn't solve the issue. Neither did removing all SQL stuff through 'Add or Remove Programs'. Looking into the error a bit further...

The system cannot find the file specified. (C:\Documents and Settings\_USERNAME_\Local Settings\Application Data\Microsoft_Corporation\LandingPage.exe_StrongName_ryspccglaxmt4nhllj5z3thycltsvyyx\10.0.0.0\user.config line 5) ---> System.IO.FileNotFoundException: Could not load file or assembly 'System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' or one of its dependencies. The system cannot find the file specified.

So the problem probably wasn't that System.dll couldn't be found, but some user.config file for the landingpage executable. The solution is as simple as it is radical: remove the entire (temporary) folder 'C:\Documents and Settings\_USERNAME_\Local Settings\Application Data\Microsoft_Corporation' (where USERNAME_ is, of course, the current username). After this the setup should start up without any problems.

Introducing Simple.Data OData provider

Vagif Abilov — Thu, 29 Dec 2011 21:12:36 GMT

Mark Rendle’s Simple.Data has quickly become a popular choice to retrieve data from various data sources. The number of Simple.Data providers includes today SQL Server, Oracle, Mysql, MongoDB and others. When I saw Simple.Data in action, I became enthusiastic about extending its list of providers with OData. I believe dynamic nature of Simple.Data matches very well RESTful nature of OData. Currently Visual Studio offers creation of a client context from an OData feed using “Add Service Reference” dialog which treats an OData service like it was a traditional SOAP service. This is unfortunate because OData communication does not need an interface proxy: communication is based on HTTP methods and can be implemented without context creation ceremony.

Welcome to Simple.Data OData provider! When I asked Mark Rendle on Twitter if he had thought about writing a Simple.Data OData provider, he replied that he was working on Windows Azure table provider that also uses OData protocol, and he offered me to join the project and focus on generic OData client implementation. This gave me an exciting opportunity, and today I am glad to announce that Simple.Data OData provider preview is available, and it’s Nuget feed is published.

Simple.Data OData provider is hosted at GitHub. The source code based is shared by OData and Azure provider implementation, but the Nuget packages are different.

Getting started with Simple.Data OData provider

The easiest way to start using Simple.Data OData provider is to install it’s Nuget package. In Visual Studio open Package Manager console and type the following:

Install-Package Simple.Data.OData

You will see output similar to this:

Attempting to resolve dependency 'Simple.Data.Core (≥ 0.12.2.2)'.
Successfully installed 'Simple.Data.OData 0.1.1'.
Successfully added 'Simple.Data.OData 0.1.1' to SimpleODataTest.

In the source file where you will be using OData provider import namespaces:

using Simple.Data; 
using Simple.Data.OData;

Create an instance of dynamic database object that will be used to communication with OData feed:

dynamic db = Database.Opener.Open("http://packages.nuget.org/v1/FeedService.svc/");

Now you can start retrieving data from the OData server using Simple.Data syntax:

var package = db.Packages.FindByTitle("Simple.Data.OData"); 
Console.WriteLine(package.Title);

Reading data using Simple.Data OData provider

package = db.Packages.FindByTitleAndVersion("Simple.Data.OData", "0.1.1.2");
Console.WriteLine(package.Title);

Find multiple results:

IEnumerable<dynamic> packages = db.Packages.FindAllByTitle("Simple.Data.OData");
packages.ToList().ForEach(x => Console.WriteLine(x.Title + " " + x.Version));

packages = db.Packages.FindAll(db.Packages.Version == "1.0.0.0");
packages.ToList().ForEach(x => Console.WriteLine(x.Title + " " + x.Version));

Select column subset:

IEnumerable<dynamic> packages = db.Packages
    .FindAllByTitle("Simple.Data.OData")
    .Select(db.Packages.Version);

Limit number of results using Skip and Take:

IEnumerable<dynamic> packages = packages = db.Packages
    .FindAllByTitle("Simple.Data.OData")
    .Take(1); 

packages = db.Packages
    .FindAllByTitle("Simple.Data.OData")
    .Skip(1)
    .Take(1);

Retrieve results in specific order:

IEnumerable<dynamic> packages = db.Packages
    .FindAllByTitle("Simple.Data.OData")
    .OrderByDescending(db.Packages.Version);

What’s next

OData provider already supports Insert,Update and Delete operations (more about it in a next blog post), but it does not support associations. The implementation of the new functionality requires some changes to Simple.Data.Core library that is on its way.

BizTalk in the Cloud, One Step Closer Part 2

Jean-Paul Smit — Thu, 22 Dec 2011 23:00:11 GMT

In my previous post I discussed a part of the recently released CTP of Windows Azure Service Bus EAI and EDI. I went over installation and the steps to take to create schemas and mappings (in this post I use different schemas and mapping, because of Visual Studio issues I had to start over).

This post is about how the schemas and mappings are used in Windows Azure. Like we’re used to with BizTalk we need the schemas to define the message types and we need the mappings to transform one message type to another. But how does this all fit together?

When you create a new ‘ServiceBus’ project, you’ll notice a new “BridgeConfiguration.bcs” file:

This file will contain the definition of the ‘Bridge’ between two systems connected to Azure. If you open the “bcs” file you’ll get an empty canvas and in the toolbox there are many options to fill the bridge configuration with:

For example pick the ‘Xml One-Way Bridge’. This is one-way WCF service endpoint, opposed to the ‘Xml Request-Reply Bridge’ of which you probably guessed it to be a request/response WCF service endpoint. The canvas looks like below:

In the solution explorer you’ll find the two schemas (SourceSchema.xsd and TargetSchema.xsd) and a mapping (Source_to_Target.trfm) I use to test with. The schema by the way is a simple mapping with a concatenation and the new if-then-else functoid (which isn’t called a functoid anymore).

Also a configuration file has been added to the solution: “XmlOneWayBridge1.BridgeConfig”, which in the end is just an XML configuration file but a so called ‘Bridge Editor’ has been created for ease of editing. Double clicking the file results in this.

In this we recognize the BizTalk pipeline! In the message types module you specify the schema's you wish to be accepted by this endpoint. The validator is just an XML validator of which I assume it can be replaced by a custom component in the future. However keep in mind that this is running in the cloud so Microsoft will be careful with custom components which might impact the performance and stability of Azure.

Enriching is interesting, it feels like property promotion in BizTalk. It opens the opportunity of content based routing. You can enrich from SOAP, HTTP, (SQL) Lookup and XPath. In the picture below I created XPath properties in the SourceSchema.xsd.

The transform module also looks familiar to BizTalk developers. Obviously only the maps that are defined as a message type in the bridge show up here:

If you build the solution now, you’ll get errors. The errors indicate that without a so called ‘Connected Entity’ the message send to this end point cannot be processed. So we need to add one to the bridge configuration. In this case I’ll write the message to a queue, but that can also be an external service that the message is relayed to. When the Queue is dropped on the canvas, it can be connected to the XmlOneWayBridge by using a ‘Connection’. Be aware you can only connect on the red dots and dragging the queue shape doesn’t create a queue on the ServiceBus.

Building this still results in an error about a filtering expression. This is caused by the fact that by default a filter expressing is specified on the connection to the Queue. To fix this click on the connection, select ‘Filter Condition’ and set the filter to ‘Match All’ (or specify a filter).

Now the project will build and the next step will be deploy to Azure!

Because Azure EAI still is in a lab phase, you need to go to a different portal than the regular Azure Management portal: https://portal.appfabriclabs.com/Default.aspx

Go there and create a so called “labsubscription”. If you haven’t created such a subscription before deployment you’ll receive an error: “The remote name could not be resolved: '<servicenamespace>-sb.accesscontrol.appfabriclabs.com'”

From the project file menu select ‘Deploy’ and the regular Azure deploy dialog shows up. Specify the Shared Secret and the project will be deployed:

Now it is time for fun by testing the bridge with the tools that come with the SDK. The set of tools contains the ‘MessageSender’ tool, which takes the account credentials, bridge URL, sample message and content type. This message was sent to the bridge:

<?xml version="1.0" encoding="utf-8"?>
<SourceSchema xmlns="http://MyFirstAzureEAI.SourceSchema">
<FirstName xmlns="">FirstName1</FirstName>
<LastName xmlns="">LastName1</LastName>
<Age xmlns="">1</Age>
<Country xmlns="">Country1</Country>
<BirthDate xmlns="">1900-01-01</BirthDate>
</SourceSchema>

Now the message is sent to the bridge and went through the pipeline where it was transformed from ‘SourceSchema’ to ‘TargetSchema’. After the pipeline processing has been done the message is written to the queue, TestEAIQueue in my case.

With another tool also from the SDK you can read messages from the queue: ‘MessageReceiver’.

In the message read from the queue you can derive the FirstName and LastName field from the SourceSchema have been concatenated in the TargetSchema. Also it has been derived that someone with and age of 1 is not an adult (IsAdult=false).

Wow, my first BizTalk-in-the-cloud-round-trip is working!

There is a lot more to discover and it is a CTP but this is working quite nice already. One thing we’re lacking in BizTalk today is the possibility to debug by pressing F5. I’m wondering if that will change with Azure EAI in the future.

Didago IT Consultancy

BizTalk in the Cloud, One Step Closer

Jean-Paul Smit — Fri, 16 Dec 2011 23:01:46 GMT

We all know Microsoft is putting an enormous amount of effort in their cloud initiative called Azure. It started with compute and storage but in the mean time it has grown and more and more products are released in a cloud version before the on-premise version is released. An example is Microsoft Dynamics CRM Online.

Since the September 2011 release of Azure the Service Bus is part of it. In the service bus we find things we know from BizTalk. The most well-known ones are Queues, Topics and Subscriptions. This so called ‘Brokered Messaging’ introduces message queuing and durable publish/subscribe messaging, which is the basis of BizTalk messaging.

Of course BizTalk is capable of a lot more, but Microsoft released today the CTP of Windows Azure Service Bus EAI and EDI. If we take a look at this release we immediately recognize the BizTalk influences in there. It is a CTP but it is showing the direction Microsoft is going.

Let’s focus on EAI for now. To install the SDK you just need a regular development machine with Windows 7/2008, .NET4 and VS2010. Download the SDK here. Installing the SDK will install some new VS templates under the section ‘ServiceBus’.

When the EAI project is created, the Solution Explorer looks like this:

And also new toolbox items are present, in which you’ll recognize the ServiceBus features Queues and Topics:

So the first step in BizTalk development would typically be to add a schema. This can be done by the regular ‘Add Item’ option in the Solution Explorer. There the first real BizTalk items show up! We all know the Maps and Schemas!

One thing that caught my eye was the extension of the mapping file, not BTM but TRFM. I can only speculate what the extension stands for.

Adding the schema is nothing new since adding XSD’s has been part of Visual Studio 2010 from the beginning.

Next step is creating a map, after adding the item another familiar screen shows up!

As well as selecting the source and destination schema. Unfortunately it isn’t possible to drag the schemas onto the mapping canvas.

And of course the toolbox is also familiar, although some items are missing, new or named differently from BizTalk.

This is definitely a preview of the new mapper as it will show up in the next version of BizTalk. Although the mapper has improved in BizTalk 2010, this one is even more advanced (and worth a blog post by itself!). For example I put the ‘If-Then-Else’ expression on the canvas:

This is really awesome!

Testing the map works quite the same way as in BizTalk, however it isn’t possible yet to generate a sample message from the schema so you need to create one yourself.

Typically you would also create artifacts like orchestrations, pipelines, etc, but they are missing in this CTP. However it won’t be a surprise that at least orchestrations will show up with WF4 in the near future.

So now we have a schema and a mapping, now what to do with it? Keep in mind that this is all Azure stuff so we need to deploy it into the cloud.

I’ll discuss these steps in my next blog post, but we’re definitely moving towards BizTalk in the cloud! Exciting stuff!

Didago IT Consultancy

Kendo UI: Managing data changes on the client and sending it back to ASP.NET MVC

Nathan Pledger — Wed, 14 Dec 2011 15:48:36 GMT

My few regular readers will know that I’m a big fan of Telerik and their products. Their product range is comprehensive, the support top-notch and their evangelism and engagement is second to none. Whilst usually involved in the .NET space from ASP.NET UI components through to testing platforms, they have recently branched out into an HTML5/JavaScript UI suite, called Kendo UI.

The more time I spend with ASP.NET MVC, the more I learn about everything that is actually going on in a web request, which is no bad thing and highlights a fault of my own professional development; depending on ASP.NET WebForms to hide the guts of the HTTP request away from me. In gaining this “missing knowledge”, I’ve developed my JavaScript skills tremendously and as such am able to think up some sweet user experiences.

My current requirement is a simple master->detail data structure and editing experience. Obviously this data-structure should not require the user’s knowledge or understanding but as anyone knows, effectively creating a seamless master->detail scenario without some degree of complexity or unnecessary user steps can be challenging. In playing around with the ASP.NET MVC grid it quickly became apparent that the guts of the grid control was becoming a barrier to rapid understanding and deployment, again, this considering I’m relatively new to MVC and the powered-by-unicorns “convention over configuration” pattern. What if I could rule out all the complex data-structure parsing, AJAX and the like and have the entire editing experience occur on the client?

The Kendo UI suite does provide integration with the server and therefore actual data, but only insofar as facilitating AJAX requests. This is fine, as I’m fairly well versed in AJAX, JavaScript and the MVC pattern now. However, I wanted to avoid having to return to the server for “mini edits” via a full POST or AJAX. So I did not want:

Two steps: one for editing master data, the other for editing individual child data
AJAX updates: updating child data in lieu of a complete POST and onward persistence (this would require some session state of some form which I am keen to avoid as this project is being developed with future cloud installation in mind)

What I needed was complete client-side editing and a single POST.

And it turns out it’s all very simple.

Given the data structure:

I created the view with the KendoUI grid in, the model containing a series of properties that would hold the modifications made on the client and the controller to tie it all together.

View

The grid is easily created, much like a jQuery UI widget:

<div id="valuesGrid"></div>

I wanted to handle everything on the client, so in in initialising my grid, I needed to consider how I was going to do this. I decided to create a few properties in my Model, which would be rendered as hidden input elements in the form element. This would allow me to manipulate items on the client and post back the individual fields as a single POST, processing them on the server.

My fields are below (in Razor syntax):


@Html.HiddenFor(model=>model.OriginalLookupValuesJson)
@Html.HiddenFor(model => model.NewLookupValuesJson)
@Html.HiddenFor(model => model.EditedLookupValuesJson)
@Html.HiddenFor(model => model.DeletedLookupValuesJson)

On the GET, the controller populates the detail records by setting the OriginalLookupValuesJson field to the JSON representation of the data-structure.

On the client-side, these are manipulated by “overriding” the built-in CRUD methods of the Kendo UI grid:


$(document).ready(function () {
    var json = $('input#OriginalLookupValuesJson').val();
    var data = eval('('+json+')');
    var dataSource = new kendo.data.DataSource({
        transport: {
            read: function (options) { 
                options.success(data);
            },
            create: function (options) {
                $("input#NewLookupValuesJson").val(kendo.stringify(options.data.models));
            },
            update: function (options) {
                $("input#EditedLookupValuesJson").val(kendo.stringify(options.data.models));
            },
            destroy: function (options) {
                $("input#DeletedLookupValuesJson").val(kendo.stringify(options.data.models));
            }
        }, //transport
        batch: true,
        pageSize: 4,
        schema: {
            model: {
                id: "ID",
                fields: {
                    ID: {
                        editable: false,
                        nullable: true
                    },
                    LookupSetID: {
                        editable: false,
                        nullable: true
                    },
                    Value: {
                        editable: true,
                        validation: {
                            required: true
                        }
                    },
                    Description: {
                        editable: true
                    }
                } //fields
            }, //model
            data: "data",
            total: function (result) {
                result = result.data || result;
                return result.length || 0;
            } //total
        } //schema
    });

    $("#valuesGrid").kendoGrid({
        dataSource: dataSource,
        editable: true,
        toolbar: ["create"],
        height: 250,
        scrollable: true,
        sortable: true,
        filterable: false,
        pageable: true,
        columns: [
            {
                field: "Value",
                title: "Value"
            },
            {
                field: "Description",
                title: "Description"
            },
            {
                command: "destroy"
            }
        ]
    });

The script implements the following:

Localises the JSON from the OriginalLookupValuesJson field into a variable, which is then evaluated into a JavaScript object
A dataSource object is then configured that takes the evaluated JavaScript object as a source for the read implementation. The create, update and destroy implementations are overridden by setting their output as the previously mentioned hidden fields. The results of which will be passed back into my Controller within the Model.
Initialises and configures the grid with the dataSource variable and the user-interface aspects I require.

Unfortunately, when you submit the form in a POST, the hidden fields used to monitor modifications are exactly as they were when they were requested: blank. You need to synchronise the internal data structures of the grid with the hidden fields by intercepting the form POST by adding the following BLOCKED SCRIPT


$("form").bind("submit", sync);
});

function sync() {
    alert('sync');
    $("#valuesGrid").data("kendoGrid").dataSource.sync();
}

Model

The Model itself is supremely simple and contains the principle object of the Master object (LookupSet) and the four fields used to store the JSON and allow the manipulation of the LookupValues on the client-side and persistence of the changes on the server-side.


public class LookupModel : ModelBase
{
    public LookupSet LookupSet { get; set; }
    public IEnumerable<SelectListItem> DataTypes { get; set; }
    public string OriginalLookupValuesJson { get; set; }
    public string NewLookupValuesJson { get; set; }
    public string EditedLookupValuesJson { get; set; }
    public string DeletedLookupValuesJson { get; set; }

    public LookupModel()
    {
    }

}

I create my models within a Factory class, ModelFactory, which has a method:


public static LookupModel CreateLookupModel(int id)
    {
        LookupModel model = new LookupModel(); 
        using (CoreEntities coreEntities = CoreEntitiesFactory.Create(configuration))
        {
            model.LookupSet = coreEntities.LookupSets.Include("LookupValues").SingleOrDefault(q => q.ID == id);
            JavaScriptSerializer javaScriptSerializer=new JavaScriptSerializer();
            model.OriginalLookupValuesJson = javaScriptSerializer.Serialize(new { data = GetLookupValueModels(model) });
        }
        return model;
    }

The method creates a new LookupModel and interrogates the data-store for the requested data. This is implemented using Entity Framework but obviously can be replaced with your own framework.

In order to have the detail data (LookupValues) processed at the client, it needs to be serialized into JSON format, using the JavaScriptSerializer class. This is called with the result of the method GetLookupValueModels(), which is shown below:


private static List<LookupValueModel> GetLookupValueModels(LookupModel model)
    {
        List<LookupValueModel> lookupValueModels = new List<LookupValueModel>();
        foreach (LookupValue lookupValue in model.LookupSet.LookupValues)
        {
            LookupValueModel lookupValueModel = new LookupValueModel()
            {
                Description = lookupValue.Description ?? string.Empty,
                ID = lookupValue.ID,
                LookupSetID = lookupValue.LookupSetID
            };
            if (model.LookupSet.DotNetDataType == typeof(string).FullName)
                lookupValueModel.Value = lookupValue.System_String;
            if (model.LookupSet.DotNetDataType == typeof(int).FullName && lookupValue.System_Int32.HasValue)
                lookupValueModel.Value = lookupValue.System_Int32.Value.ToString();
            if (model.LookupSet.DotNetDataType == typeof(decimal).FullName && lookupValue.System_Decimal.HasValue)
                lookupValueModel.Value = lookupValue.System_Decimal.Value.ToString();
            lookupValueModels.Add(lookupValueModel);
        }
        return lookupValueModels;
    }

This takes the Entity Framework objects and creates a LookupValueModel for each, returning the result. This is then wrapped up in an anonymous type, which assigns the result to the “data” property. The result of which would be typically:


{
    "data": [
        {
            "ID": 3,
            "LookupSetID": 2,
            "Value": "XXX",
            "Description": "Description for XXX"
        },
        {
            "ID": 4,
            "LookupSetID": 2,
            "Value": "YYY",
            "Description": "Description for YYY"
        },
        {
            "ID": 5,
            "LookupSetID": 2,
            "Value": "ZZZ",
            "Description": "Description for ZZZ"
        }
    ]
}

As this is placed in the model property OriginalLookupValuesJson, this is sent to the client as part of the form, and correctly rendered by the Kendo UI grid component.

Controller

For completeness, the HTTP GET request is implemented by the controller as follows:


public ActionResult EditLookup(int id)
    {
        ActionResult result;
        LookupModel model = ModelFactory.CreateLookupModel(id);
        if (model.LookupSet == null)
        {
            result = View("InvalidLookup", ModelFactory.Create<GenericPageModel>("Invalid lookup"));
        }
        else
        {
            model.Title = string.Format("Edit lookup '{0}'", model.LookupSet.Name);
            result = View("EditLookup", model);
        }
        return result;
    }

But where we are interested in is the POST, which will take the modified values from the hidden form fields and implement the modifications on the data-store. The modifications arrive within the hidden fields as JSON, so it is a simple matter to rehydrate those to usable data that we can work with by deserializing the LookupValues back into CLR objects. I use the Deserialize<T>() method from this StackOverflow post (external link)" href="http://stackoverflow.com/questions/2246694/how-to-convert-json-object-to-custom-c-sharp-object">StackOverflow post:


private static T Deserialize<T>(string json)
    {
        T obj = Activator.CreateInstance<T>();
        MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(json));
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
        obj = (T)serializer.ReadObject(ms);
        ms.Close();
        return obj;
    }

Then I call that for each of the modification types in the HTTP POST handler of my Controller (excluding the wider persistence code):


[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult EditLookup(LookupModel model)
{
    ActionResult result = View(model);
    if (ModelState.IsValid)
    {
                    List<LookupValueModel> modifiedLookupValues = Deserialize<List<LookupValueModel>>(model.EditedLookupValuesJson);
                    List<LookupValueModel> createdLookupValues = Deserialize<List<LookupValueModel>>(model.NewLookupValuesJson);
                    List<LookupValueModel> deletedLookupValues = Deserialize<List<LookupValueModel>>(model.DeletedLookupValuesJson);
    }

    return result;
}

How you handle the individual CUD methods is dependent on your persistence layer.

Running Weltmeister in IIS 7

chilberto — Wed, 14 Dec 2011 09:51:05 GMT

The Impact Javascript Game Engine comes with level editor: Weltmeister. This is primarily built with javascript but does include some php scripting.

This post will hopefully save some windows developers some time getting started.

There is also an open-source project available that accomplishes this without installing PHP. This accomplishes this by introducing ASPX pages which mimic the PHP scripts.

I am running a basic install of IIS 7.0 on Windows 7. In summary, the steps I took to get the level editor to function were to install PHP in IIS and to run the site with windows authentication.

Installing PHP

Setting up PHP in IIS is as a simple as using the web installer via the PHP in IIS site and then performing some configuration of PHP in IIS. There is a video regarding the steps required after the installation.

Security

Because the Weltmeister must interact with the file system, sufficient access rights must be given. The easiest way is to enable Windows Authentication on the site.

I'm in the MXP for Architects!

Bas — Thu, 17 Nov 2011 08:55:00 GMT

"the what for Architects?!", you might ask yourself? MXP stands for Microsoft eXcellence Program, and is a unique collaboration between my employer (Achmea) and Microsoft, with the aim to train people, who will operate as (technical) leaders within the Microsoft community within Achmea. The participants will be intensively be trained and coached (on the job) for two years, to increase their skill on several competences: leadership communication organizational insights strategic insights...(read more)

Fast Search for SharePoint caveat: Apply a sortformula with managed properties of type decimals

Bas — Sat, 05 Nov 2011 08:53:00 GMT

Fast Search for SharePoint provides four great possibilities to influence the sort order of your resultset that was returned: Sort by Managed property Sort by Rank Sort by Formula Sort in Random order When I was working on my presentaion and demo for the diwug (Dutch Information Worker User Group) last week, to show off on how you can improve your search experience by using custom ranking models, custom sort orders and extending the pipeline, I ran into an issue that I wasn't aware off. When...(read more)

Yet Another Logging Framework

Marc Jacobi — Fri, 21 Oct 2011 11:30:27 GMT

This blogpost is a brain dump on a new logging framework I’m planning to write. If you have any additions or suggestions please leave them as comments.

So why do we need, yet another Logging Framework. Well, because I cannot find in others what I think is important and also I want to leverage the Diagnostics Trace code I have already written.

What scenarios should this Logging Framework be able to handle?

Easy to use.
It should be easy to configure and easy to call. Any provider based mechanism (log targets) is bound to have config associated with it, but at least give good feedback on any problems that might occur. Convention over configuration and MEF might ease the problems.
One liner.
When using it, you should only have to write one line of code. This is not always feasible but it is a good starting point. Why is this important? Because you want to make it easy on the poor developer that is using your ‘yet another logging framework’. The use of Aspects (PostSharp) can also be of use.
On the other hand, most applications that use a 3rd party library almost always create a façade for interacting with it. So its better to have a good API that is easy to integrate into a façade than to have an awkward API in order to force it all into one line of code.
Uses the TraceContext (source) information to ‘automatically’ enrich the log entries. The TraceContext now has a method to AddContectTo an Exception, but could be extended to also AddContextTo a LogEntry.
Fallback log targets.
Have a mechanism to fallback on log targets when they are not available. This answers the question: were do you log the exception that you cannot connect to your log target.
Integrated .NET support for WCF and ASP.NET.
Make use of the extra information that lives in those contexts and allow that context to be easily added to the log entry. Both these contexts also support some kind of interception (think Behaviors for WCF and Modules for ASP.NET) to allow automatic logging.
Log to multiple log targets at the same time – each with unique filters.
The default System.Diagnostics TraceListeners will already do this. Also be able to retrieve different types of logs in the code (error log, message log, security audit log etc).
Use that same log framework for technical logging as well as functional auditing.
There is no reason why a logging framework cannot be used for (more) functional logging also, provided the they use unique ‘streams’.
Different log entry formats.
Different log targets may require different log entry structs. Still I would prefer to use the existing diagnostics code. This means that those structures has to be serialized and deserialized. I think JSON can be of great help here.
Distributed and Correlated.
You want to be able to correlate log (and trace) entries made by different parts of the system. This allows you to get a good impression to what happened where and why.
Support debug-only log entries.
Conditional compilation on DEBUG. No biggie, just useful.
Asynchronous logging.
This is tough one. You want Async logging in order to minimize performance impact on the running thread – actually this is more a tracing issue than a logging issue, assuming logging doesn’t output a whole lot of entries per second). But making it asynchronous can also mean that you lose that one vital entry just before the app crashes. More on this later.

Using System.Diagnostics

The idea is that we use as much of the existing logging technology as possible. That means reusing and extending the main classes of the System.Diagnostics namespace. TraceSource can be derived into LogSource and provide the basis for a log target. Each LogSource can specify a collection of TraceListeners. Custom TraceListeners can be used as well as the out of the box ones.

But using these TraceListseners means that all Log information has to be squeezed through a single string (essentially – worst case). This coupled with the fact that different log types might require different log entry structures leads to one conclusion. We have to serialize the complex data into a string so that it can be output by different log targets (Sinks) and mapped to their most appropriate fields.

The use of JSON would be excellent here, also because JSON is somewhat readable even in its serialized form. So you can still make sense of it even when its written to a text file. The object structure that is used will be partly fixed, we will need some known fields to extract data needed for further processing. But custom structures can also be easily serialized to JSON and on the receiving side, easily serialized into generic data containers (ExpandoObjects) for use in the viewer.

Formatting this complex data into something that makes sense for the specific log target is done when reading the log, not while writing it. This not only saves a little performance hit while writing the log entry, it also allows for a more versatile viewer.

Performance

One of the obvious ways to decouple the performance costs of tracing and logging is to take the processing of the log entry onto a background thread. Only the data gathering takes place on the active thread all other operations will be done on the background thread.

The trouble with this is that you can lose potentially critical log entries just before your application crashes. One possibly way to have the best of both worlds is to use the log level (Critical, Error, Warning and Info) as an indication of priority. That could mean that Critical log entries are always logged on the active thread. The other levels are processed by the background thread starting with Error, Warning and Info as least significant.

We have to provide some way to identify the order of these entries (can be a simple sequence number) in order to be able to view them in the correct order. Gaps in the sequence can be detected and displayed in the viewer. This mechanism will also make it easy to merge log ‘files’ from different machine into one.

If we take formatting out of the write-a-log-entry process, we might also need to revisit the Tracing code we have so far in order to make that option available in Tracing too.

Reading Log entries

For each (type of) log target a Sink is needed that knows how to put the log entry data into its storage. Think for instance Enterprise Library Logging block or Log4Net or simply the event log. A TraceListener is implemented for each target that knows how to take that one string and persist it in the most optimal way.

When those (types of) targets also want to play in the log viewer, they also have to expose a Provider: an object that knows how to read log entries from its storage and provide them to the viewer.

The viewer will be able to union all log entries from all providers and sort them into the temporal sequence they were written in. Merging of different (machine) sources is also possible.

Of course the viewer would be able to filter and even search through the entries.

I think it would be advantageous to implement an OData REST service as a source for all the log entries. This allows easy access to the log entries for all kinds of purposes and provide a flexible basis for retrieving log entry information for different applications. Both Xml and Json formatting can be supported.

Closing remarks

I am sure that a lot more issues will present themselves once a more detailed design is made and implementation starts. But I think this WILL make a pretty nice logging framework if we can pull it off. Writing this blog post has helped me to structure my thoughts more on the subject and I hope it was a pleasant read for you, perhaps even an inspiration to tweak the logging framework you are no using.

Windows Azure has best performance of cloud service providers

Mark Willems — Fri, 14 Oct 2011 11:31:00 GMT

http://www.businesscloudnews.com/applications/592-top-25-cloud-service-providers-revealed.html

Want to speed up your website use a CDN for commonly used files

Mischa Kroon — Fri, 30 Sep 2011 13:18:00 GMT

Introduction Serving files from a website is easy just link to them and you're done. Serving files from your website in the most optimal way isn't that easy, first you have to think about things like making sure that the caching is right and if the files are being used a lot on other sites. If files are being used a lot on other sites then it could be that the user already has a copy of this file lying around, let's say you use jQuery on your site. You're not the only one using this...(read more)

Version Control by Example: Review and how to get it for free.

Mischa Kroon — Fri, 30 Sep 2011 12:32:00 GMT

I just read: Version Control by Example It's a free printed book which can be shipped to your home for free by filling out a page full of questions. If you want the details on how to get it shipped to your home or have any questions about it find out the details here . Quick review of the book: Introduction The book gives you a quick intro about version control systems, it tells you about the history of version control systems and how they got here. What the different commands are for the version...(read more)

Specification Pattern Continued

Dries Marckmann — Thu, 29 Sep 2011 04:35:00 GMT

In a previous post, I talked about the specification pattern. In the last sentence I promised you to keep you posted on the next version of the implementation. I still owe you guys that result. So without further ado:

Download it here.

The implementation itself is pretty straightforward. The class has a protected property Predicate that takes in a Lambda expression that results in a boolean ( a predicate). It is protected so that you have to set the predicate in the derived class.

/// <summary>
/// Use the Specification to make some complex (business) logic explicit. 
/// </summary>
/// <typeparam name="TEntity">The Type of entity that is the subject of the specification</typeparam>
public abstract class Specification<TEntity>
{
     
    protected Func<TEntity, bool> evalCompiled;
    protected Expression<Func<TEntity, bool>> evalExpression;

    protected internal Expression<Func<TEntity, bool>> Predicate
    {
        get
        {
            return evalExpression;
        }
        set
        {
            evalExpression = value;
            evalCompiled = evalExpression.Compile();
        }
    }

    /// <summary>
    /// Use this method to evaluate the predicate for a single item.
    /// </summary>
    /// <param name="item">The item to examine</param>
    /// <returns>A boolean.</returns>
    public bool IsSatisfiedBy(TEntity item)
    {
        return evalCompiled(item);
    }

    /// <summary>
    /// Use this method to filter IQueryables using the Predicate 
    /// </summary>
    /// <param name="candidates">The IQueryable that needs filtering</param>
    /// <returns>An IQueryable that has the added filter</returns>
    public IQueryable<TEntity> SatisfyingElementsFrom(IQueryable<TEntity> candidates)
    {
            return candidates.Where(evalExpression);
    }
}

The usage is simple.

Suppose that there is a business rule that big orders need approval by a manager. Big orders are orders above a 1000 euros. There are 2 cases when we need to know whether an order is a big order. First, when the order is created so that we can send a request for approval to the manager and second in a managers app that shows all the big orders.

The class IsBigOrderSpecification is a business rule made explicit. This rule could be throughout your system. Here’s what it looks like:

class IsBigOrderSpecification : Specification<SalesOrderDetail>
{
    public IsBigOrderSpecification()
    {
        Predicate = (o => o.LineTotal >= 1000);
    }
}

When a new order is created we can now use this specification to enforce the business rule.

SalesOrderDetail orderLine = new SalesOrderDetail();
orderLine.LineTotal = 999;
bool isBigOrderLine = isBigOrderLineSpec.IsSatisfiedBy(orderLine);
if (isBigOrderLine)
{
    Console.WriteLine("LineTotal {0} means this is a big orderline.", orderLine.LineTotal);
}
else
{
    Console.WriteLine("LineTotal {0} means this is a not big orderline.", orderLine.LineTotal);
}

Yet the same specification can be used when querying for these big orders in the system. Because it works on IQueryable<SalesOrderDetail> we get all the advantages of deferred execution.

AdventureWorksEntities db = new AdventureWorksEntities();

var query = from so in db.SalesOrderDetails
                        select so;

var bigOrderLines = isBigOrderLineSpec.SatisfyingElementsFrom(query);

Console.WriteLine("{0} big OrderLines in database", bigOrderLines.Count());

Composite specification

In the solution you can also find the code to create composite specifications. Composite specifications are specifications that have been combined. What if we changed the business rule (the manager is getting to busy) to state that only big orders from sales people that have little experience have to be approved. Little experience has been qualified at working at the company less than 2 years. You probably get an IsExperiencedSalesPersonSpecification.

We are now able to combine the 2 specifications as follows:

bool needsApproval = isBigOrderLineSpec.And(new IsExperiencedSalesPersonSpecification().Not()).IsSatisfiedBy(orderLine);

My opinion is that this specification pattern is quite powerful in specifying and enforcing business rules in a distributed system.

How to configure AutoTest.Net to use Snarl notifications

Vagif Abilov — Wed, 21 Sep 2011 13:36:11 GMT

Important part of continuous testing is instant and clear notification on test results. Developer should not need to inspect small text in Visual Studio output window, test execution results should flash like traffic lights, especially when things go wrong.

There are several commonly used notification applications for Windows, and AutoTest.Net is integrated with two of them: Growl and Snarl. They provide good visualization of test execution results. Here is how Snarl notification looks:

While integration with Growl works without any adjustments, Snarl needs to be configured to work with AutoTest.Net. Here is how you do it:

1. Open Snarl preference dialog

2. Go to “Network” tab and select “Yes” for “Listen for incoming Growl or Snarl notifications?

3. Start Visual Studio (AutoTest.Net or ContinuousTests a.k.a. MightyMoose must be installed)

4. Find and highlight “AutoTest.Net on 127.0.0.1”

5. Highlight in “Notification Classes” “Run succeeded”, then press “Configure”

6. Select “Yes” for “use custom icon?”

7. Go to AutoTest.Net or ContinousTests installation folder and find in Icons subfolder circleWin.png. You should see the icon with green light:

8. Repeat the previous step for classes “Run succeeded with warnings” and “Run failed” and choose for them icons with yellow and red light.

Now Snarl is configured to receive notifications from AutoTest.Net.

How to unit test a method that has void as return type

Dennis van der Stelt — Thu, 15 Sep 2011 06:01:38 GMT

How do I test a method that returns void? For example a method like this.

public void Process(int leadId)
{
    decimal price = _calculator.CalculateNormalLead(leadId);

    Lead lead = new Lead(leadId, price);

    _leadRepository.Save(lead);
}

How to test what the state of the lead object is? This is a question that comes up a lot of the time. It has many different answers. Some options:

Return a type anyway, even though you don’t use it. Or expose a property with the result. This are design changes that are only neccesary for testing. I’m sure that’s not what we want.
Check what the method changed, like records in the database. That’s a slow integration test.
Split the methods so that one portion of it returns something, and the second method just takes the result and uses it. This way however, you’ll have to make two calls to your class, which I think is even worse than the previous two options!
Expose internals by using the InternalsVisibleTo attribute. But now you have to make changes to the design of your class again, making private methods or properties internal.
Another option is to accept you can’t test everything. What you can however check is
- Check if it throws exceptions
- Check if it changes mutable objects you pass in as parameters
- Do interaction based testing. Either write mocks or use a mocking framework to verify if calls were made to another method.

This last thing is something we can really use. Now this might not always work, but in our case it’s very usable. Imagine we have a repository that in production kind of works like this.

public class LeadRepository : ILeadRepository
{
    public void Save(Lead lead)
    {
        throw new NotImplementedException("Sorry, this is for an integration test.");
    }
}

Now I said kind of, because I don’t want to bother you with a lot of database and query stuff. But our lead enters this class and we’d really like to have this one! This repository implements an interface and the class is injected into the Invoicing class, where our Process method is. For the complete example, check the solution. But for now, check out this FakeRepository I created to use during testing.

public class FakeRepository : ILeadRepository
{
    public Lead CreatedLead { get; private set; }

    public void Save(Lead lead)
    {
        CreatedLead = lead;
    }
}

The only thing this repository does, is put the lead it receives into a property of the FakeRepository class. Remember that the repository in production does not have this property, so normally it’s never exposed.

Now we can write a test that injects our own fake objects and when asserting, we use the property of our FakeRepository to check the state of our lead.

[TestMethod]
public void Does_MapPropertiesCorrectly_When_CalculatingALead()
{
    // Arrange
    int leadId = 1;
    decimal leadPrice = 0.5m;
    FakeRepository fakeRepository = new FakeRepository();
    FakeCalculator calculator = new FakeCalculator(leadPrice);

    // Act
    Invoicing invoicing = new Invoicing(calculator, fakeRepository);
      invoicing.Process(leadId);

    // Assert
    Lead result = fakeRepository.CreatedLead;
    Assert.AreEqual(leadId, result.LeadId);
    Assert.AreEqual(leadPrice, result.Price);
}

See how easy it sometimes is? Download the complete solution here.

Locking in SQL Server and the nolock and readpast hints

Dennis van der Stelt — Tue, 13 Sep 2011 14:25:30 GMT

I’ve written about transactions, the TransactionScope in .NET before.

Still I was recently surprised with the comment that I had to use the READPAST in my queries. So I started investigating and felt I had to blog about this. First of all, I’m not going to discuss every option here, just a few basics so you get what the differences are. If you want to know more, check out the BOL/MSDN documentation. Here’s a good starting point.

I’ve created a demo to show locking mechanisms. The database I used was the only one at hand at the time I wrote this, and it’s the Cookbook database from Dennis Doomen his Silverlight Cookbook example. It only has one table and a full select outputs the following result in my case.

Shared Locks
First I want to tell about Shared Locks. Normally when you start a transaction like the code below, you place a shared lock until the transactions is over. A shared lock means someone else is still able to read the data you’ve locked, they just now allowed to update it. Because you want to be sure that the data you read, is still the same at the time you commit a transaction (to update data, for example).

SqlCommand cmd = new SqlCommand();
cmd.Connection = GetConnection();
cmd.CommandText = "select * from Recipes with (readpast)";
var reader = cmd.ExecuteReader();

The GetConnection() method initiates and opens a connection to my database.

ReadCommitted transaction
A regular transaction is done with isolation level ‘ReadCommitted’. This means that you cannot read data that has an exclusive lock on it. This is achieved when you update a row and another transaction tries to read it while you still have your transaction open. Here’s the update code.

TransactionOptions transactionOptions = new TransactionOptions();
transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;

using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew,transactionOptions))
{
    SqlConnection con = new SqlConnection();
    con.ConnectionString = ConnectionString;
    con.Open();

    SqlCommand cmd = new SqlCommand();
    cmd.Connection = con;
    cmd.CommandText = "update Recipes set Description = 'ChangedDescription' where Id = 1";                
    cmd.ExecuteNonQuery();
}

And here’s the code in another transaction that tries to read it.

SqlCommand cmd = new SqlCommand();
cmd.Connection = GetConnection();
cmd.CommandText = "select * from Recipes";
var reader = cmd.ExecuteReader();

while (reader.Read())
{
    Console.WriteLine("Description : {0}", reader["Description"].ToString());
}

The second method should not be able to retrieve data from the table until the transactions is closed. The original transaction can place multiple kinds of locks, including a lock that concerns the entire table. The select query I wrote just simply retrieves everything, and as the first row (at least) is locked, it’s not able to retrieve anything. If you add a where clause to filter out just the second row, it should be able to load the data anyway.

NOLOCK hint
So with the NOLOCK / READUNCOMMITTED hint/isolation-level, you tell your transaction (or query) that you want to read dirty data. Even though the transaction hasn’t been committed yet, you still want to read its data. A problem can occur that when the other transaction is rolled back, you’ve loaded data that isn’t there anymore. Worse yet, when SQL Server decides to shift data between different pages, you might simply loose a lot of data because it’s not there!

SqlCommand cmd = new SqlCommand();
cmd.Connection = GetConnection();
cmd.CommandText = "select * from Recipes with (nolock)";
var reader = cmd.ExecuteReader();

The result is that you get the change from the update statement. But because we never commit anything, everything is rolled back and we’ve read a dirty state.

Description : ChangedDescription
Description : Description2
Description : Description3
Description : Description4

READPAST hint
Now with the READPAST hint you’re telling SQL Server you do NOT want to read dirty data. Instead, it skips the rows that are locked.

SqlCommand cmd = new SqlCommand();
cmd.Connection = GetConnection();
cmd.CommandText = "select * from Recipes with (readpast)";
var reader = cmd.ExecuteReader();

Result is first row not being shown at all! So when we change the update query to ‘where Id = 1 or Id = 2’ we get one row less in the other select query.

Description : Description2
Description : Description3
Description : Description4

Conclusion
Be very, very aware of the problems you might introduce when using these table hints!

Download the demo solution here.

Value of Unit testing

Dennis van der Stelt — Mon, 12 Sep 2011 13:17:27 GMT

There are probably uncountable amount of articles, posts and arguments on to why Unit Testing is so valuable. I just found a nice example that would’ve (or at least should’ve) been caught using Unit Tests. The following code was a bit adjusted to the need of this post, but has a mistake. See if you can spot it.

public class Discount
{
    public Discount(decimal percentage, DateTime startDate, DateTime endDate)
    {
        endDate.Add(new TimeSpan(23,59,59));

        Percentage = percentage;
        StartDate = startDate;
        EndDate = endDate;            
    }

    public decimal Percentage { get; private set; }
    public DateTime StartDate { get; private set; }
    public DateTime EndDate { get; private set; }
}

If you haven’t spotted it, I’d advise you to write a unit test to show that it’s failing. Here’s mine.
I’ve used FluentAssertions by the way, a library I love that helps me assert my code more easily.

[TestMethod]
public void Does_MapPropertiesCorrectly_When_CreatingNormalDiscount()
{
    // Act
    Discount discount = new Discount(5, new DateTime(2001, 9, 11), new DateTime(2011, 9, 11));

    // Assert
    discount.EndDate.Should().Be(new DateTime(2011, 9, 11, 23, 59, 59));
}

What is says is that it’s still 2011/9/11 00:00:00 instead of at the last second of that day. The problem here is that the endDate.Add method adheres to the framework guidelines. That is that you can’t edit an object you get passed by external source, only return new values. So the Add method returns a new DateTime object. We can make the test working with the following adjustment.

public class Discount
{
    public Discount(decimal percentage, DateTime startDate, DateTime endDate)
    {
        endDate = endDate.Add(new TimeSpan(23,59,59));

        Percentage = percentage;
        StartDate = startDate;
        EndDate = endDate;            
    }

    public decimal Percentage { get; private set; }
    public DateTime StartDate { get; private set; }
    public DateTime EndDate { get; private set; }
}

The only change I made was on line 5.

Record Skype

Fadzai Chamba — Wed, 07 Sep 2011 13:54:49 GMT

Just saw this on Channel 9 - http://bit.ly/ojq6Hk. It refers to a blog post by Gal Ratner, http://bit.ly/p093H7. Discussion on Skype API and source code for how to attach to Skype process and redirect conversations allowing you to record them. Check it out.

Something you REALLY should know about dates ! (beeing Kind to DateTime.Kind)

Patrick Wellink — Fri, 02 Sep 2011 14:07:00 GMT

Here we go, some important stuff about dates.....(it's not only BizTalk related) I had a very simple scenario. Webservice Receives a request (with several datetime fields in it) Send the received message to SQL via the WCF adapter For some obscure reason some datetime values originating from the same WebRequest got modified once in the database and some did not. After some tracing we found that the dates were serialized in a different way once inside the webservice. some of the formats we saw...(read more)

Evolution of Windows Explorer

Andries van der Meulen — Tue, 30 Aug 2011 13:05:15 GMT

Nice post of Steven Sinofsky on MSDN blogs about the history and future of Windows Explorer.
http://blogs.msdn.com/b/b8/archive/2011/08/29/improvements-in-windows-explorer.aspx

(edit 31-08-2011)
And Martin Tirion of Microsoft Netherlands wrote about it a day later (in Dutch).
http://blogs.microsoft.nl/blogs/ux/archive/2011/08/30/windows-explorer-in-windows-8-en-user-experience.aspx

Article Published in Dutch .NET Magazine

Jean-Paul Smit — Sun, 28 Aug 2011 12:01:43 GMT

Just before my holiday started, I got the great news that my article on the BizTalk Software Factory had been published on the Dutch .NET magazine site! It is my first article ever!

The BizTalk Software Factory is a community tool that helps BizTalk developers build consistent solutions.

Together with Mr. Dijkstra I wrote an article to explain the advantages of using the BizTalk Software Factory. The concepts of the BizTalk Software Factory can be applied to other technologies as well though.

You can find the article here, but keep in mind it is in Dutch…

Didago IT Consultancy

Datadrop Website Load Tool

Andries van der Meulen — Tue, 23 Aug 2011 15:41:25 GMT

In the last months I’ve experienced a lot of problems with my current internet connection. Due to mysterious reasons there have been data-drops at random times for random periods.

I’ve contacted my ISP (Online.nl), and told them my story. But every time they’ve called me back, they said that they could not find the problem. My connection was always fine.

Irritated by the fact that they could not solve my problem, I asked them what they would need to fix the problem. They answered that they need proof of the failing connection.

So I’ve created a solution.

At the moment they probably are only testing with pings, and my problem isn’t actually a failing connection, but data-loss due package-drops.
So I’ve searched for an small application that I can run on my HomeServer, which measures the internet connection.
Unfortunately I have only found Ping-testers, which wasn’t exactly where I was looking for.

Therefore I’ve decided to build my own tester.

Website Load Tool

The website load tool is a small application build on WPF .Net 4 that will download data with a configurable interval from defined URI’s.
So you set up a series of websites with an test interval of 60 seconds, and keep it running for several days.
Changes of state are written in a Log, so you can collect you own evidence of the stability of your connection.

I’ve released the application on CodePlex, so everybody is free to use it.
It also can come in handy if you need to check network-stability or the availability of your website.

Get it at websiteloadtool.codeplex.com.