Developing dotnet architect

Supporting Cross Origin Resource Sharing (CORS) requests in a WCF Rest service - Part 4

2011-06-24T01:00:00.008+02:00

For background information, see part 1

For message inspection code, see part 2

For operation dispatcher code, see part 3

To include the message inspection in our wcf service for our service we need to bind it to our service. This is done using behaviors. To bind the IDispatchMessageInspector that works on the ServiceEndpoint level we need to implement an IEndpointBehavior and assign it to our endpoint.

To bind the IOperationInvoker and IDispatchMessageFormatter we need to implement the IOperationBehavior that works on the operation level.

This class also works as an attribute so you can decorate your contract and operations with it if need be. It also contains some properties if you want to control the header values.

https://github.com/dhvik/Wcf-cors-behavior/blob/master/CorsBehaviorAttribute.cs

Assigning can be done in many ways. By declarations on the contract (attribute), configuration in the applications configuration file or direct using code. I'm using code since I host the services in a windows service.

var host = new WebServiceHost2(serviceType, false,
new Uri(serviceBaseUrl + serviceName));
var endpoint = host.AddServiceEndpoint(contractType,
new WebHttpBinding(WebHttpSecurityMode.None), "");
//add support for cors (both for the endpoint to detect and create reply)
endpoint.Behaviors.Add(new CorsBehaviorAttribute());

foreach (var operation in endpoint.Contract.Operations) {
//add support for cors (and for operation to be able to not
//invoke the operation if we have a preflight cors request)
operation.Behaviors.Add(new CorsBehaviorAttribute());
}

When we now have all pieces in place we don't need to bother about cross domain requests. Our endpoint and operation behaviors handles this and we don't need to litter our service code with things that don't belong there anyway.

Supporting Cross Origin Resource Sharing (CORS) requests in a WCF Rest service - Part 3

2011-06-24T00:37:00.012+02:00

For background information, see part 1

For message inspection code, see part 2

When a cors request is identified we now have the CorsState object available on our operation level and can act upon this. To be able to skip calling the service method in case of a preflight request we need to implement two extension points in the operation level. Message formatting and operation invocation. Since the preflight request won't have the correct requests message format, we skip the deserializing process and the message using the normal deserializator can results in errors. So in that case we skip both serialization and deserialization.

https://github.com/dhvik/Wcf-cors-behavior/blob/master/CorsFormatter.cs

When it comes to the IOperationInvoker we just skip invoking the operation if we have a preflight request. All other requests uses the original invoker.

https://github.com/dhvik/Wcf-cors-behavior/blob/master/CorsInvoker.cs

In the part 4 we will see how we bind all these extension points together for our service.

Supporting Cross Origin Resource Sharing (CORS) requests in a WCF Rest service - Part 2

2011-06-23T23:55:00.006+02:00

For a background in the subject please see part 1.

To handle Cors requests we can take advantage of the extensibility mechanism that is embedded in WCF. There are many extension points that we can use and the cors problem can be issued in more than one way.

There is a great article, written by Aaron Skonnard, published in the Dec 2007 issue of MSDN magazine, that covers many parts of this mechanism that I can recommend for further reading.

Our main problem is that we need to analyse the incoming request and determine if it is a cors preflight request, cors normal request or a normal request. Preflight request should not reach the service method at all since we don't want to invoke the service method. The other requests should invoke the method but for all cors responses we should add extra headers.

I found a reply by Carlos Figueira in a msdn thread that solves the "analyse message and skip invoking the service method"-part that I used as a start. (as a side note Richard Blewett stated (in the same thread) that we could intercept the message before it reaches the dispatcher by writing a protocol channel. I will leave that excercise to the reader or for another day.)

So to analyse the incoming message we use the first avaliable extension point in the dispatcher (server) that would be the Message inspection stage.

To use this extension point we implement an IDispatchMessageInspector. In this stage we are at the service endpoint and haven't decided wich method of the service that we should call. What we do here is that we look for a cors request (checking if the Origin header is present). If so we create a Cors state object and adds a property to the message so we can use this later on in other extension points.

If it is a preflight request we also create a response message that we should use.

When the message inspector receives the reply we add the headers (and if it was a preflight request, we replace the whole response.

In part 3 we will continue to the operation level where we check the property and omits the call to the service method in case of a preflight request.

View code on github https://github.com/dhvik/Wcf-cors-behavior/blob/master/CorsDispatchMessageInspector.cs

In part 3 we will see how we handle things on the operation level.

Supporting Cross Origin Resource Sharing (CORS) requests in a WCF Rest service - Part I

2011-06-23T23:43:00.008+02:00

If you use try to consume a rest service using JavaScript (jquery) and are using chrome or Firefox (newer versions) you might run into cross domain issues that involves the w3c standard for accessing resources on other domains (or ports).

In short, if you try to request a resource on a page using javascript(call a rest service) that is located on another domain/port then the XMLHttpRequest object that is implemented in the browser will first try to discover if the cross-origin resource is prepared/allows to accept requests from the origin. If this preflight request succeeds then the real request will be fired.
All this is handled by the browsers XMLHttpRequest object so from the JavaScript side this don't affect the code.

The server side code must support cors though.

An example: we take a simple service method that only returns a string.

public string Hello() {
 return "Hello!";
}

If we want to allow cors requests, then we must detect the preflight request and reply accordingly and if it is the real request we should perform the actual method.

public string Hello(){
 //for all cors requests
 WebOperationContext.Current.OutgoingResponse.Headers
     .Add("Access-Control-Allow-Origin","*");
 //identify preflight request and add extra headers
 if (WebOperationContext.Current.IncomingRequest.Method == "OPTIONS") {
      WebOperationContext.Current.OutgoingResponse.Headers
          .Add("Access-Control-Allow-Methods", "POST, OPTIONS, GET");
      WebOperationContext.Current.OutgoingResponse.Headers
          .Add("Access-Control-Allow-Headers",
               "Content-Type, Accept, Authorization, x-requested-with");
      return null;
  }
  return "Hello!";
}

Basically we first add the Access-Control-Allow-Origin header telling that we allow any origins (we can also specify an origin that matches the origin that the request comes from). Then we check if the request is a preflight request (method is OPTIONS). If it is we add extra headers to declare which methods and headers that we allow the real request to contain. There are a few more access-control headers that we can add if we need and these are described in the w3c spec.

To add this code in every method is not a great solution but in part 2 we will see how we can use WCF extensibility to do this in a more elegant way.

Alpha version of IOU tracker

2011-01-02T02:24:00.002+01:00

Have been experimenting with .net4, MVC2 and EntityFramework. The result is a IOU tracker that is available at iou.nu.
Service is free of charge and feel free to try it out.

I know there are several other iou trackers out there, but since the most lack some features and I needed to dig deeper into net4/mvc2/EF anyway so why not give it a try!?

/Dan

TF53010: Errors in the metadata manager when rebuilding OLAP cube

2010-06-09T12:04:00.004+02:00

I was adding new fields to our TFS workitems the other day and wanted them to be part of the olap cube. But when I added them (marked them with the reportable attribute) and processed the cube, i couldn't see them in the cube.
I went reading the Event log on the Data tier of the TFS and found log entries like below


TF53010: The following error has occurred in a Team Foundation component or extension:
Date (UTC): 2010-06-09 09:31:26
Machine: MyTfsServer
Application Domain: /LM/W3SVC/830720315/Root/Warehouse-3-129205184075330719
Assembly: Microsoft.TeamFoundation.Warehouse, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a; v2.0.50727
Process Details:
 Process Name: w3wp
 Process Id: 9316
 Thread Id: 8484
 Account name: DOMAIN\admin

Detailed Message: The pending configuration changes were not successfully added to
the cube because of the following error: Microsoft.AnalysisServices.OperationException: 
XML parsing failed at line 1, column 0: A document must contain exactly one root element.
.
Errors in the metadata manager. An error occurred when instantiating a metadata 
object from the file, '\\?\C:\Program Files\Microsoft SQL Server\MSSQL.3\OLAP\Data
\TfsWarehouse.0.db\Team System.63837.cub.xml'.

  at Microsoft.AnalysisServices.AnalysisServicesClient.SendExecuteAndReadResponse(ImpactDetailCollection impacts, Boolean expectEmptyResults, Boolean throwIfError)
  at Microsoft.AnalysisServices.AnalysisServicesClient.Alter(IMajorObject obj, ObjectExpansion expansion, ImpactDetailCollection impact, Boolean allowCreate)
  at Microsoft.AnalysisServices.Server.Update(IMajorObject obj, UpdateOptions options, UpdateMode mode, XmlaWarningCollection warnings, ImpactDetailCollection impactResult)
  at Microsoft.AnalysisServices.Server.SendUpdate(IMajorObject obj, UpdateOptions options, UpdateMode mode, XmlaWarningCollection warnings, ImpactDetailCollection impactResult)
  at Microsoft.AnalysisServices.MajorObject.Update(UpdateOptions options, UpdateMode mode, XmlaWarningCollection warnings)
  at Microsoft.AnalysisServices.MajorObject.Update(UpdateOptions options)
  at Microsoft.TeamFoundation.Warehouse.OlapCreator.CreateOlap(WarehouseConfig whConf, String accessUser, String[] dataReaderAccounts, Boolean dropDB, Boolean processCube)
  at Microsoft.TeamFoundation.Warehouse.AdapterScheduler.EnsureCubeIsUpToDate()

For more information, see Help and Support Center at http://go.microsoft.com/fwlink/events.asp.

I searched the path in the error message above (on the database server, little bit confusing since the path seems to be a local one, but since the error originates from the database server it makes sense).

I the folder i found several files named Team System.xxxx.cub.xml (where xxxx is digits) and some where 0 bytes long and some contained error xml (seemed to be cut in the middle of writing).
I removed these files and processed the cube again. (I used the Warehousecontroller webservice on the tfs server, https://mytfsserver:8143/Warehouse/v1.0/WarehouseController.asmx?op=Run)

This time the processing went through without any problems and the fields apperared in my cube.

I wonder how these error xml files where created, perhaps if the cube was instructed to reprocess while the iis was restarted or for some other reason.
I'll better check the folder once and a while....

Writing a custom trigger for CruiseControl.Net

2010-05-21T00:51:00.016+02:00

I’ve had some problems regarding the triggering of our nightly builds and has not been able to solve this with the standard triggers that comes with ccnet (using v1.4.4). So finally I took some time (night time, kids are sleeping and there is peace and quiet in the house :) and wrote a trigger that fixed the issue at hand. I will come to the trigger in just a moment but I’ll take some time to explain our ccnet setup.

Interval builds

All our projects are built using CruiseControl.Net and for each project we setup two builds. One interval build that triggers when the source has been changed. This build uses the intervalTrigger that checks the source repository at regular intervals. The interval build compiles the project and performs unit testing and provides feedback to the programmer. This is quite standard setup I guess so there’s no rocket science here…

Nightly builds

The other build is a nightly build that (in addition to the tasks for the interval build) performs analysis, generates documentation and installation packages ready to deploy to a target system. It also creates deliverable folder in a specific ”drop zone” for the project. This folder is named using the label of the nightly build.

Labels

All projects uses the project name and build no as label (like MyProject – 234). We reuse the build number of the interval build for the nightly build so if the last interval build was ”MyProject – 234”, the next time the nightly build is triggered the label for the nightly build is ”MyProject-Nightly – 234”. This creates a side effect that if the nightly build is triggered twice and the interval build hasn’t been triggered, the label is the same. If you remember the drop zone folder it uses the label of the nightly build as a name so if it is triggered twice using the same label, it tries to overwrite the drop zone folder.

This is a big no-no and to solve this I added a nant task that fires in the beginning of the nightly build that fails if the drop zone folder exists.

Triggering the nightly build

So to avoid failing the nightly build, it should only be triggered if an interval build has successfully been completed and the nightly build for that interval build hasn’t been performed.

Normally nightly triggers are defined to run at a specific time every night using a ScheduleTrigger that fires at that time if any changes to the source has been made during the day. In combination with a projectTrigger that only fires if the interval build has been successful we can accomplish the trigger to fire only if the interval is successful.

Problem with projectTrigger

There is a limitation to the projectTrigger that affects our setup severely. It doesn’t remember the project status after the ccnet server has restarted. This causes the nightly projects to be rebuilt after a server restart. Since we have lots of projects on the server, we need to restart it atleast once a week and this causes the nightly builds to fail.

New trigger?

To solve this we need another way to trigger the build. The first solution that comes to mind is if there was a trigger that could check if a specific folder (the drop zone folder in this case) was missing, we could replace the projectTrigger with a ”Missing folder trigger”.

Perhaps could look like this.

<missingFolderTrigger path="Z:\PublishedBuilds\MyProject-Nightly\1.0.0.234"/>

Problem here is that we don’t know the last folder name. The ”1.0.0.234”comes from the file version for our compiled assemblies.
The first part of the version number can be any numbers and the 234 refers to the build number of the project. This changes for each build so we need a way to look this up.

Final design

I speak highly of the KISS principle, but I’m also great at creating generic things and sometimes this ”generic gene” gets some overhand (and sometimes also get way out of hand, but I think I found a good level this time :)
So the final design was a trigger syntax like below:

<fileExistsTrigger
 triggerOnMissing="true"
 seconds="30"
 path="Z:\PublishedBuilds\MyProject-Nightly\"
 match="\d+\.\d+\.\d+\.[Regex.Match([Projects(MyProject).LastSuccessfulBuildLabel],\d+$)]"/>

This trigger is now a more ”generic” one allowing us to trigger on both files and directories.
The ”triggerOnMissing” allows us to trigger on both exists and not exists.
It’s based on an interval trigger and the ”seconds” parameter allows us to set on how often a file/directory should be checked.
The ”path” allows us to set the path that should be checked. If we only need to check a file/directory that we know the name of, this is enough. End with a \ to check a directory.

The match attribute

The ”match” allows us to perform a regular expression search that searches for a match for a directory/file in the supplied path.

The \d+ will match one or more digits
The \. will match a dot.
Repeating this match three times \d+\.\d+\.\d+\. will match the ”1.0.0.” part of the file (or any other valid version major.minor.build. combo)

Now the fun part begins :). I added some syntax to perform string operations and replacements. Any valid command is surrounded by [] and are replaced before the file/directory regex matching begins.
In this example we have two commands, one property and one method call. Properties are evaluated first so [Projects(MyProject).LastSuccessfulBuildLabel] allows us to instruct the trigger to lookup the project named ”MyProject” and return the LastSuccessfulBuildLabel. In this case this would be ”MyProject – 234”.
The method call would look like this after the property replacement. [Regex.Match(MyProject - 234,\d+$)]. This will call the Regex.Match method and return the matched pattern. In this case \d+$ will match the last digits in the ”MyProject – 234” and would return ”234”.
So the final match attribute will be \d+\.\d+\.\d+\.234 and would in this case find a folder named 1.0.0.234. If the folder is missing, the build will be triggered, but if it is there, no trigger is fired. If the interval build fires and is successful, the LastSuccessfulBuildLabel increases and is 235. When the nightly build is triggered again, the folder is missing and the trigger will fire.

Writing the trigger

The first part to think about when writing extensions/plugins to ccnet is that the assembly must be named ccnet.*.plugins.dll otherwise ccnet wont find it. Secondly, the trigger class needs to be decorated with the ReflectionTypeAttribute to tell the class what the xml element name for the class looks like (like [ReflectorType("fileExistsTrigger")]). Every field/property that should be read into the trigger should also be decorated with the ReflectorPropertyAttribute (like [ReflectorProperty("path", Required = true)]). I mainly looked at the ProjectTrigger that comes with ccnet and added stuff along the way.
Beware that the code don't fix all special cases, like if your project name contains , ) or other characters that messes up the expressions, but this is what I needed (remember TDD).
You can use the code below as it is or modify it to your needs. If you want the whole solution (including unit tests), just drop me a mail.
Good luck :)

using System;
using System.Collections.Generic;
using System.Linq;
using ThoughtWorks.CruiseControl.Remote;
using ThoughtWorks.CruiseControl.Core.Triggers;
using ThoughtWorks.CruiseControl.Core.Util;
using Exortech.NetReflector;
using System.Text.RegularExpressions;
using System.IO;

namespace Meridium.CruiseControl.Net.Triggers {
    [ReflectorType("fileExistsTrigger")]
    public class FileExistsTrigger : IntervalTrigger {
        /// <summary>
        /// If the trigger should be active if the file is missing, default is false
        /// </summary>
        [ReflectorProperty("triggerOnMissing", Required = false)]
        public bool TriggerOnMissing;
        /// <summary>
        /// The url to the ccnet server, defaults to a local ccnet installation tcp://localhost:21234/CruiseManager.rem
        /// </summary>
        [ReflectorProperty("serverUri", Required = false)]
        public string ServerUri;
        /// <summary>
        /// The file/directory path to see if it exists or not
        /// </summary>
        [ReflectorProperty("path", Required = true)]
        public string Path;
        /// <summary>
        /// Optional parameter to use if a regular expression should be used to match a file or directory in the path. Default is an empty string.
        /// </summary>
        [ReflectorProperty("match", Required = false)]
        public string Match;

        private readonly ICruiseManagerFactory _managerFactory;

        public IDictionary<string, ProjectStatus> ProjectStatus {
            get {
                lock (ProjectStatusLock) {
                    //if cache has timed out, clear cache.
                    if (_projectStatus != null && DateTime.Now > _cacheValidUntil) {
                        _projectStatus = null;
                        Log.Debug("Cache was deleted, was valid until " + _cacheValidUntil.ToString("yyyy-MM-dd HH:mm:ss,fff"));
                    }
                    if (_projectStatus == null) {
                        Log.Debug("Updating ProjectStatus cache from server: " + ServerUri);
                        _projectStatus = new Dictionary<string, ProjectStatus>();
                        foreach (ProjectStatus status in _managerFactory.GetCruiseManager(ServerUri).GetProjectStatus()) {
                            _projectStatus.Add(status.Name, status);
                        }
                        _cacheValidUntil = DateTime.Now + CacheTime;
                        Log.Debug("Cache valid until " + _cacheValidUntil.ToString("yyyy-MM-dd HH:mm:ss,fff"));
                    }
                    return _projectStatus;
                }
            }
        }
        private static DateTime _cacheValidUntil = DateTime.MinValue;
        private static readonly TimeSpan CacheTime = new TimeSpan(0, 10, 0);
        private static Dictionary<string, ProjectStatus> _projectStatus;
        private static readonly object ProjectStatusLock = new object();

        public FileExistsTrigger()
            : this(new DateTimeProvider(), new RemoteCruiseManagerFactory()) {
        }

        public FileExistsTrigger(DateTimeProvider dtp, ICruiseManagerFactory managerFactory)
            : base(dtp) {
            ServerUri = "tcp://localhost:21234/CruiseManager.rem";
            _managerFactory = managerFactory;
        }
        public override IntegrationRequest Fire() {
            //only check on intervals
            if (base.Fire() != null) {
                try {
                    Log.Debug(string.Format("More than {0} seconds since last integration, checking url.", IntervalSeconds));
                    if (FileExists() != TriggerOnMissing) {
                        Log.Debug("Trigger matched, fire IntegrationRequest");
                        return new IntegrationRequest(BuildCondition, Name);
                    }
                } catch (Exception ex) {
                    Log.Error(ex);
                } finally {
                    IncrementNextBuildTime();
                }
            }
            return null;
        }
        private string HandleProjectPropertyMatches(Match m) {
            string projectName = m.Groups["projectName"].Value;
            string property = m.Groups["property"].Value;
            var ps = GetCurrentProjectStatus(projectName);
            switch (property.ToLower()) {
                case "lastsuccessfulbuildlabel":
                    return ps.LastSuccessfulBuildLabel;
                case "name":
                    return ps.Name;
                case "buildstatus":
                    return ps.BuildStatus.ToString();
                default:
                    throw new NotImplementedException(string.Format("Support for property {0} is not implemented yet!", property));
            }
        }
        private static string HandleRegexMatchMatches(Match m) {
            string input = m.Groups["input"].Value;
            string pattern = m.Groups["pattern"].Value;
            Match match = Regex.Match(input, pattern);
            return match.Success ? match.Value : string.Empty;
        }
        private bool FileExists() {
            string fp = TranslateValue(Path);
            string match = TranslateValue(Match);
            if (!string.IsNullOrEmpty(match)) {
                if (!fp.EndsWith(@"\"))//"
                    fp += @"\";//"
                var dir = new DirectoryInfo(fp);
                if (!dir.Exists) {
                    Log.Debug(string.Format("Matching path {0} failed. Directory does not exist.", fp));
                    return false;
                }
                foreach (var fs in dir.GetFileSystemInfos().Where(fs => Regex.IsMatch(fs.Name, match))) {
                    Log.Debug(string.Format("Match successful with fileSystemInfo {0}", fs.FullName));
                    return true;
                }
                Log.Debug(string.Format("No match for {0}", match));
                return false;

            }
            bool isDirectory = fp.EndsWith(@"\");//"
            bool exists = isDirectory ? Directory.Exists(fp) : File.Exists(fp);
            Log.Debug(string.Format("Checking if {0} {1} exists: {2}", (isDirectory ? "directory" : "file"), fp, exists));
            return exists;
        }
        /// <summary>
        /// Translates the supplied value and expands all methods and variables
        /// </summary>
        /// <param name="val">The value to translate</param>
        /// <returns>The translated value</returns>
        private string TranslateValue(string val) {
            //handle replacements...
            //like [Projects(MyProject).LastSuccessfulBuildLabel]
            val = Regex.Replace(val, @"\[Projects\((?<projectName>[^\)]+)\)\.(?<property>[^\]]+)\]", HandleProjectPropertyMatches, RegexOptions.IgnoreCase);
            //handle Regexp
            //like [Regex.Match(string,pattern)]
            val = Regex.Replace(val, @"\[Regex\.Match\((?<input>[^,]+),(?<pattern>[^\)]+)\)\]", HandleRegexMatchMatches, RegexOptions.IgnoreCase);

            return val;
        }
        private ProjectStatus GetCurrentProjectStatus(string project) {
            if (!ProjectStatus.ContainsKey(project)) {
                throw new NoSuchProjectException(project);
            }
            return ProjectStatus[project];
        }
    }
}

Adding buttons to the TinyMce editor in EPiServer 6 programmatically

2010-04-13T10:49:00.007+02:00

While developing ImageVault we needed to add buttons to insert images in the TinyMce editor that ships with EPiServer CMS 6. The buttons are decorated with a TinyMCEPluginButtonAttribute and they can be added manually by entering admin mode and modifying the settings for the XHTML property (see Oskars post "Add functionality to the rich text editor in EPiServer cms 6").
To do this by code this was rather simple since EPiServer has a great Api (even that it could contain more examples)...

The settings are stored in the EPiServer database and is accessed using the PropertySettingsRepository class.
To get the current settings for the TinyMce editor, just create a repository and use the GetDefault method


PropertySettingsRepository p = new PropertySettingsRepository();
PropertySettingsWrapper defaultSettings = p.GetDefault(typeof(TinyMCESettings));

The PropertySettingsWrapper contains metadata for the settings, like DisplayName, Id etc.
It also contains the specific setting for the TinyMce editor in the property PropertySettings.

To create a new settings for the TinyMce editor with some buttons added we can use the code below.


PropertySettingsRepository p = new PropertySettingsRepository();
PropertySettingsWrapper defaultSettings = p.GetDefault(typeof(TinyMCESettings));

//create a copy of the default settings
PropertySettingsWrapper copy = defaultSettings.Copy();
copy.DisplayName+="(My copy)";
TinyMCESettings settings = copy.PropertySettings as TinyMCESettings;

//create a new toolbar row for my buttons
ToolbarRow row = new ToolbarRow();
settings.Toolbars.Add(row);

//the buttons are added using the name defined in the
//ButtonName property of the TinyMCEPluginButtonAttribute.
row.Buttons.Add("mybutton1");
row.Buttons.Add("separator");
row.Buttons.Add("mybutton2");

//Save the copy as a global setting
p.SaveGlobal(copy);

//Set it as default
p.SetDefault(copy.Id);

Quite easy. The separator button is included in EPiServer 6 the others need to be added using classes decorated with the TinyMCEPluginButtonAttribute.

Note!
To actually use this code in EPiServer you need to insert it somewhere :) The easiest way is to create a InitializationModule class (implement IInitializaionModule and mark it with the InitializationModuleAttribute). Then in the Initialize method, add your code to the InitializationEngine.InitComplete event.


public void Initialize(InitializationEngine context) {
    context.InitComplete+=(sender,args)=> MyInstallButtonsMethod();
}

More about EPiServer Initialization on episerver world.

Converting word doc to pdf in CruiseControl.Net

2009-10-16T14:46:00.009+02:00

Today I needed to automate the process where we create PDF files out of our client documentation in Microsoft Word format. Since up to now we have done it manually by opening the document and printing to a installed PDF printer. Quite tedious work.
After some searching I start to realize that there are many PDF creators around; and most of them uses Ms word and prints using a pdf printer (just as we use to do, but by automation).
The problem is that I don't want to install printers or the Ms Office package on our build server (if I can avoid it). Another wish is that the solution should be free and open source.
So finally I stumbled upon this article by Graham J. Williams that uses OpenOffice.org to do the conversion and a custom macro to allow the conversion to be called from the commandline.

REM  *****  BASIC  *****

Sub ConvertWordToPDF(cFile)
  cURL = ConvertToURL(cFile)

  ' Open the document.
  ' Just blindly assume that the document is of a type that OOo will
  '  correctly recognize and open -- without specifying an import filter.
  oDoc = StarDesktop.loadComponentFromURL(cURL, "_blank", 0, Array(MakePropertyValue("Hidden", True), ))

  cFile = Left(cFile, LastIndexOf(cFile,".")) + "pdf"
  cURL = ConvertToURL(cFile)

  ' Save the document using a filter.
  oDoc.storeToURL(cURL, Array(MakePropertyValue("FilterName", "writer_pdf_Export"), ))

  oDoc.close(True)

End Sub

Function LastIndexOf ( cText as String, cMatch as String) As Integer
  lastIndex = 0
  pos=0
  Do
    pos = InStr(pos+1,cText,cMatch)'
    If pos >0 Then
      lastIndex = pos
    End If
  Loop While pos >0
  LastIndexOf()=lastIndex
End Function

Function MakePropertyValue( Optional cName As String, Optional uValue ) As com.sun.star.beans.PropertyValue
  Dim oPropertyValue As New com.sun.star.beans.PropertyValue
  If Not IsMissing( cName ) Then
    oPropertyValue.Name = cName
  EndIf
  If Not IsMissing( uValue ) Then
    oPropertyValue.Value = uValue
  EndIf
  MakePropertyValue() = oPropertyValue
End Function

I modified it a bit to allow correct handing of extensions.
To call it from a windows command prompt just enter

c:\program files\OpenOffice.Org 3\Program\swriter.exe -invisible "macro:///Standard.Module1.ConvertWordToPDF(c:\temp\My word document.doc)"

I incorporated it in our cruisecontrol.net nant scripts so all solutions that needs pdf conversions in the build chain can have it.
Great!

2010-05-11 Update: Fixed a bug with filenames that contained more than one period (.), added the LastIndexOf function

Bugfix for Documentator Macros (VB)

2009-08-06T00:10:00.006+02:00

A small bug fix for the auto documentation feature for VB.Net.

Thanks for the report Sam; what has it been, nearly 2 years since you reported the bug finally I've come about... ( You said it wasn't urgent... you'll probably reconsider next time ;)

When autodocumenting a Sub or function that is connected to an event, an error occurs.

The fix is included in version 2.5.3.0 that can be downloaded from http://dan.meridium.se/DocumentatorMacros/v2.5.3.0/Meridium.rar.

(For more information about the Documentator Macros, see http://www.codeproject.com/KB/cs/documentatormacros.aspx )

Mvc for Winforms - Mapping the View event to the Controller action Part III

2009-07-27T21:47:00.011+02:00

Long time since part I and II were posted, but I've been quite busy lately so I haven't found time (or prioritized) to write the last part, but here we are :)

To recap, in part I I explained about the background of the issue, that I was writing a small winforms MVC framework. The goal of the framework was to be able to instruct the controller to listen to a component in the view and when the component called an event, a specific method would be called.
For example, the call below would register the click event from the saveButton

Controller.RegisterAction(saveButton,"Save");

(in later editions I have also added support for lamda expressions instead of method names, and thus almost abandoned the previous)

Controller.RegisterAction(rotateRightButton,() => Controller.Rotate(90));
Controller.RegisterAction(rotateLeftButton,() => Controller.Rotate(-90));

In part II I wrote about how find and listen to the event of the component.
In this section I will explain how I call the method.

What we ended with in the last post was that we had registered the controllers event to call the ExecuteAction method of the Controller class.

public void ExecuteAction(object source, object eventArgs, ActionData actionData)

or in the latter case using lambda expressions (or action)

public void ExecuteAction(object source, object eventArgs, Action action)

In this case the Action is the easiest to implement. Just call the Invoke method of the Action instance and you are done.

public void ExecuteAction(object source, object eventArgs, Action action) {
   action.Invoke();
}

The no Action ExecuteAction method (almost abandoned way )
The ActionData variant is somewhat more tedious but this is how ASP.NET MVC does it.
First we need to find the method to call. The ActionData contains the name of the method. We now needs to find the method of the controller that matches that name. MVC for ASP.NET uses the ActionSelectorClass. The ActionSelectorClass is responsible for retrieving the MethodInfo for an action by passing in the name of the action. It support action aliases and other things so look it up for a great example.
In short it uses reflection to get all methods, filters out irrelevant methods and returns the one that matches the name.
Example (really shortened example, lookup ActionSelectorClass in the ASP.NET MVC framework for a complete example.)

//get all methods
MethodInfo[] array = ControllerType.GetMethods(BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance);
//convert to a dictionary
ILookup<string,MethodInfo> methodLookup = array.ToLookup(method => method.Name, StringComparer.OrdinalIgnoreCase);
//return the matching MethodInfo
MethodInfo action = methodLookup[actionName];

Now we have the MethodInfo to invoke, only to calculate the parameters to pass to the method is left.

The action is invoked using the Invoke method of the MethodInfo class and we need to pass the instance to invoke it on (the controller instance) and the object array containing the parameters to pass to the method/action.
Example

action.Invoke(controller,parameterValues);

If the action don't have any parameters we just pass null, but if we do have parameters we need to assign values for them.
Remember: we wanted to be able to register the call

Controller.RegisterAction(createBoldTextButton, "CreateText", new {name="Bold", type=4});

To call the action method

public void CreateText(string name, int type) {...}

using the "Bold" as value for the name parameter and 4 as value for the type parameter.

To succeed with this we need to do some parsing.

Iterate all parameters of the method info.
Handle special cases (like if the parameter is named source and is of type object, then the source value from the event handler method should be passed).
Find a property with a matching name from the value object passed in the RegisterAction.

Iterate all parameters of the method info
Using reflection it's easy to find the parameters.

List<object> objects = new List<object>();
foreach (ParameterInfo info in method.GetParameters()) {              
  objects.Add(GetParameterValue(info));
}
return objects.ToArray();

Handle special cases
The GetParameterValue method will return the value to pass to the supplied ParameterInfo. In some cases the value to be passed as parameter is not any of the values passed to the values parameter (in the RegisterAction method), like for example, if one would need to get the EventArgs or source parameter passed from the event component, then we would need to handle them. (other customizations can be done here, this is an example)

Type parameterType = parameterInfo.ParameterType;
string parameterName = parameterInfo.Name;

//handle eventArgs and source parameters
if (string.Equals(parameterName, "e", StringComparison.OrdinalIgnoreCase) && _eventArgs != null && parameterType.IsAssignableFrom(_eventArgs.GetType()))
  return _eventArgs;
if (string.Equals(parameterName, "source", StringComparison.OrdinalIgnoreCase)&& parameterType.Equals(typeof(object)))
  return _source;

//parse the values object
return GetValuesValue(parameterType, parameterName);

Find a matching property of the value object
At last we would try to find a matching property of the value object that matches the parameter type and name. (First we check that the parameter don't matches the whole value object)

//if we don't have a value, return null
if (ValueType == null)
  return null;
//if the value is matching, use it as value
if (type.Equals(ValueType))
  return _actionData.Values;
PropertyInfo[] valueProperties= ValueType.GetProperties();
//if the value don't have any properties, return null
if (valueProperties.Length == 0)
  return null;
//find matching property
PropertyInfo[] possibleMatches = valueProperties
     .Where(p => string.Equals(name, p.Name, StringComparison.OrdinalIgnoreCase)
            && type.IsAssignableFrom(p.PropertyType))
     .ToArray();
if (possibleMatches == null || possibleMatches.Length == 0)
  return null;
if (possibleMatches.Length > 1)
  throw new AmbiguousMatchException(string.Format("The value collection contains ambigous match values for the parameter {0} {1}", type, name));
return possibleMatches[0].GetValue(_actionData.Values, null);

Ok, so now we can invoke the method with our array of parameters. (as I said, a bit tedious).
If we compare the two variants,

Controller.RegisterAction(createBoldTextButton, "CreateText", new {name="Bold", type=4});
Controller.RegisterAction(createBoldTextButton, ()=> Controller.CreateText("Bold", 4);

you understand why I have abandoned this last variant and only uses Actions/lambda functions.
The tedious method can still be used if you want to lift the connection between view and controller to a configuration layer. Then the Action method will be hard to implement.

That sums up this last part of my WinForms MVC framework lessons and experiences. Hope that you learned something.

The start address cannot be crawled

2009-06-24T11:40:00.009+02:00

Have a SharePoint site on one of our servers and have lately added a new hostname to that server to access a new site collection. I started getting a lot of entries in the eventlog using event id 2436 stating:

The start address <https://newhostname.domain.com> cannot be crawled.

Context: Application 'Search index file on the search server', Catalog 'Search'

Details:
Access is denied. Check that the Default Content Access Account has access to this content, or add a crawl rule to crawl this content. (0x80041205)

For more information, see Help and Support Center at http://go.microsoft.com/fwlink/events.asp.

Another symptom on this error is that if you open a web browser on the server itself and try to navigate to the url, you'll only get an authentication dialog (symptom on a 401 error).

After a bit of searching I found a solution that I recognized. The following kb article http://support.microsoft.com/kb/971382 provided the solution to add the new hostname to the registry key HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Lsa\MSV1_0\BackConnectionHostNames .

When I started regedit I found that the key already existed and a couple of hostnames already was present. It seems that I had implemented this fix before.
Better to write a post about it so I don't forget it in the future :)

Ps. Don't forget to restart the server after applying the registry change. Ds.

Export and Import Work item queries in TFS projects

2009-06-24T07:26:00.005+02:00

I have lately been introducing new WorkItemTypes in our TFS project to handle tests and support cases. With those new types the need for modifying the queries in the current projects was necessary. To modify a query I could have opened them in visual studio and saved them to disk and then saved them individually to each project. Since we are getting a lot of projects (60+) this would be a quite tedious task to update 10+ queries in each project individually.
To solve this administrative plague I wrote a small commandline program that allows you to export and import queries from a project.

Example
To list all queries in a project
TFSQueryUtil.exe /t https://tfsserver.domain.com:8143 /p "My Tfs Project"

This will list every Work Item Query by Scope, Name and description

To export all queries to the current folder
TFSQueryUtil.exe /t https://tfsserver.domain.com:8143 /p "My Tfs Project" /o Export /q *

This will export each query using the name of the query (plus the .wiq extension) as name of the exported file. If you want to only export one query, use the example below.
TFSQueryUtil.exe /t https://tfsserver.domain.com:8143 /p "My Tfs Project" /o Export /q "My query"

To import all *.wiq files to a project as Team queries
TFSQueryUtil.exe /t https://tfsserver.domain.com:8143 /p "My Tfs Project" /o Import /f *.wiq /qs Public

This command will use the filename (without the .wiq extension) as name for the imported query.
You can also specify a Description of the query by using the /qd switch (best for use with one query imports)

The format of the wiq files follows the WorkItemQuery schema but since the schema only includes the query and no meta data (like name, scope or description) this has to be provided as parameter switches... (Perhaps something to fix in TFS 2010)

If you need more help add the /? parameter.

I haven't released the program as open source but feel free to use it if you have need for it.
Can be downloaded from http://dan.meridium.se/TfsQueryUtil.rar
To use it you need to have Team Foundation Explorer 2008 installed. (needs the tfs dlls in the GAC).

2009-09-28 Update; small bugfix
* Now writes xml files as utf-8 (was an in consequence between xml notation and file encoding)

New version of DocumentatorMacros

2009-05-05T14:27:00.005+02:00

Long time since last version was released officially... (almost two years), time to make a change.
New version can be downloaded from http://dan.meridium.se/DocumentatorMacros/v2.5.2.0/Meridium.rar
(For more information about the Documentator Macros, see http://www.codeproject.com/KB/cs/documentatormacros.aspx )

New version contains some news:

Contains support for Resharper 4.5, Visual studio 2008 and some minor changes.

Enhancements /Bugfixes

No longer enters wrong type of linefeeds when applying some functions
PasteTemplate
- now indents correctly
- Handles static events
- Handles new, virtual, override keywords when converting fields->property
DocumentThis - Now autodocuments thrown exceptions

AssemblyName.GetPublicKeyToken() ToString using lambda

2009-05-04T13:31:00.008+02:00

I was searching for a convenient way to get the public key token from a signed assembly and present it in an ordinary string style that is found in all FQ assembly names. The problem is that the GetPublicKeyToken() method from the Assembly type returns a byte array and using ToString() isn’t that great.

I searched the net a bit and all I found was examples on how to do it with a loop and using ToString(”x2”) on every byte, or even more horrible, indexing the 8 bytes by hand...
But if I use a linq/lambda expression, this could be a nice one-liner? ’aye?!

Ok, first convert the byte array to a string array

GetPublicKeyToken().Select(x=>x.ToString(”x2”))

Then aggregate (i was trying the concat first, but that didn’t make any sense) to a single string.

.Aggregate((x, y) => x + y)

With some error handling this boils down to the following method.

#region public static string GetAssemblyPublickKeyToken(Assembly assembly)
/// <summary>
/// Gets the public key token of the supplied argument
/// </summary>
/// <param name="assembly">The <see cref="Assembly">to get the public key token for</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">If <paramref name="assembly">is null.</exception>
public static string GetAssemblyPublickKeyToken(Assembly assembly) {
    if (assembly == null) {
        throw new ArgumentNullException("assembly");
    }
    byte[] token = assembly.GetName().GetPublicKeyToken();
    if(token == null token.Length==0)
        return null;
    return token.Select(x => x.ToString("x2")).Aggregate((x, y) => x + y);
}
#endregion

RadioButton helper and label

2009-01-21T15:17:00.008+01:00

When using Mvc (beta) and rendering RadioButtons using the HtmlHelper they are rendered without any text or description. The label tag is used for this but is not rendered by the RadionButtons method.
Example;

<%=Html.RadioButton("MyRadioButton","MyValue")%>

renders

<input id="MyRadioButton" value="MyValue" name="MyRadioButton" type="radio">

To get the label we just add the label tag and uses the input tags id as reference for the label.

<label for="MyRadioButton">My description</label>

This will allow us to check the radio button by clicking on the label as well.

Then the problem occurs if we should use multiple radio buttons with the same name.
Example;

<%=Html.RadioButton("IsItRaining","Yes")%>
<%=Html.RadioButton("IsItRaining","No")%>

This will render
renders

<input id="IsItRaining" value="Yes" name="IsItRaining" type="radio">
<input id="IsItRaining" value="No" name="IsItRaining" type="radio">

This it not so well since we need different id attributes to be able to bind the label tags.
To fix this we need to add different ids to the input tags.
Example:

<%=Html.RadioButton("IsItRaining", "Yes", new {id="IsItRaining_Yes"})%><label for="IsItRaining_Yes">Yes</label>
<%=Html.RadioButton("IsItRaining", "No", new {id="IsItRaining_No"})%><label for="IsItRaining_No">No</label>

That will produce the intended output;

<input id="IsItRaining_Yes" type="radio" value="Yes" name="IsItRaining"/>
<label for="IsItRaining_Yes">Yes</label>
<input id="IsItRaining_No" type="radio" value="No" name="IsItRaining"/>
<label for="IsItRaining_No">No</label>

And will work as below

YesNo

The GetField method

2008-11-27T12:22:00.004+01:00

Last month I wrote an article about clicking a button in a winforms application and in my code example I referred to the ReflectionUtil.GetField method.
The ReflectionUtil class is an utility class that I have used for several years and they provide a better/easier way to use reflection. They are in line to be converted as Extension methods for the Type type, but for now they are ordinary static methods.
I'll post the GetField method to allow the example to be complete.

#region public static object GetField(Type type, string name, object instance)
/// <summary>
/// Gets the field from the instance
/// </summary>
/// <param name="type">The <see cref="Type"/> that contains the field</param>
/// <param name="name">The name of the field</param>
/// <param name="instance">The instance to get the value from</param>
/// <returns>The value of the field</returns>
public static object GetField(Type type, string name, object instance) {
    return InvokeMember(type, name, instance, BindingFlags.GetField | BindingFlags.Instance);
}
#endregion

The GetField only wraps the InvokeMember method. (I have more wrappers named GetProperty, SetField, SetProperty, InvokeMethod, InvokeStaticMethod etc. that calls the InvokeMember method)

#region public static object InvokeMember(Type type, string name, object instance, BindingFlags flags, params object[] parameters)
/// <summary>
/// Invokes the member
/// </summary>
/// <param name="type">The <see cref="Type"/> that contains the member</param>
/// <param name="name">The name of the member</param>
/// <param name="instance">The instance to invoke on</param>
/// <param name="flags">The <see cref="BindingFlags"/> to use</param>
/// <param name="parameters">The <see cref="object"/> array to pass as parameters</param>
/// <returns>The returnvalue</returns>
public static object InvokeMember(Type type, string name, object instance, BindingFlags flags, params object[] parameters) {
    if (instance == null) {
        flags |= BindingFlags.Static;
        flags &= ~BindingFlags.Instance;
    }

    try {
        return type.InvokeMember(name,BindingFlags.Public | BindingFlags.NonPublic | flags,null,instance,parameters);

        //if the target threw an exception, throw this instead.
    } catch (TargetInvocationException e) {

        // if no exception is found, throw the TIException instead.
        if (e.InnerException == null)
            throw;
        throw e.InnerException;
    }
}
#endregion

Hope the click button example can make more sense now :)

Mvc for Winforms - Mapping the View event to the Controller action Part II

2008-11-02T21:11:00.009+01:00

This time I will try to deliver part of the answer to the requirements from my previous post. To recap I would like to be able to connect a component to a controller action by calling the RegisterAction method like below.

Controller.RegisterAction(saveButton, "Save");
Controller.RegisterAction(createBoldTextButton, "CreateText", new {name="Bold", type=4});
Controller.RegisterAction(myTextBox, "ValidateText","Validating", null);

And letting those events call the actions defined below

public void Save() {...}
public void CreateText(string name, int type) {...}
public void ValidateText(CancelEventArgs e, object source) {...}

I will divide the solution in two steps and in this post I will cover the first, that is capturing the event of the object.

We start by creating the RegisterAction method. We get the object which event should be listened to and sometimes also the name of the event that we should listen to. If this argument isn't supplied we need to find the DefaultEvent of the object.

By using reflection we can retrieve the DefaultEventAttribute of the object. The following unit test shows how to get the attribute for a Button object. Notice the true flag on the GetCustomAttributes call. Since the DefaultEventAttribute is not present on the Button class itself, we need to go down in the inheritance chain to look for the attribute. Not until we reach the Control class we find the DefaultEventAttribute.

[Test]
public void GetDefaultEventAttribute() {
 object obj = new Button();
 DefaultEventAttribute attribute = null;
 Attribute[] attributes = obj.GetType().GetCustomAttributes(typeof(DefaultEventAttribute), true) as Attribute[];
 if (attributes != null && attributes.Length > 0) {
     attribute = attributes[0] as DefaultEventAttribute;
 }
 Assert.IsNotNull(attribute);
}

When we have the attribute, we just look at the Name property to get the name of the default event.

Now when we have the name of the event (either by parameter or using the DefaultEventAttribute) we should add listener to the event. The listener method is a method in the Controller class, not the controller Action (we will get to that in the next part), but a event hub where all the Views events will pass before they are dispatched to the correct Action. The event hub method is declared as below

public void ExecuteAction(object source, object eventArgs, ActionData actionData)

The ExecuteAction method takes three parameters. The source and arguments of the event that was fired (this is the same values that the original event passes along). The third parameter contains the data for the action that is to take place, like the name of the action and any value parameters (The values that are stated when registering the action).

So we got the object and the name of the event and the target method of the event, but how can we connect them?

My first thought was to generate a delegate to the ExecuteAction and use reflection to get the EventInfo for the event and use the AddEventHandler of the EventInfo class to bind to the ExecuteAction method.

[Test]
public void BindToButtonClickEvent() {
 object obj = new Button();
 EventInfo info = obj.GetType().GetEvent("Click");
 MethodInfo method = GetType().GetMethod("ExecuteAction");
 Delegate d = Delegate.CreateDelegate(typeof(MyExecuteAction),method);
 info.AddEventHandler(obj,d);
}
private delegate void MyExecuteAction(object source, object eventArgs, ActionData actionData);
public void ExecuteAction(object source, object eventArgs, ActionData actionData) {}

But when I ran this code I got an Exception

System.ArgumentException: Error binding to target method.

Of course this won't work since the Click event cannot directly connect to the ExecuteAction method because the Click event can only add handlers that matches the EventHandler delegate, a method with a void return value and two arguments, object and EventArgs.

The conclusion of this is that if I would like to have a single method that acts as an event hub and it must be able to handle any type of delegate that the event declares (note that events as practice should always return void and take two arguments, object and a instance of an EventArgs derived class), I need to generate this method in runtime.

The first option that comes to mind is using Emit. I have tested this in the past, it has worked but comes not so natural to me. Oren Eini used this technique but since I would like to pass a local variable (the ActionData instance) in the call, I needed to modify this piece of code, and possibly use an external list of ActionData instances if I couldn't pass them along using the dynamic method, I searched a bit more for an alternative (second opinion)...

Finally I came across an answer from Mark Cidade that compiled a method in runtime using lambda expressions and that was fairly easy to modify.
First we need to setup the call to the ExecuteAction method. This is done using a lambda expression and storing it in the Action delegate.

ActionData actionData = new ActionData("Save", null);
//Create the delegate using an lambda expression
Action<object,object> eventHubCall = (source, e) => ExecuteAction(source, e, actionData);

This action will take two parameters and call the ExecuteAction just the way as we would like it to. The problem is that this expression is not typed the correct way as the event is so we need to create a new method using lambda expressions again but with the correct declaration. So we start by getting the information about the event.

Type type = obj.GetType();
EventInfo evt = type.GetEvent("Click");
ParameterInfo[] eventParams = evt.EventHandlerType.GetMethod("Invoke").GetParameters();

Then we create the lambda

ParameterExpression[] parameters = eventParams.
  Select(p => Expression.Parameter(p.ParameterType, "x")).ToArray();
MethodCallExpression body = Expression.Call(Expression.Constant(eventHubCall),
  eventHubCall.GetType().GetMethod("Invoke"), parameters);
LambdaExpression lambda = Expression.Lambda(body, parameters);

Now we have a method with two parameters of the correct type, the only thing left is to create a delegate that we can use for adding to the event.

Delegate proxy = Delegate.CreateDelegate(evt.EventHandlerType, lambda.Compile(), "Invoke", false);
evt.AddEventHandler(obj, proxy);

Tada!! No more Error binding to target method errors.
The complete test follows.

[Test]
public void BindToButtonClickEvent2() {
 ActionData actionData = new ActionData("Save", null);
 //Create the delegate using an lambda expression
 Action<object,object> eventHubCall = (source, e) => ExecuteAction(source, e, actionData);

 object obj = new Button();
 //find the exact definition of the event
 Type type = obj.GetType();
 EventInfo evt = type.GetEvent("Click");
 ParameterInfo[] eventParams = evt.EventHandlerType.GetMethod("Invoke").GetParameters();

 //create a new lambda expression using the correct parameters
 ParameterExpression[] parameters = eventParams.
      Select(p => Expression.Parameter(p.ParameterType, "x")).ToArray();
 //call the event hub
 MethodCallExpression body = Expression.Call(Expression.Constant(eventHubCall),
      eventHubCall.GetType().GetMethod("Invoke"), parameters);
 //create the expression with the correct parameters to match the event
 LambdaExpression lambda = Expression.Lambda(body, parameters);
 //and then create the delegate that wraps the lambda expression.
 Delegate proxy= Delegate.CreateDelegate(evt.EventHandlerType, lambda.Compile(), "Invoke", false);

 evt.AddEventHandler(obj, proxy);      
}

Not so dumb ey! All credits goes to Mark Cidade for providing the elegant solution. (So I perhaps my greatest talent is to find solutions that others have done before me, and use them ;)
Anyway, that concludes part II and next we will look how to call the action method of the controller from the ExecuteAction method.

Mvc for Winforms - Mapping the View event to the Controller action

2008-11-01T23:41:00.008+01:00

In my current (or rather one of my current projects) I'm writing a small MVC framework for a WinForms application (I mentioned this in my last post). The latest issue that I stumbled upon and found worth mentioning is about connecting the Views events to the Controllers actions.

If we look at the MVC for ASP.NET the events is the requests by the web client and the URL contains the information that the Routing module uses to find an appropriate action to call. It should be nice to have such a feature in the WinForms solution as well so after some thought I summarized a small example.

In my view I can have several objects (not necessary controls) that can/will fire some events (like a button firering the click event when the user clicks it).
In my controller I have several action methods that should be called by the view when the appropriate event occurs. (Like a Save action that should be called when the user clicks the save button, thus triggering the save button click event) (nothing out of the ordinary here;)

Whats the fuzz about this then, you may think? This is normal stuff, no strange things!? (who is this dumb guy anyway...)

Yes I see your point. I could easily use the Forms designer in Visual studio, double click the Save button and enter the code below to call the Save button.

private void saveButton_Click(object sender, System.EventArgs e) {
  Controller.Save();
}

But thats not what I want. I don't want to litter the View with a lot of event methods just calling one line of code. The purpose of the MVC pattern is to separate the View from the logic and if we start putting those event handler methods in the view, soon some line of controller logic will be entered in there (just to test) and we'll never find the way to clean them up again.

My vision is to register these events one by one in the Views constructor, on one line that enables me to

Listen to an event from an object in the view
Capture the event and pass it to an action in the controller
Allow the mapping to pass additional parameters to the action (compare the routing in MVC for ASP.NET)

If I would make the same example like the one above but using the one liner instead, it would look like below.

Controller.RegisterAction(saveButton,"Save");

If I would pass some parameters to the action I could use the same syntax as when defining default routes in MVC for ASP.NET.

Controller.RegisterAction(createBoldTextButton,"CreateText", new {name="Bold",type=4});

This would then be mapped to the action CreateText which declaration looks like below.

public void CreateText(string name, int type) {...}

If I want to listen to an event that isn't the DefaultEvent (see the DefaultEventAttribute) I could state this as well in the call

Controller.RegisterAction(myTextBox,"ValidateText","Validating", null);

And if I declare the action to include the event argument and/or source they should be passed along as well

public void ValidateText(CancelEventArgs e, object source) {...}

How do I code this to be like I want it to then???

In my next post I will try to give you a solution to the requirements above and hopefully prove that I'm not a dumb guy after all ;)
See ya!

Clicking a winforms button from code

2008-10-27T11:11:00.006+01:00

Today I was writing a unit test for a winforms application (or rather a small Mvc framework for winforms) and I would like to simulate a button click on the form to se that all events had been wired correctly.
Since the event is a delegate, I thought it would be easy to just call the Invoke/DynamicInvoke methods of the Click delegate instance to get the events fiering...
It wasn't quite that easy though. When I tried to use the code

button.Click.Invoke(this,EventArgs.Empty);

I got a compiler error

The event 'System.Windows.Forms.Control.Click' can only appear on the left hand side of += or -=

After a search I found an article by Partha S that summarized the issue quite well, namely the difference between an event and a delegate is that the event can control the chaining and the event can only be invoked from within the declaring class. Partha also provided a solution for declaring an event that can be called from external code but that don't help me since I cannot modify the Button class.

A workaround is then to use reflection for retrieving the delegate field from the button class and when we have direct access to the delegate (not through the event wrapper construct) we will be able to Invoke the event.
The code below contains a method "GetField" that is included in our base library that I can post if anyone is interested, but for now it returns the value of a field.

//All events in a Component is listed in an EventHandlerList 
//called events in the Component class. 
//b is the button instance.
EventHandlerList list = ReflectionUtil.GetField(
    typeof(Component), "events", b) as EventHandlerList;
Assert.IsNotNull(list,"Cannot get eventlist from component");

//in the EventHandlerList, each delegate is identified by a
//static object instance in the control class
object eventClick = ReflectionUtil.GetField(typeof(Control),
    "EventClick",null);

//now we get the click event delegate
Delegate click = list[eventClick];

//finally we can invoke the listeners of the click event.
click.DynamicInvoke(this, EventArgs.Empty);

So now I can click da button in my unittest :)

BadImageFormatException when loading Microsoft.TeamFoundation.Client.dll

2008-10-22T12:07:00.005+02:00

I tried to make a small winforms application on my 64bit Vista that talks with our TeamFoundationServer today. I use a plugin based application that loads the assemblies using Assembly.Load (utilizing the AppDomain.AssemblyResolve event).

The problem surfaced when I tried to activate a function in one of my loaded plugins that used the TeamFoundation client dll, this was not located in the same folder as the exe.
Using the AppDomain.CurrentDomain.AssemblyResolve event, I was easy to find the assembly dll and using Assembly.LoadFrom(filename) I could return the needed assembly.

The problem was that when I tried to do this, I got a BadImageFormatException stating that

Could not load file or assembly 'file:///C:\MyPath\MyProject\bin\Debug\Plugins\MyPlugin\Microsoft.TeamFoundation.Client.dll' or one of its dependencies. An attempt was made to load a program with an incorrect format.
at System.Reflection.Assembly._nLoad(AssemblyName fileName, String codeBase, Evidence assemblySecurity, Assembly locationHint, StackCrawlMark& stackMark, Boolean throwOnFileNotFound, Boolean forIntrospection)
at System.Reflection.Assembly.InternalLoad(AssemblyName assemblyRef, Evidence assemblySecurity, StackCrawlMark& stackMark, Boolean forIntrospection)
at System.Reflection.Assembly.LoadFrom(String assemblyFile)
at Meridium.Plugins.PluginLoader.CurrentDomain_AssemblyResolve(Object sender, ResolveEventArgs args) in C:\VSS\TFS\Meridium\Source\Meridium.Plugins\PluginLoader.cs:line 606

This seemed not quite correct, since the assembly at the location is ok and can be opened for instance in Reflector.

After a bit of searching I found more clues pointing to the fact that a 64bit application cannot load 32bit assemblies if they are in "Mixed mode" since they contain native code and thus are platform specific. The forum post http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=665884&SiteID=1 stated the problem and provided the solution to set the project output to be built for the x86 platform.

After changing the settings in the project, it worked like a charm.

Adding an appender to log4net in runtime

2008-08-26T16:35:00.012+02:00

I was testing logging with log4net today and wanted to create a unit test that verified that the method logged alright.
To verify that the logging worked I wanted to create a log appender (the MemoryAppender) and add it to the log4net configuration to be able to compare the actual logged messages with the expected ones. (The MemoryAppender has the GetEvents() and Clear() methods which works well in a unit test case).

Normally you use a configuration file (xml) to add your appenders but using configuration files in a unit test is not quite the optimal solution. So how could I set it in runtime in my test method. After a bit of testing and reading (I wonder why the testing and reading always seem to be in that order? (for me anyway) Shouldn't you start reading about the theory before you start coding and testing? ;)

I found some tips using the Hierarchy class to access the root level logger and add append the MemoryAppender there.

The important steps where to set the Configured property of the Hierarchy and call the RaiseConfigurationChanged() method to actually utilize the configuration changes.

Here is a complete example.

//First create and configure the appender
MemoryAppender memoryAppender = new MemoryAppender();
memoryAppender.Name = "MyAppender";

//Notify the appender on the configuration changes
memoryAppender.ActivateOptions();

//Get the logger repository hierarchy.
log4net.Repository.Hierarchy.Hierarchy repository =
   LogManager.GetRepository() as Hierarchy;

//and add the appender to the root level
//of the logging hierarchy
repository.Root.AddAppender(memoryAppender);

//configure the logging at the root.
repository.Root.Level = Level.All;

//mark repository as configured and
//notify that is has changed.
repository.Configured = true;
repository.RaiseConfigurationChanged(EventArgs.Empty);

Now we have prepared the logging for the root (all log events) and directed it to the memoryAppender.

//Call the method to test (this one creates
//an info level message to the log
//stating the string "GetConfiguration()".
ServerDataFactory.Instance.GetConfiguration();

When we have ran the code that has produced some logging, we add assert statements to check that the code behaved as we expected.

//use the memoryAppender to get the logged events
LoggingEvent[] events = memoryAppender.GetEvents();

//We only expect one log statement on the info level
Assert.AreEqual(1, events.Length,
   "Incorrect number of log statements");
LoggingEvent e = events[0];
Assert.AreEqual(Level.Info, e.Level,
   "Incorrect logging level");
Assert.AreEqual("GetConfiguration()", e.MessageObject,
   "Incorrect log message");

Thats how I did it. Does anyone has another solution that works well?

ClickOnce, SharePoint and Anonymous access

2008-02-28T13:50:00.005+01:00

I have been laborating with a ClickOnce deployed application in SharePoint and all seems to work well until I tried to connect to SharePoint (wss3) from a workstation where I used another locally logged in user than the one I used to authenticate myself at the SharePoint server.

When I then tried to access the ClickOnce application the bootstrap downloader (ApplicationActivator) prompts a "Cannot Start Application" error that says "Cannot retrieve application. Authentication error".

The details of the error indicates a 401 response from the webserver.

System.Deployment.Application.DeploymentDownloadException (Unknown subtype)
  - Downloading http://wm20031/_layouts/MyApp/MyApp.application did not succeed.
  - Source: System.Deployment
  - Stack trace:
    at System.Deployment.Application.SystemNetDownloader.DownloadSingleFile(DownloadQueueItem next)
    at System.Deployment.Application.SystemNetDownloader.DownloadAllFiles()
    at System.Deployment.Application.FileDownloader.Download(SubscriptionState subState)
    at System.Deployment.Application.DownloadManager.DownloadManifestAsRawFile(Uri& sourceUri, String targetPath, IDownloadNotification notification, DownloadOptions options, ServerInformation& serverInformation)
    at System.Deployment.Application.DownloadManager.DownloadDeploymentManifestDirectBypass(SubscriptionStore subStore, Uri& sourceUri, TempFile& tempFile, SubscriptionState& subState, IDownloadNotification notification, DownloadOptions options, ServerInformation& serverInformation)
    at System.Deployment.Application.DownloadManager.DownloadDeploymentManifestBypass(SubscriptionStore subStore, Uri& sourceUri, TempFile& tempFile, SubscriptionState& subState, IDownloadNotification notification, DownloadOptions options)
    at System.Deployment.Application.ApplicationActivator.PerformDeploymentActivation(Uri activationUri, Boolean isShortcut, String textualSubId, String deploymentProviderUrlFromExtension)
    at System.Deployment.Application.ApplicationActivator.ActivateDeploymentWorker(Object state)

--- Inner Exception ---
System.Net.WebException
  - The remote server returned an error: (401) Unauthorized.
  - Source: System
  - Stack trace:
    at System.Net.HttpWebRequest.GetResponse()
    at System.Deployment.Application.SystemNetDownloader.DownloadSingleFile(DownloadQueueItem next)

If I check the weblog we can se the following two entries

2008-02-28 12:05:29 W3SVC1265274740 192.168.1.199 GET /_layouts/MyApp/MyApp.application 80 domain\administrator 192.168.1.2 Mozilla/4.0+(...) 206 0 0
2008-02-28 12:05:29 W3SVC1265274740 192.168.1.199 GET /_layouts/MyApp/MyApp.application  80 - 192.168.1.2 - 401 5 0

The first is the webbrowser access where I authenticate using the domain\administrator account and the application manifest is successfully returned to the browser. Then the ApplicationActivator tries the same thing as anonymous but fails utterly. Ok, so perhaps this is only anonymous user access that is denied, but I had already checked the "Enable Anonymous access" in the IIS manager for the _layouts/MyApp folder.

Testing with firefox and anonymous access proved that is not the access rights that is incorrectly set.

2008-02-28 12:16:56 W3SVC1265274740 192.168.1.199 GET /_layouts/MyApp/MyApp.application 80 - 192.168.1.2 Mozilla/5.0+... 200 0 0

So the IIS is not blocking access, then it has to be SharePoint? (_layouts is a SharePoint managed folder)

To test I checked the code for the System.Deployment.Application.SystemNetDownloader.DownloadSingleFile(DownloadQueueItem next) method and reproduced the code that was processed there.

WebRequest request = WebRequest.Create("http://wm20031/_layouts/MyApp/MyApp.application");
request.Credentials = CredentialCache.DefaultCredentials;
RequestCachePolicy policy = new RequestCachePolicy(RequestCacheLevel.BypassCache);
request.CachePolicy = policy;
HttpWebRequest request2 = request as HttpWebRequest;
if (request2 != null) {
  request2.UnsafeAuthenticatedConnectionSharing = true;
  request2.AutomaticDecompression = DecompressionMethods.GZip;
  request2.CookieContainer = GetUriCookieContainer(request2.RequestUri);
  WebRequest.DefaultWebProxy.Credentials = CredentialCache.DefaultCredentials;
}
WebResponse response = null;
response = request.GetResponse();
using (StreamReader reader = new StreamReader(response.GetResponseStream())) {
  Console.WriteLine(reader.ReadToEnd());
}
response.Close();

This code fails with the same exception as the Application Activator and after some debugging I noticed that if I didn't copy the cookies to the request, then it worked?!
Checking further in the cookie container, it only added one cookie MSOWebPartPage_AnonymousAccessCookie and with the value of the webapplication port. (80)

The GetUriCookieContainer parsed the cookies retrieved in IE for the url. If I removed the cookie for the server in the temporary internet files folder, the code above worked even with the cookie row (no cookies added).

To solve the problem one workaround is to create a virtual folder in the root of the SharePoint site (MyApp) (that is not managed by SharePoint), map this to the same folder as _layouts/MyApp, allow anonymous access there and navigate to that url instead (/MyApp/MyApp.application). This works since the cookie is not present for the application.

But what I really like to know is the purpose of the MSOWebPartPage_AnonymousAccessCookie, especially why SharePoint sets this cookie when I navigate to the site and why it throws an access denied when I try to access with the cookie set?

Task failed because "sgen.exe" was not found

2007-11-26T15:10:00.001+01:00

I installed Visual Studio 2008 (final) and started to create a WinForms (2.0) application that calls a webservice and is deployed with clickonce. When I try to compile it (after adding the webreference) I get the following build error

C:\WINDOWS\Microsoft.NET\Framework\v3.5\Microsoft.Common.targets(1993,9):
error MSB3091:
Task failed because "sgen.exe" was not found, or the correct Microsoft Windows SDK is not installed. The task is looking for "sgen.exe" in the "bin" subdirectory beneath the location specified in the InstallationFolder value of the registry key HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SDKs\Windows\v6.0A. You may be able to solve the problem by doing one of the following:
1) Install the Microsoft Windows SDK for Windows Server 2008 and .NET Framework 3.5.
2) Install Visual Studio 2008.
3) Manually set the above registry key to the correct location.
4) Pass the correct location into the "ToolPath" parameter of the task.

I thought that the SDK was to be installed with VisualStudio 2008, but when looking into the SDKs folder (C:\Program Files\Microsoft Visual Studio 9.0\SDK) it contains almost nothing, only a few files in the v3.5 folder.

When I searched for the SDK for framework 3.5 it seems that is included in the windows server 2008 platform sdk and that is only avaliable for beta2 so far...

Regarding the registry settings, I have the SDK for v2.0 installed and since I build vs the 2.0 framework, shouldn't it look in the KEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SDKs\Windows\v2.0 key?

How do I set the ToolPath?

Anyway, I came around the issue by setting the HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SDKs\Windows\v6.0A InstallationFolder key to the same path as the 2.0 Sdk path and compilation was successful...

Is the VisualStudio 2008 release not final since it seems to miss the SDK or have I been sloppy installing the product?

Signing a ClickOnce manifest file using a spc/pvk certificate

2007-11-26T12:03:00.001+01:00

To sign a ClickOnce manifest file/assembly you need a pfx file without chaining information.

First we need to convert the spc/pvk file to a pfx file. As Stuart found out you use the pvk2pfx tool to accomplish this.

If we try to use this certificate and it contains chaining information we will get an error stating

"Cannot find the certificate and private key for decryption"

Then we need to make sure that the pfx don't include the chaining information as described in the case @ commodo (importing and exporting the pfx).

When these steps has been completed, you can build and sign your application.