.net – Page 2 – Code musings in C#

Using NUnit for a .Net 4 project in a Jenkins installation

I have migrated my MBUnit tests to NUnit, considering MBUnit has been “on hiatus” for about a year now. NUnit is not much more agile, but at least there is a semblance of life on their Github account.

The switch has been surprisingly easy: change the namespace, change TestRow with Test, and change Row with TestCase. Easy!

Run unit tests in your continuous integration platform

In order to integrate the tests in our continuous integration platform, while minimizing build time, I have split the setup package build and the unit tests run. So I have a job that runs at each commit, that builds the project and generates the setup packages; and another job running at midnight, that only builds the project and runs unit tests.

Apparently, using the automatic package restore from Visual Studio is now obsolete with the latest Nuget versions. So I followed the instructions and migrated to Nuget package restore. Remember to download nuget.exe from nuget.org, add it to the CI server’s PATH, and restart Jenkins.

Add the NUnit Nuget packages to the test projects, and remember to add the NUnit Runner Nuget package to the solution! It will be much easier to run the unit tests this way (no need to install NUnit on the CI server).

I’m using PSAke for my build process (awesome tool!), so now my script looks like this:

Properties {
  $ROOT_PATH = [System.IO.Path]::GetFullPath((Join-Path (pwd) ".\build"))
  $APP_PATH = Join-Path $ROOT_PATH "app"
  $TESTS_PATH = Join-Path $ROOT_PATH "tests"
  $NUNIT_PATH = Join-Path (pwd) "packages\NUnit.Runners.2.6.3\tools\nunit-console-x86.exe" # note that if you build your test binaries for x86, you must use the x86 test runner
}

Framework "4.0x86" # this builds using the 32-bit .Net 4

# This is the task that is run by the "standard" job
task default -depends Cleanup, Build, Config, Setup

# this is the task that is run by the "tests" job
task Test -depends Cleanup, BuildNUnit {
  Get-ChildItem $TESTS_PATH -Filter "*.*Test*.dll" | % {
    $result = (Join-Path $resultsPath $_.Name) -replace ".dll",".xml"
    Start-Process $NUNIT_PATH -ArgumentList "`"$($_.FullName)`" /framework:net-4.0 /nologo /result:`"$result`"" -Wait -NoNewWindow
  }
}

task Restore {
  & nuget restore
}

task Cleanup { 
  # remove all binaries - only useful for local run
}

task Build -depends Restore { 
  Exec {
    msbuild "mysolution.sln" /t:Build /p:Configuration=Release /p:Platform=x86
  }
}

task BuildNUnit -depends Restore { 
  Exec {
    msbuild "mysolution.sln" /t:Build /p:Configuration=NUnit /p:Platform=x86
  }
}

task Config { 
  # modify config values
}

task Setup {
  # run InnoSetup to generate setup packages
}

Properties {

$ROOT_PATH = [System.IO.Path]::GetFullPath((Join-Path (pwd) ".\build"))

$APP_PATH = Join-Path $ROOT_PATH "app"

$TESTS_PATH = Join-Path $ROOT_PATH "tests"

$NUNIT_PATH = Join-Path (pwd) "packages\NUnit.Runners.2.6.3\tools\nunit-console-x86.exe" # note that if you build your test binaries for x86, you must use the x86 test runner

}

Framework "4.0x86" # this builds using the 32-bit .Net 4

# This is the task that is run by the "standard" job

task default -depends Cleanup, Build, Config, Setup

# this is the task that is run by the "tests" job

task Test -depends Cleanup, BuildNUnit {

Get-ChildItem $TESTS_PATH -Filter "*.*Test*.dll" | % {

$result = (Join-Path $resultsPath $_.Name) -replace ".dll",".xml"

Start-Process $NUNIT_PATH -ArgumentList "`"$($_.FullName)`" /framework:net-4.0 /nologo /result:`"$result`"" -Wait -NoNewWindow

}

task Restore {

& nuget restore

}

task Cleanup {

# remove all binaries - only useful for local run

}

task Build -depends Restore {

Exec {

msbuild "mysolution.sln" /t:Build /p:Configuration=Release /p:Platform=x86

}

task BuildNUnit -depends Restore {

Exec {

msbuild "mysolution.sln" /t:Build /p:Configuration=NUnit /p:Platform=x86

}

task Config {

# modify config values

}

task Setup {

# run InnoSetup to generate setup packages

}

And now my Jenkins jobs consist of a simple batch line:

powershell "Import-Module .\psake.psm1 ; Invoke-Psake .\build.ps1 MYTASKNAME"

1	powershell "Import-Module .\psake.psm1 ; Invoke-Psake .\build.ps1 MYTASKNAME"

I have sumbled on a System.BadImageFormatException while running tests in Jenkins using nunit-console, or trying to add the assemblies to the NUnit GUI runner. Here are a few things to remember:

Do not use AnyCPU

Your test assemblies, assemblies linked by your tests, and really your whole project, should be built in 32-bits mode, so that they can be run by the 32-bits test runner. Personnaly, I created a “NUnit” solution configuration just for this. It allows me to select which assemblies are built in which case: no need to build tests in the general build, and no need to build stuff like bootstrapper exes in the test build.

Check your build paths

If you create a new configuration like I did, remember to change the build path! My main project builds in the \build\app folder, and my tests are located in \build\tests. I spent a few minutes wondering why the platform change did nothing, before finding out that my x86 test assemblies were in bin\x86\NUnit (the default value).

Check the framework version

Select the proper .Net framework with the /framework:net-4.0 switch. NUnit should be able to find out automagically, but sometimes it doesn’t.

WPF/SOAP configuration for third-party webservice with empty security headers

I am writing a program that accesses a SOAP webservice written by a third-party provider.

I need to provide a user and login in the SOAP headers, which is kind of easy, in theory:

add the webservice reference to Visual Studio
instantiate a new “XXXXClient” generated class
set xxx.ClientCredentials.UserName.UserName and xxx.ClientCredentials.UserName.Password

Easy as pie. Except when it’s not. You see, the provider’s webservice is written using php, it does not behave nicely with .Net. When you send the request, you can see on Fiddler that the query is sent and gets a response, but .Net does not like this response, and throws exceptions around.

First problem: it throws a MesssageSecurityException because of empty security headers in the response (see here). I first thought that I had the same problem, so I spent the day resolving the issue following this blog post, but it turns out it’s much more simple. To fix this, you must set the enableUnsecuredResponse in the binding’s security node to true. And in order to do that, your binding must be a customBinding. If you have a complicated binding, good luck switching.

Second problem: the mime type for the request and the response are different (“text/xml” vs “application/soap+xml”). To fix this one, you have to write your own custom text encoder (download the WCF examples at the top), and to do that… you have to create something like a thousand classes with a hundred lines each. Just for a simple mime type mismatch! Do not forget to also copy, from the downloadable examples, the BindingElement, BindingSection, ConfigurationStrings, and MessageVersionConverter !

So, for such a simple task, as is too often the case with Microsoft, I need to rewrite (or copy, here) a whole bunch of stuff, just to modify some pretty mundane and common behavior, which should be configurable in the first place. It shows how extensible WCF is, and how bloated the extending is.

Anyway, here is a working app.config. For the code of the custom text message encoding class, as I said, just copy the MS examples (and don’t forget to rename the types in the bindingElementExtensions).

<system.serviceModel>
    <extensions>
        <bindingElementExtensions>
            <add name="customTextMessageEncoding" type="MyClient.SOAP.CustomMessageBindingSection, MyClient" />
        </bindingElementExtensions>
    </extensions>
    <bindings>
        <customBinding>
            <binding name="ThirdPartyOrderBinding">
                <customTextMessageEncoding messageVersion="Soap11" mediaType="text/xml" />
                <security authenticationMode="UserNameOverTransport" enableUnsecuredResponse="true" />
                <httpsTransport />
            </binding>
        </customBinding>
    </bindings>
    <client>
        <endpoint address="https://www.myservice.com/services/ThirdPartyOrder.php"
            binding="customBinding" bindingConfiguration="ThirdPartyOrderBinding"
            contract="MyServiceWS.ThirdPartyOrderPortType" name="ThirdPartyOrderPort" />
    </client>
</system.serviceModel>

<system.serviceModel>

</bindingElementExtensions>

</extensions>

</binding>

</customBinding>

</bindings>

<endpoint address="https://www.myservice.com/services/ThirdPartyOrder.php"

binding="customBinding" bindingConfiguration="ThirdPartyOrderBinding"

contract="MyServiceWS.ThirdPartyOrderPortType" name="ThirdPartyOrderPort" />

</client>

</system.serviceModel>

Debug integrated WPF WebBrowser scripts using Visual Studio

Copied and modified from another blog for future reference.

Note that in order to debug the Javascript inside a WebBrowser control, you don’t need the source code of the application (neat!).

Open Internet Explorer, go to Settings, tab Advanced, and, in the “Navigation” section:
- Uncheck “disable script debugging” (both IE and Other)
- Uncheck “Display friendly HTTP messages”
- Check “Display a notification about every script error”
Open an instance of Visual Studio. Open the Tools menu, Attach to Process, and on the “Attach to” line, click “Select…”, and only check “Script”.
Run the program including the WPF BrowserControl
Attach the Visual Studio instance to its process.

Now, open the “Solution explorer” tab/toolbox. You will see every Javascript file loaded by the WPF WebBrowser control, and you can add breakpoints where you want.

Tested with IE 11 and Visual Studio 2010.

Using SWIG to create a .Net wrapper around a C library

A consultant has written a C library to neatly pack images on a space. They have integrated it in their Ruby On Rails / Node.js online app through the power of extending Ruby. I’m quite jealous, because it’s not quite as easy to do in .Net. Especially when, like me, you know absolutely nothing about C/C++.

Two options are available to me:

Create a C++/CLI project, that will generate a .Net DLL
Use SWIG to generate a .Net wrapper around the C code.

Now, since I can’t change much the C code (it must be built on Mac through Ruby), I thought that I couldn’t easily switch it to CLI (I was wrong ; see the next post).

So I tried using SWIG. And it’s a pain to use. Let me walk you through creating a wrapper around a non-trivial C library.

Generating basic wrapper methods is pretty easy: it’s a matter of creating a .i file with a few lines of code:

%module packer_cs
%include <carrays.i>
%{
    #include "packer.h" 
%}
%include "packer.h"

%module packer_cs

%include <carrays.i>

#include "packer.h"

%include "packer.h"

Run SWIG on this file to generate a few C# files and a C wrapper class:

swig -csharp -outdir bin\csharp src\packer\packer.i

1	swig -csharp -outdir bin\csharp src\packer\packer.i

Then, you create an empty C/C++ library project with Visual Studio, include all the necessary files, and generate it. It builds a DLL, and you can include both the C# files and the DLL in your .Net project to use. Very nice, very simple.

A problem arises when you have a C method taking an array as argument: SWIG generates a C# signature taking a single instance as argument:

public static int pack(image_t images, int nb_images, parameters_t arg2)

1	public static int pack(image_t images, int nb_images, parameters_t arg2)

You can tell SWIG to create an “intermediate” array type by adding this to your .i file:

%array_class(image_t, image_t_array);

1	%array_class(image_t, image_t_array);

This creates an “image_t_array” class, with methods for setting and getting items, old-school-style. There is also a method to cast it as “image_t”, with pointers handling to go back and forth in the array.

// build the array from the "images" variable (a List<image_t>)
var images_array = new image_t_array(images.Count);
for (var i = 0; i < images.Count; i++)
{
    image_t_array.setitem(i, images[i]);
}

// the cast() method casts it to image_t
var result = packer_cs.pack(images_array.cast(), images.Count, param);

// build the array from the "images" variable (a List<image_t>)

var images_array = new image_t_array(images.Count);

for (var i = 0; i < images.Count; i++)

{

image_t_array.setitem(i, images[i]);

}

// the cast() method casts it to image_t

var result = packer_cs.pack(images_array.cast(), images.Count, param);

Now, creating an array class, and cast as instance to pass it as parameter is not very intuitive, and I’m trying to create a usable wrapper. I want to pass an actual, managed array to my method. Is that so hard?

The SWIG documentation has a whole part about passing managed arrays to non-managed code. The problem is that (once again), the documentation is incomplete. It shows an example for a managed arrays of ints… but not an array of structs. Apparently it doesn’t work the same way, because SWIG complains about a missing typemap when using this:

%apply image_t INPUT[] { image_t *images }

1	%apply image_t INPUT[] { image_t *images }

Actually, a totally undocumented feature needs to be called just above this line:

CSHARP_ARRAYS(image_t, image_t)

1	CSHARP_ARRAYS(image_t, image_t)

Thanks to a nice fellow on StackOverflow for reading the SWIG sources… Googling for “CSHARP_ARRAYS” yeilds exactly zero result in the documentation, but only a few relevant results on forums and mailing lists. Why is it not documented, while it’s obviously necessary? If it’s not the right way, which is? Why not documenting the warning message that appears when you don’t use it?

So anyway, now my C# method takes a managed array as argument, which makes this library so much more easy to use. It throws a memory access exception when running the “pack” method, though (System.AccessViolationException).

Thankfully I have both the source files, and the pdb file for the unmanaged dll. I just have to copy the pdb to the target directory (using my test program post-build events), and once I activate unmanaged code debugging (managed project properties / debug /activate unmanaged code debugging), I can step through the library, using the actual C code! Awesome.

At the actual point that an error occurs, I can see that the library tries to access an image in the array that is not defined. Weird. By adding a few breakpoints in the C library (I can’t imagine how I would have debugged that without the source code…), I quickly notice that my “*images” (in the pack) have very weird values, and that they do not correspond to the sent values at all.

Since passing values as arrays might do weird things with pointers, I decide to switch back to using the “image_t_array” class… and sure enough, now the values are correctly passed. I still have memory access problems, though, but that seems to be on the C side… but it runs nicely when a C++ program calls it, so I still have some digging to do.

At this point, debugging the wrapper becomes very complicated with all the layers involved, so I decided to try the C++/CLI way which, as you may see in my next post, is not that hard after all.

Linq2SQL – Row Not Found Or Changed

Working on a .Net 3.5 client app, I am stuck using the lesser evil of Linq2SQL (compared to the awefulness that is EntityFramework 1).

Updating data on a column results in a ChangeConflictException : “Row not found or changed”. The usual culprit of the DBML differing even slightly from the actual DB model was not to blame, and the concurrency was not either, since the processing took a few milliseconds at worst, on a local DB.

It actually was a trigger updating the “updated_at” column. In the DBML editor, setting the column to “check update : never” and “automatic synchronization : always” solved the problem.

Abstract away constructor logic

I need to create an administration interface in MVC, over an old and seriously crappy DB. The fields and tables have no consistency whatsoever, but that’s easily solved through renaming things with Entity Framework. But now, I need to do 5 administration interfaces for 5 trios of tables : “master”, “images” and “categories”. They are pretty much the same, except the table and field names. To do that, let’s play with abstraction.

I’m using crude ViewModels to display my search pages. They get the elements to display in the search dropdown lists, and paginate the results. All of the logic is in the constructor (the viewmodel is only used to display a search screen). When the constructor needs to get specific elements, it calls abstract methods. They are the ones that are actually different in the various pages.

The abstract base looks like this :

using MvcPaging;

public abstract class BaseElementListViewModel
{
    public BaseElementListViewModel(int? page, int? category, int? format, int? status)
    {
        this.Statuses = this.GetStatuses(status);
        this.Categories = this.GetCategories(category);
        this.Formats = this.GetFormats(format);

        using (var db = new SoftwareAdminEntities())
        {
            var baseQuery = this.GetBaseQuery(db);

            // filter the baseQuery with the selected category, format and status

            this.Results = baseQuery.ToPagedList(this.PageNumber, this.PageSize, this.TotalNumber);
        }
    }

    public IEnumerable<SelectListItem> Categories { get; set; }

    public IEnumerable<SelectListItem> Formats { get; set; }

    public IPagedList<IElementCombination> Results { get; set; }

    public IEnumerable<SelectListItem> Statuses { get; set; }

    protected abstract IQueryable<IElementCombination> GetBaseQuery(ModelEntities db);

    protected abstract IEnumerable<SelectListItem> GetCategories(int? category);

    protected abstract IEnumerable<SelectListItem> GetFormats(int? format);

    private IEnumerable<SelectListItem> GetStatuses(int? currentStatus)
    {
        // gets the list of statuses ; they are always the same for all elements
    }
}

using MvcPaging;

public abstract class BaseElementListViewModel

{

public BaseElementListViewModel(int? page, int? category, int? format, int? status)

{

this.Statuses = this.GetStatuses(status);

this.Categories = this.GetCategories(category);

this.Formats = this.GetFormats(format);

using (var db = new SoftwareAdminEntities())

{

var baseQuery = this.GetBaseQuery(db);

// filter the baseQuery with the selected category, format and status

this.Results = baseQuery.ToPagedList(this.PageNumber, this.PageSize, this.TotalNumber);

}

public IEnumerable<SelectListItem> Categories { get; set; }

public IEnumerable<SelectListItem> Formats { get; set; }

public IPagedList<IElementCombination> Results { get; set; }

public IEnumerable<SelectListItem> Statuses { get; set; }

protected abstract IQueryable<IElementCombination> GetBaseQuery(ModelEntities db);

protected abstract IEnumerable<SelectListItem> GetCategories(int? category);

protected abstract IEnumerable<SelectListItem> GetFormats(int? format);

private IEnumerable<SelectListItem> GetStatuses(int? currentStatus)

{

// gets the list of statuses ; they are always the same for all elements

}

And now the implementation is very simple ; here for the themes :

public class ThemesListViewModel : BaseElementListViewModel
{
    public ThemesListViewModel(int? page, int? category, int? format, int? status) : base(page, category, format, status)
    {
    }

    protected override IQueryable<IElementCombination> GetBaseQuery(SoftwareAdminEntities db)
    {
        return from i in db.Theme_Images
               join m in db.Theme_Master on i.ThemeMasterID equals m.ThemeMasterID
               orderby i.CreatedDate descending
               select new Theme_Combination
                      {
                          Active = i.Active,
                          AllowInterior = i.AllowInterior,
                          ImageID = i.BackgroundImageID,
                          BookSizeID = m.BookSizeID,
                          Checksum = i.Checksum,
                          Created = i.CreatedDate,
                          FileType = i.File_type,
                          Modified = m.ModifiedDate,
                          Size = i.Size,
                          Sort = i.Sort,
                          Status = i.Status,
                          CategoryID = m.ThemeCategoryID,
                          MasterID = m.ThemeMasterID,
                          Version = m.Version
                      };
    }

    protected override IEnumerable<SelectListItem> GetCategories(int? category)
    {
        // get the list of categories
    }

    protected override IEnumerable<SelectListItem> GetFormats(int? format)
    {
        // get the list of formats
    }
}

public class ThemesListViewModel : BaseElementListViewModel

{

public ThemesListViewModel(int? page, int? category, int? format, int? status) : base(page, category, format, status)

{

}

protected override IQueryable<IElementCombination> GetBaseQuery(SoftwareAdminEntities db)

{

return from i in db.Theme_Images

join m in db.Theme_Master on i.ThemeMasterID equals m.ThemeMasterID

orderby i.CreatedDate descending

select new Theme_Combination

{

Active = i.Active,

AllowInterior = i.AllowInterior,

ImageID = i.BackgroundImageID,

BookSizeID = m.BookSizeID,

Checksum = i.Checksum,

Created = i.CreatedDate,

FileType = i.File_type,

Modified = m.ModifiedDate,

Size = i.Size,

Sort = i.Sort,

Status = i.Status,

CategoryID = m.ThemeCategoryID,

MasterID = m.ThemeMasterID,

Version = m.Version

};

}

protected override IEnumerable<SelectListItem> GetCategories(int? category)

{

// get the list of categories

}

protected override IEnumerable<SelectListItem> GetFormats(int? format)

{

// get the list of formats

}

Theme_Combination is the joining of two entities, Master and Images. All your element_combination must inherit from IElementCombination. If they do not implement anything specific themselves, you can even use a single ElementCombination class.

Bug in WPF 4 text rendering

Microsoft has completely changed the text rendering engine from WPF 3.5 to 4.0. In the meantime, it also has introduced a bug, which you can read about here : http://stackoverflow.com/questions/23246254/ and here : https://connect.microsoft.com/VisualStudio/feedback/details/860053/wpf-4-font-rendering-bug-with-some-fonts-generated-xps-is-invalid. I have built a test project that demonstrates the problem here : https://github.com/tbroust-trepia/wpf-4-font-rendering

What looks like a small problem (the apostrophe character ” ‘ ” actually reduces the space between two characters with some fonts, resulting in overlapping characters) is problematic when you generate an XPS file from the XAML, because the resulting XPS is “corrupted”, with negative letter-spacing, which seems illegal in XPS.

I don’t really know which is to blame more : the font rendering bug, or the XPS converter (integrated in .Net !) which renders the text faithfully, but shouldn’t. Anyway, while waiting for MS to fix anything, I have found the way to fix it myself. Warning: dirty hack ahead.

public class XpsFile
{
    /// <summary>
    /// Regex to validate XPS "indices" property (gotten from ABCPDF)
    /// </summary>
    private static readonly string IndicesRegex = @"(((\(([1-9][0-9]*)(:([1-9][0-9]*))?\))?([0-9]+))?(,(\+?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?)?(,((\-|\+)?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?)?(,((\-|\+)?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?))?)?)?)(;((\(([1-9][0-9]*)(:([1-9][0-9]*))?\))?([0-9]+))?(,(\+?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?)?(,((\-|\+)?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?)?(,((\-|\+)?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?))?)?)?)*";

    /// <summary>
    /// Fixes the XPS problems it encounters and knows about
    /// </summary>
    public static void FixXps(string filePath)
    {
        // first we'll load the XPS file
        using (var currentPackage = Package.Open(filePath, FileMode.Open))
        {
            var pageUri = new Uri("/Documents/1/Pages/1.fpage", UriKind.Relative);

            // check that the file we'll modify exists
            if (!currentPackage.PartExists(pageUri))
            {
                throw new Exception(string.Format("Unable to find first page in XPS {0} - unable to fix this XPS !", filePath));
            }

            // assume the broken part is in the first page
            var firstPage = currentPackage.GetPart(pageUri);
            var relationships = firstPage.GetRelationships();
            var pageContent = XDocument.Load(firstPage.GetStream());

            // then we'll look up each glyph and check if their "Indices" property is valid
            XNamespace ns = pageContent.Root.GetDefaultNamespace();
            var glyphs = (from g in pageContent.Descendants(ns + "Glyphs")
                          where g.Attribute("Indices") != null
                          select g).ToList();
            for (var i = 0; i < glyphs.Count(); i ++)
            {
                glyphs[i] = FixGlyph(glyphs[i]);
            }

            // remove the current (corrupted) file from the package
            currentPackage.DeletePart(pageUri);

            // add the new (shiny) file to the package
            var newPage = currentPackage.CreatePart(pageUri, "application/vnd.ms-package.xps-fixedpage+xml", CompressionOption.NotCompressed);
            using (var ms = new MemoryStream())
            {
                // we need to remove XML declaration, so we need to use the XmlWriter
                var settings = new XmlWriterSettings();
                settings.Indent = false;
                settings.NewLineChars = string.Empty;
                settings.NewLineHandling = NewLineHandling.Replace;
                settings.OmitXmlDeclaration = true;
                using (var xw = XmlWriter.Create(ms, settings))
                {
                    pageContent.WriteTo(xw);
                }

                ms.Seek(0, SeekOrigin.Begin);
                CopyStream(newPage.GetStream(), ms);
            }

            // now we need to re-create the relationships between the Page file and the fonts
            foreach (var relation in relationships)
            {
                newPage.CreateRelationship(relation.TargetUri, relation.TargetMode, relation.RelationshipType, relation.Id);
            }
        }
    }

    /// <summary>
    /// Tries to load the XPS, and returns false if it fails
    /// </summary>
    public static bool IsValidXps(string filePath)
    {
        try
        {
            using (var xpsOld = new XpsDocument(filePath, FileAccess.Read))
            {
                var unused = xpsOld.GetFixedDocumentSequence();
            }

            return true;
        }
        catch (System.Windows.Markup.XamlParseException)
        {
            return false;
        }
    }

    /// <summary>
    /// Writes the whole content of a stream into another
    /// </summary>
    /// <remarks>
    /// http://stackoverflow.com/a/18885954/2354542
    /// </remarks>
    private static void CopyStream(Stream target, Stream source)
    {
        const int bufSize = 0x1000;
        byte[] buf = new byte[bufSize];
        int bytesRead = 0;
        while ((bytesRead = source.Read(buf, 0, bufSize)) > 0)
        {
            target.Write(buf, 0, bytesRead);
        }
    }

    /// <summary>
    /// Fixes the glyph, if necessary
    /// </summary>
    private static XElement FixGlyph(XElement g)
    {
        var matchAttribute = Regex.Match(g.Attribute("Indices").Value, IndicesRegex);
        if (!matchAttribute.Success)
        {
            return g;
        }

        var hasProblem = false;
        foreach (var token in matchAttribute.Value.Split(";".ToCharArray()))
        {
            if (token == ",")
            {
                hasProblem = true;
                break;
            }
        }

        if (hasProblem)
        {
            // the Indices attribute is not well-formed: let's try to fix the one(s) that are wrong
            var fixedTokens = new List<string>();
            foreach (var token in g.Attribute("Indices").Value.Split(";".ToCharArray()))
            {
                var newToken = token;
                var matchToken = Regex.Match(token, @",(-\d+)");
                if (matchToken.Success) // negative number, yay ! it's not allowed :-(
                {
                    newToken = ",0"; // it should be zero, I believe
                }

                fixedTokens.Add(newToken);
            }

            g.Attribute("Indices").Value = string.Join(";", fixedTokens);
        }

        return g;
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

public class XpsFile

{

/// <summary>

/// Regex to validate XPS "indices" property (gotten from ABCPDF)

/// </summary>

private static readonly string IndicesRegex = @"((($([1-9][0-9]*)(:([1-9][0-9]*))?$)?([0-9]+))?(,(\+?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?)?(,((\-|\+)?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?)?(,((\-|\+)?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?))?)?)?)(;(($([1-9][0-9]*)(:([1-9][0-9]*))?$)?([0-9]+))?(,(\+?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?)?(,((\-|\+)?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?)?(,((\-|\+)?(([0-9]+(\.[0-9]+)?)|(\.[0-9]+))((e|E)(\-|\+)?[0-9]+)?))?)?)?)*";

/// <summary>

/// Fixes the XPS problems it encounters and knows about

/// </summary>

public static void FixXps(string filePath)

{

// first we'll load the XPS file

using (var currentPackage = Package.Open(filePath, FileMode.Open))

{

var pageUri = new Uri("/Documents/1/Pages/1.fpage", UriKind.Relative);

// check that the file we'll modify exists

if (!currentPackage.PartExists(pageUri))

{

throw new Exception(string.Format("Unable to find first page in XPS {0} - unable to fix this XPS !", filePath));

}

// assume the broken part is in the first page

var firstPage = currentPackage.GetPart(pageUri);

var relationships = firstPage.GetRelationships();

var pageContent = XDocument.Load(firstPage.GetStream());

// then we'll look up each glyph and check if their "Indices" property is valid

XNamespace ns = pageContent.Root.GetDefaultNamespace();

var glyphs = (from g in pageContent.Descendants(ns + "Glyphs")

where g.Attribute("Indices") != null

select g).ToList();

for (var i = 0; i < glyphs.Count(); i ++)

{

glyphs[i] = FixGlyph(glyphs[i]);

}

// remove the current (corrupted) file from the package

currentPackage.DeletePart(pageUri);

// add the new (shiny) file to the package

var newPage = currentPackage.CreatePart(pageUri, "application/vnd.ms-package.xps-fixedpage+xml", CompressionOption.NotCompressed);

using (var ms = new MemoryStream())

{

// we need to remove XML declaration, so we need to use the XmlWriter

var settings = new XmlWriterSettings();

settings.Indent = false;

settings.NewLineChars = string.Empty;

settings.NewLineHandling = NewLineHandling.Replace;

settings.OmitXmlDeclaration = true;

using (var xw = XmlWriter.Create(ms, settings))

{

pageContent.WriteTo(xw);

}

ms.Seek(0, SeekOrigin.Begin);

CopyStream(newPage.GetStream(), ms);

}

// now we need to re-create the relationships between the Page file and the fonts

foreach (var relation in relationships)

{

newPage.CreateRelationship(relation.TargetUri, relation.TargetMode, relation.RelationshipType, relation.Id);

}

/// <summary>

/// Tries to load the XPS, and returns false if it fails

/// </summary>

public static bool IsValidXps(string filePath)

{

try

{

using (var xpsOld = new XpsDocument(filePath, FileAccess.Read))

{

var unused = xpsOld.GetFixedDocumentSequence();

}

return true;

}

catch (System.Windows.Markup.XamlParseException)

{

return false;

}

/// <summary>

/// Writes the whole content of a stream into another

/// </summary>

/// <remarks>

/// http://stackoverflow.com/a/18885954/2354542

/// </remarks>

private static void CopyStream(Stream target, Stream source)

{

const int bufSize = 0x1000;

byte[] buf = new byte[bufSize];

int bytesRead = 0;

while ((bytesRead = source.Read(buf, 0, bufSize)) > 0)

{

target.Write(buf, 0, bytesRead);

}

/// <summary>

/// Fixes the glyph, if necessary

/// </summary>

private static XElement FixGlyph(XElement g)

{

var matchAttribute = Regex.Match(g.Attribute("Indices").Value, IndicesRegex);

if (!matchAttribute.Success)

{

return g;

}

var hasProblem = false;

foreach (var token in matchAttribute.Value.Split(";".ToCharArray()))

{

if (token == ",")

{

hasProblem = true;

break;

}

if (hasProblem)

{

// the Indices attribute is not well-formed: let's try to fix the one(s) that are wrong

var fixedTokens = new List<string>();

foreach (var token in g.Attribute("Indices").Value.Split(";".ToCharArray()))

{

var newToken = token;

var matchToken = Regex.Match(token, @",(-\d+)");

if (matchToken.Success) // negative number, yay ! it's not allowed :-(

{

newToken = ",0"; // it should be zero, I believe

}

fixedTokens.Add(newToken);

}

g.Attribute("Indices").Value = string.Join(";", fixedTokens);

}

return g;

}

Update: Microsoft has closed the ticket, and, obviously, they have decided to not resolve the issue, since it impacts such a small number of people (maybe just us ?). I always thinks it’s sad when a company this big does not close such a small and quickly-fixed bug.

WPF and MVVM discovery

In our setup, we have operations that cannot realistically be run by the installer itself, so we have a separate application that updates various components at the end of the setup. I am rewriting this app so it’s cleaner (which isn’t very difficult considering the current state), and taking this opportunity to familiarize myself with WPF and the MVVM pattern.

I am using MVVM Light, and it’s a bit of a pain. There is exactly zero official documentation. It’s a real shame, considering that it’s one of the most used MVVM frameworks. I would love to use Caliburn.Micro because it’s well documented and supported, but using it in conjunction with MahApps.Metro adds yet another layer of complexity, and I am already learning about many things at once.

Creating a responsive UI in WPF using MVVM involves many steps and components. I will need to do my work in a BackgroundWorker, autoscroll a text box, etc, and bind it in my MVVM view. What I can find here and there often lacks a few important points, but it’s generally easy to find help.

Your ViewModel needs to declare public properties for each of the things displayed in the view, that you might want to change in the ViewModel. For instance, with a progress bar, if you don’t know how many steps you will have in advance, but you don’t want to use percentages, you will need to bind the Maximum property in the VM. Opening message and confirmation boxes should be done in the view, otherwise your VM unit tests will open dialog boxes that you can’t close. To do that, you need to create a messaging system.

All in all, I still don’t like WPF/MVVM very much. It’s very verbose, and doing anything takes a huge number of steps, namespaces importing, classes, workers, commands, and messaging back and forth. I have yet to come to a point where I find that all this overhead is useful. WPF seems really powerful, but it’s also really complicated and verbose to do anything at all. The overhead of adding a screen is huge: you have to create like a thousand properties, relay commands, events and events handlers, etc. I get that it’s the right way, but it’s a really long and windy way.

The main problem I have seems to be that people come up with incredibly complicated solutions to simple problems, and then say stuff like “it is easy to do X” and “simply do Y”… after posting a hundred-lines-long post with half a dozen classes… to display a message box.

As an aside, I hate Windows XP. In addition to being incredibly buggy (most of our customer’s problems come from XP users), it prevents us from upgrading to .NET 4.5, and using shiny new toys. It’s like we’re stuck in the dark ages. We have almost 10% of our customers still using XP. It’s huge! And about 40% of them seem to never update their software version, even though they are asked to do it at each software startup. That’s a bit depressing. We can’t use the C# async/await keywords, and more and more NuGet packages require this version. I can’t even find how to display a MahApps.Metro dialog box without the async keyword.

Building a .NET application for distribution

We have a Windows (WPF) app distributed to end users (general public).

I am changing the build process to simplify it. It is currently comprised of these steps :

A SVN commit runs a Jenkins build
Jenkins runs a few NAnt scripts
NAnt builds the application through MSBuild
It then launches a custom application that does several things:
1. It downloads a few infos through a webservice, updates a DB, etc
2. It modifies InnoSetup scripts with a few dynamic informations, like the version number
3. It signs the binaries with a SSL certificate
4. It launches the InnoSetup scripts to create the setup packages
5. It signs the setup packages with the SSL certificate
It then changes a few things before running the custom app again, in order to generate a different setup package

That’s quite a complicated and convoluted solution to a not-so-complicated problem. And, most importantly, it uses too much different technologies : I believe both the NAnt scripts and the custom application can be removed from the process.

So, I’m looking for a suitable replacement. I’ve had my eyes on Albacore for a few weeks, which looks very fun, and would allow me to use Ruby, which I might need to learn for later projects. But it has important problems:

It’s very light on documentation: the official wiki documents the V1, but it’s incompatible with the current V2, which is better. You have to look at the sources to see what’s available to you, and how to use it.
Help is hard to come by on the net.
It uses Ruby
- it’s yet another layer in the build stack
- it won’t allow me to get rid of the custom app (good luck updating an Access DB through a SOAP webservice)
- runnig Ruby on Windows is easy, but many gems are not available (some of them very useful)

So now I’m looking at FAKE, which also looks promising. It has the huge advantage of allowing me to easily migrate the custom app (or simply reuse its components), because it’s .NET. But it also has problems:

Documentation does not seem much better, even though I haven’t yet started using it, so maybe it’s enough
Help seems to be even harder to come by, there seems to be even less FAKE questions on Stackoverflow than Albacore
It uses F#, which I don’t know at all, and won’t need in the future, but it’s always interesting to learn a new language (and apparently it’s the new kid on the block in .NET)

That being said, I will try FAKE anyway. It will allow me to remove build layers, and maybe remove the custom app. It will also probably be more easily adopted by the .NET community, especially since Scott Hanselman posted about it a few weeks ago.

Looking from the comments there, if FAKE does not work for me, I might want to try PSake: it’s in PowerShell, wich is a great scripting language, and I know pretty well already.