Coding By My Own Example

Network shares not mapped across UAC boundaries - The code

2013-03-20T12:26:00.003+01:00

This is a short follow up on this blog entry. This is the code for the concept I wrote about in that entry.

Tweaks to make to the source ready for use:

In the RegisterTask project, the file ReMount.xml under triggers there is a commented out line that need to be updated to the correct user. If the user is the one installing the UserId template from the Author tag can be used.

The solution can be downloaded from here.

Network shares not mapped across UAC boundaries

2012-12-12T16:24:00.000+01:00

After upgrading the OS on my workstation from Windows XP to Windows 7 I discovered that, suddenly, some files could not be opened from a network shares that was mapped on my computer when the program was running in elevated mode and the file that I wanted to open was activated by double clicking the item. Also I discovered that when I used the "Open File" dialog from within the program all the network shares that was connected when using Explorer was now marked with a red X indicating that the connection was not established. Selecting the mapped drive would then connect the share and every thing would work as it used to for that share until the next time the computer was rebooted.

This behavior was the effect of being restrained by the UAC introduced in Windows Vista and as an administrator on the computer you actually have two sessions when you are looged on to the system, one elevated an one restricted. These two sessions does not share context, and this also includes what network shares that are mapped and connected. So when you double click a file in Explorer to open it in the associated program, and that program is set to be elevated, then you have a scenario where a program in one context is asking to have a file opened in another context, but the program in the other context does not yet known that the mapped drive exists. Only when the mapped drive has been connected in the other context, i.e. by using the "Open File" dialog and making the drives connect will the context know that the drive is accessible, and this information will last until next time the user needs to perform a new log-on and thus creating new sessions.

After searching the Internet for solutions to this problem, including understating what the underlying problem was, I ended up with two possible solution candidates

The first possible solution was a change in registry as described in this article: Programs may be unable to access some network locations after you turn on User Account Control in Windows Vista or in Windows 7. The problem, in my view, with this solution is that it essentially just removed the security boundary, and then I could just as well turn UAC completely off, plus a change to the registry was needed that was not guaranteed to work going forward. So this method was not really what I wanted, and the search for solutions continued.

As my search continued I got more and more frustrated that there was no apparent solution to this problem and I decided that it should be possible to create some kind of solution that would perform the task of entering the other security context, perform the equivalent of selecting an unconnected network share to get it reconnect.

My reasoning was that explorer is able to show me the shares that are mapped and whether they are connected or not. So I should be able to extract that information as well.

After a lot of digging around I ended up with a solution that uses some parts of Windows Management Instrumentation and some parts of Windows Shell Objects to accomplish the task.

the WMI part is used for querying what shares are mapped, but not necessarily connected and what drive letters is actually used for mounted drives. By comparing the two list I can then determine what shares that are not connected by seeing if the drive letter that is listed in the ManagementObject is also listed in the mounted drives list.

And if the drive is not mounted, and is one of the shared that I want to have mounted I can then use the WSO to mount the share to the requested drive letter.

A question may arise here of why I don't use WMI to map/mount the share as a drive. and the answer is that this was the fasted solution i could find at the time, and possibly not the best.

This fine little application now just needs to be executed once in the other context (the elevated one in this case) and then the world view would be the same for the selected drives on both sides of the security context wall.

Putting the program in the startup folder won't help you here, as Windows will block programs that require elevated privileges to avoid the elevation prompt at startup.

To solve this little dilemma I found out that I could make a scheduled task that would run whenever I logged in that can then elevate the process to the correct context and thus problem solved.

Just To make this solution deployable across the entire department where I work, I created an MSI installer that automatically created the task upon installation and removed on removal of tool, this is accomplished by using custom actions that uses the command line version of schtasks.exe

What is the MSIL PrivateImplementationDetail

2010-09-02T13:57:00.000+02:00

Digging in MSIL
As part of my work I sometimes have to verify that an installer contains only rebuild code for some of the sub modules. To achieve this I use the ildasm.exe tool to decompile the assemblies and then make a text comparison of the IL output.

During examination of the output I encountered some weird IL output that I couldn't directly map to the source code and that was changing every time the code was rebuild even though the source code didn't change. The characteristic of this output was always <privateimplementationdetails>{SOME GUID}.

In an effort to understand what this was I tried googling for any information that could explain what this was and how I could verify that there actually was no source code change. But Google disappointed me and didn't give any answer.

Instead I (and my colleague) started making code samples to get IL code with this <privateimplementationdetails> output. After some binary search in code known to produce this we found the code structure, or at lest one, that could reproduce this.

The following code sample will show you code that both do and don't produce <privateimplementationdetails> in the IL output.

class CharClass
{
    char[] char_1 = new[] { 'a', 'b' };
    char[] char_2 = new[] { 'c', 'd', 'e' };
}

The resulting IL code looks like the following (excluding the meta data).

.class private auto ansi beforefieldinit CharClass
       extends [mscorlib]System.Object
{
  .field private char[] char_1
  .field private char[] char_2
  .method public hidebysig specialname rtspecialname 
          instance void  .ctor() cil managed
  {
    // Code size       55 (0x37)
    .maxstack  4
    .locals init ([0] char[] CS$0$0000)
    IL_0000:  ldarg.0
    IL_0001:  ldc.i4.2
    IL_0002:  newarr     [mscorlib]System.Char
    IL_0007:  stloc.0
    IL_0008:  ldloc.0
    IL_0009:  ldc.i4.0
    IL_000a:  ldc.i4.s   97
    IL_000c:  stelem.i2
    IL_000d:  ldloc.0
    IL_000e:  ldc.i4.1
    IL_000f:  ldc.i4.s   98
    IL_0011:  stelem.i2
    IL_0012:  ldloc.0
    IL_0013:  stfld      char[] CharClass::char_1
    IL_0018:  ldarg.0
    IL_0019:  ldc.i4.3
    IL_001a:  newarr     [mscorlib]System.Char
    IL_001f:  dup
    IL_0020:  ldtoken    field valuetype '<privateimplementationdetails>{F325A222-827B-4DCA-B78A-B2EC85FEBAD3}'/'__StaticArrayInitTypeSize=6' '<privateimplementationdetails>{F325A222-827B-4DCA-B78A-B2EC85FEBAD3}'::'$$method0x6000001-1'
    IL_0025:  call       void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
    IL_002a:  stfld      char[] CharClass::char_2
    IL_002f:  ldarg.0
    IL_0030:  call       instance void [mscorlib]System.Object::.ctor()
    IL_0035:  nop
    IL_0036:  ret
  } // end of method CharClass::.ctor

} // end of class CharClass

.class private auto ansi '<privateimplementationdetails>{F325A222-827B-4DCA-B78A-B2EC85FEBAD3}'
       extends [mscorlib]System.Object
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
  .class explicit ansi sealed nested private '__StaticArrayInitTypeSize=6'
         extends [mscorlib]System.ValueType
  {
    .pack 1
    .size 6
  } // end of class '__StaticArrayInitTypeSize=6'

  .field static assembly valuetype '<privateimplementationdetails>{F325A222-827B-4DCA-B78A-B2EC85FEBAD3}'/'__StaticArrayInitTypeSize=6' '$$method0x6000001-1' at I_00002050
} // end of class '<privateimplementationdetails>{F325A222-827B-4DCA-B78A-B2EC85FEBAD3}'

// =============================================================

.data cil I_00002050 = bytearray (
                 63 00 64 00 65 00)                               // c.d.e.

As it's clear from the IL there is clearly a difference between assigning a char array with 2 and 3 elements. This goes for most value types tested (summary at the end).

Expanding the the search to reference types the following was observed.

class ObjectClass
{
    object[] Object_1 = new[] { new object(), new object() };
    object[] Object_2 = new[] { new object(), new object(), new object() };
}

Results in

.class private auto ansi beforefieldinit ObjectClass
       extends [mscorlib]System.Object
{
  .field private object[] Object_1
  .field private object[] Object_2
  .method public hidebysig specialname rtspecialname 
          instance void  .ctor() cil managed
  {
    // Code size       76 (0x4c)
    .maxstack  4
    .locals init ([0] object[] CS$0$0000)
    IL_0000:  ldarg.0
    IL_0001:  ldc.i4.2
    IL_0002:  newarr     [mscorlib]System.Object
    IL_0007:  stloc.0
    IL_0008:  ldloc.0
    IL_0009:  ldc.i4.0
    IL_000a:  newobj     instance void [mscorlib]System.Object::.ctor()
    IL_000f:  stelem.ref
    IL_0010:  ldloc.0
    IL_0011:  ldc.i4.1
    IL_0012:  newobj     instance void [mscorlib]System.Object::.ctor()
    IL_0017:  stelem.ref
    IL_0018:  ldloc.0
    IL_0019:  stfld      object[] ObjectClass::Object_1
    IL_001e:  ldarg.0
    IL_001f:  ldc.i4.3
    IL_0020:  newarr     [mscorlib]System.Object
    IL_0025:  stloc.0
    IL_0026:  ldloc.0
    IL_0027:  ldc.i4.0
    IL_0028:  newobj     instance void [mscorlib]System.Object::.ctor()
    IL_002d:  stelem.ref
    IL_002e:  ldloc.0
    IL_002f:  ldc.i4.1
    IL_0030:  newobj     instance void [mscorlib]System.Object::.ctor()
    IL_0035:  stelem.ref
    IL_0036:  ldloc.0
    IL_0037:  ldc.i4.2
    IL_0038:  newobj     instance void [mscorlib]System.Object::.ctor()
    IL_003d:  stelem.ref
    IL_003e:  ldloc.0
    IL_003f:  stfld      object[] ObjectClass::Object_2
    IL_0044:  ldarg.0
    IL_0045:  call       instance void [mscorlib]System.Object::.ctor()
    IL_004a:  nop
    IL_004b:  ret
  } // end of method ObjectClass::.ctor

} // end of class ObjectClass

Clearly reference types do not get the same treatment as value types.

What is this <privateimplementationdetails> anyway?
To the best of my knowledge, and this is only an educated guess from what I have observed, these private implementation details are just that. something that the C# compiler does behind your back, presumably to preserve stack usage.

What types get this treatment?
As far as I have observed, again this is not meant to be an exhaustive list, the numeric value types behaves this way. That is byte, sbyte, short, ushort, int, uint, long, ulong, float and double. When using reference types this compiler trick doesn't seem to invoked.

It's also worth noting that even though enums are value types they are treated like reference types in this case. String, known to get special treatment are also just reference types in this case.

When can I expect this behavior from the compiler?
I have only seen the <privateimplementationdetails> been generated by the C# compiler. I have tried making the equivalent code in VB.NET and they just replicate the way C# handles 2 items, by using the stack for each element. In C# I have tried with version 2.0 and 4, both version produces the same IL code.

CLI VS C# and the meaning of cast.

2010-08-31T13:34:00.001+02:00

What is a cast operation actually?
Well, that depends. Do you see the worlds from the C# language or from the CLI world.

This article is based on my experience using C# 3.5 SP1 and I have no idea if it applies to other .NET Language.

I was in a situation where an API call returned an int[] and I needed to use those values with an other API call but as a double[]. Looking at what immediate option the IntelliSense in Visual Studio showed me I found the Cast<t> and thought that this is just what I need for this job.

To my surprise, when running the code a runtime exception of System.InvalidCastException is thrown. My initial thought was why doesn't this work? The Cast<t> comes from the IEnumerable interface, thus if there exists an implicit conversion from one type to the other the cast should be possible. So why ins't it?

Looking at the specifications.
Reading the MSDN entry for IEnumerable.Cast<t> didn't give me any insight to why this didn't work

The C# Language Specification 7.6.6 defines the cast expression (T)E to be an explicit conversion(so this is why I think the name Cast<T> sucks).
Also 6.1.2 specifies a list if allowed implicit conversions.

Looking at ECMA-335 chap 8.3.3 could explain why they have made this particular implementation.

Unlike coercion, a cast never changes the actual type of
an object nor does it change the representation. Casting preserves the identity of objects.

Searching around on the Internet it does looks like it has worked as I would expect from the name (From C# definition) before 3.5 sp1
For instance this article.

Cast<t> for IEnumerable should really be Unbox<t> or something similar to make it visible that you can only perform this on objects that are in the same line of inheritance.

Ways around this technical implementation detail
To find out how to get the wanted result I tried to think of ways to implement the wanted behavior and then time the time it takes to see what is the best way. I tried to make a generic approach as to find any other limitations that the different implementations might have.

I found 5 approaches that could be feasible:

An implicit cast using the Array.CopyTo method.
The IEnumerable.Cast<T> (Just to make sure it wasn't just my specific case that made problems).
Use a LINQ query with Convert.ChangeType.
Use Array.ConvertAll with Convert.ChangeType.
Use Convert.ChangeType directly on the arrys.

That resulted in the following code:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace TransformArrays
{
    class Program
    {
        private static void DoImplcitConversion<T1, T2>(T1[] fromArray, out T2[] toArray)
        {
            code = Code.ImplcitWithArray_CopyTo;
            Console.WriteLine("Implicit conversion from {0}[] to {1}[] using Array.CopyTo with {2} elemets", typeof(T1).Name, typeof(T2).Name, fromArray.Length);
            try
            {
                Stopwatch watch = StartNew();
                toArray = new T2[fromArray.Length];
                fromArray.CopyTo(toArray, 0);
                StopStopwatch(watch);
            }
            catch
            {
                toArray = null;
                Console.WriteLine(ExceptionMgs);
            }
        }

        private static void DoChangeType<T1, T2>(T1[] fromArray, out T2[] toArray)
        {
            code = Code.ChangeTypeOnArrays;
            Console.WriteLine("Convert.ChangeType from {0}[] to {1}[] using Array.CopyTo with {2} elemets", typeof(T1).Name, typeof(T2).Name, fromArray.Length);
            try
            {
                Stopwatch watch = StartNew();
                toArray = (T2[])System.Convert.ChangeType(fromArray, typeof(T2[]));
                StopStopwatch(watch);
            }
            catch
            {
                toArray = null;
                Console.WriteLine(ExceptionMgs);
            }
        }

        private static void DoCast<T1, T2>(T1[] fromArray, out T2[] toArray)
        {
            code = Code.Cast;
            Console.WriteLine("Using IEnumerable.Cast<> to change from {0}[] to {1}[] with {2} elemets", typeof(T1).Name, typeof(T2).Name, fromArray.Length);
            try
            {
                Stopwatch watch = StartNew();
                toArray = fromArray.Cast<t2>().ToArray();
                StopStopwatch(watch);
            }
            catch
            {
                toArray = null;
                Console.WriteLine(ExceptionMgs);
            }
        }

        private static void DoConversionWithLambdaAndLinq<T1, T2>(T1[] fromArray, out T2[] toArray)
        {
            code = Code.Linq_SelectWithChangeType;
            Console.WriteLine("Using IEnumerable<>.Selectx => ({1})Convert.ChangeType(x, typeof({1}))).ToArray() to change from {0}[] to {1}[] with {2} elemets", typeof(T1).Name, typeof(T2).Name, fromArray.Length);
            try
            {
                Stopwatch watch = StartNew();
                toArray = fromArray.Select(x => (T2)Convert.ChangeType(x, typeof(T2))).ToArray();
                StopStopwatch(watch);
            }
            catch
            {
                toArray = null;
                Console.WriteLine(ExceptionMgs);
            }
        }
        
        private static void DoConversionWithLambdaAndArrayConvert<T1, T2>(T1[] fromArray, out T2[] toArray)
        {
            code = Code.Array_ConvertAllWithChangeType;
            Console.WriteLine("Using Array.ConvertAll<>(Input, x => ({1})Convert.ChangeType(x, typeof({1}))) to change from {0}[] to {1}[] with {2} elemets", typeof(T1).Name, typeof(T2).Name, fromArray.Length);
            try
            {
                Stopwatch watch = StartNew();
                toArray = Array.ConvertAll(fromArray, x => (T2)Convert.ChangeType(x, typeof(T2)));
                StopStopwatch(watch);
            }
            catch
            {
                toArray = null;
                Console.WriteLine(ExceptionMgs);
            }
        }

         /******************************************************************************
         *                                                                             *
         *                Code below is for running the examplas and                   *
         *                        collecting data code only.                           *
         *                                                                             *
         ******************************************************************************/

        enum Code { ImplcitWithArray_CopyTo, Cast, Linq_SelectWithChangeType, Array_ConvertAllWithChangeType, ChangeTypeOnArrays };
        enum FromTo { IntDouble, DoubleInt }

        static int Iterations = 25;
        static Code code = Code.ImplcitWithArray_CopyTo;
        static FromTo fromTo = FromTo.IntDouble;
        static string TimerMgs = "Execution took {0}" + Environment.NewLine;
        static string ExceptionMgs = "Exception thrown" + Environment.NewLine;
        static Dictionary<FromTo, Dictionary<Code, TimeSpan>> timeCollection = new Dictionary<FromTo, Dictionary<Code, TimeSpan>>();
        static double[] doubles = Enumerable.Range(1, 10000000).Select(x => (double)x).ToArray();
        static int[] ints = Enumerable.Range(1, 10000000).ToArray();

        static void Main(string[] args)
        {
            for (int i = 0; i < Iterations; i++)
            {
                Console.WriteLine("round {0}", i + 1);
                FromIntToDouble();
                Console.WriteLine();
                FromDoubleToInt();
            }

            foreach (var ft in timeCollection.Keys)
            {
                foreach (var c in timeCollection[ft].Keys)
                {
                    Console.WriteLine("{0}, {1} : {2}", ft.ToString(), c.ToString().PadRight(8, ' '), timeCollection[ft][c].TotalMilliseconds / Iterations);
                }
            }
        }

        private static void FromDoubleToInt()
        {
            fromTo = FromTo.DoubleInt;
            int[] ints = null;
            DoImplcitConversion<double, int>(doubles, out ints);
            DoCast<double, int>(doubles, out ints);
            DoConversionWithLambdaAndLinq<double, int>(doubles, out ints);
            DoConversionWithLambdaAndArrayConvert<double, int>(doubles, out ints);
            DoChangeType<double, int>(doubles, out ints);
        }

        private static void FromIntToDouble()
        {
            fromTo = FromTo.IntDouble;
            double[] doubles = null;
            DoImplcitConversion<int, double>(ints, out doubles);
            DoCast<int, double>(ints, out doubles);
            DoConversionWithLambdaAndLinq<int, double>(ints, out doubles);
            DoConversionWithLambdaAndArrayConvert<int, double>(ints, out doubles);
            DoChangeType<int, double>(ints, out doubles);
        }

        public static Stopwatch StartNew()
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            return sw;
        }

        public static void StopStopwatch(Stopwatch sw)
        {
            sw.Stop();
            Console.WriteLine(TimerMgs, sw.Elapsed);
            if (!timeCollection.ContainsKey(fromTo))
            {
                timeCollection.Add(fromTo, new Dictionary<Code, TimeSpan>());
            }

            if (!timeCollection[fromTo].ContainsKey(code))
            {
                timeCollection[fromTo].Add(code, new TimeSpan());
            }
            timeCollection[fromTo][code] += sw.Elapsed;
        }
    }
}

Benchmark results
I have tried making some benchmark of the different way of converting by making large arrays of 10.000.000 item and convert the data into another type 25 times.

This is the results

|-------------------------------------------|
|              |  double->int | int->double |
|--------------+--------------+-------------|
| Implcit      |       N/A    |      145 ms |
|--------------+--------------+-------------|
| ConvertAll   |      2015 ms |     1659 ms |
|--------------+--------------+-------------|
| Select       |      3003 ms |     2568 ms |
|--------------+--------------+-------------|
| Cast>T<      |       N/A    |      N/A    |
|--------------+--------------+-------------|
| Array Change |       N/A    |      N/A    |
|-------------------------------------------|

A little caution note on chaining compound assignment.

2010-07-08T11:36:00.002+02:00

First of, what is a compound assignment.? A compound assignment is when you use an operator in conjunction with the assignment operator

a += b; // The same as a = a + b

Now consider that you want to write a swap routine using XOR

a=a^b;
b=a^b;
a=a^b;

this could be transformed to compound operators

a^=b;
b^=a;
a^=b;

If you haven't read the spec on how assignments works, you would think that chaining these operators would be the same

a^=b^=a^=b;

But you will be surprised to learn that the latter two pieces of code behave differently.

Chapter 7.16.2 in the C# specification explains what is going on. When using the compound operator the left side operand is evaluated only once. this means in practice that when you chain the operators like in the last example, then all the left side operands are evaluated before any execution, thus the chain doesn't get the intermediate a and b updated as when you make it line by line.

Why is my static constructor not called?

2010-03-16T14:19:00.001+01:00

In an effort to streamline the use of some utility code that we use for our different products I learned a lesson that I think not many programmers think about. And that is how the compiler, IntelliSense, inheritance and static methods work together.

The problem that I encountered was the following:
The utility code contains a print method that will traverse any object and print it out.
The print method has a bunch of overloads for various formatters and other stuff (this is not included in the sample code as this is trivial).
There exists other utility code that derives from the basic utility code to handle known objects in a non-generic way.
These derived utility methods should have all the overloads that only act as proxies for the real print implementation, available without the need for making signature hiding with the new keyword to get the right method called.
Any changes to the code must not break any old code using this utility code.

My starting point was code that looks like this:

namespace before
{
    using System;
    public class UtilClass
    {
        public static void Print(object data)
        {
            Print(data, true, 0);
        }

        public static void Print(object data, bool recurse)
        {
            Print(data, true, 0);
        }

        protected static void Print(object data, bool recurse, int depth)
        {
            Console.WriteLine(string.Format("Base class with data {0}", data));
        }
    }

    public class SpecificClass : UtilClass
    {
        new public static void Print(object data)
        {
            Print(data, true, 0);
        }

        new public static void Print(object data, bool recurse)
        {
            Print(data, true, 0);
        }

        new protected static void Print(object data, bool recurse, int depth)
        {
            Console.WriteLine(string.Format("Derived class with data {0}", data));
            UtilClass.Print(data, recurse);
        }
    }

    public class Program
    {
        static void Main()
        {
            UtilClass.Print("Call to Base");
            SpecificClass.Print("Call to Derived");
        }
    }
}

As you can see, all methods are static, and I thought that, hey, why not make some sort of Singleton implementation which is controlled by the specific utility implementation and make a virtual print method that gets called by the static code and can then be overridden by any of the specific implementations, as the execution context will always be only one of the specific implementations, this should not introduce any conflicts. Only one specific implementation would be active at a time.

So I made some changes to the original code and was quite surprised with what happened. The code looked like this:

namespace intend
{
    using System;

    public class UtilClass
    {
        protected static UtilClass instance = new UtilClass();
        public static void Print(object data)
        {
            instance.Print(data, true, 0);
        }

        public static void Print(object data, bool recurse)
        {
            instance.Print(data, recurse, 0);
        }

        protected virtual void Print(object data, bool recurse, int depth)
        {
            Console.WriteLine(string.Format("Base class with data {0}", data));
        }
    }

    public class SpecificClass : UtilClass
    {
        static SpecificClass()
        {
            instance = new SpecificClass();
        }

        protected override void Print(object data, bool recurse, int depth)
        {
            Console.WriteLine(string.Format("Derived class with data {0}", data));
            base.Print(data, true, 0);
        }
    }

    public class Program
    {
        static void Main()
        {
            UtilClass.Print("Call to Base");
            SpecificClass.Print("Call to Derived");
        }
    }
}

That's it, make the working methods to a virtual and an override, introduce an instance reference and make the type constructor update the instance reference to point to an object of the correct type. Remove the old overload methods from the specific implementation

What would you expect the outcome of the code from main is?

Base class with data Call to Base
Derived class with data Call to Derived
Base class with data Call to Derived

Base class with data Call to Base
Base class with data Call to Derived

If you guessed the second output, then you are correct. And the reason: The type constructor for SpecificClass is never executed.

Why? Well the compiler makes some interpreting on the code, before spitting out IL. What the compiler sees is that the call to SpecificClass.Print is in fact a call to UtilClass.Print and will substitute the type, thus a reference to SpecificClass no longer exists, and the type constructor will never be called.

My final solution ended up being that I need to swallow the hit for the existing overloads and force any new code not to use these overloads by marking them obsolete.

The singleton idea is still valid, but I was not able to make the automatic selection of which flavor of the specialized class to use work with this way of implementing it.

The solution builds on a base class which has all the static void Print() overloads that is desired which work as proxies to the protected virtual instance method, and a protected singleton instance of itself for the proxies to call. Any existing derived classes will then have to stub out the already implemented static void print() with a setting of the flavor to a type of itself, and then calling the Print() on the instance. The end result looks a little something like this:

namespace Solution
{
    using System;

    public class UtilClass
    {
        protected static UtilClass instance = new UtilClass();

        public static void SetFlavor(T type) where T : UtilClass
        {
            UtilClass.instance = type;
        }

        public static void Print(object data)
        {
            instance.Print(data, true, 0);
        }

        public static void Print(object data, bool recurse)
        {
            instance.Print(data, recurse, 0);
        }

        protected virtual void Print(object data, bool recurse, int depth)
        {
            Console.WriteLine(string.Format("Base class with data {0}", data));
        }
    }

    public class SpecificClass : UtilClass
    {
        new public static void Print(object data)
        {
            SpecificClass.SetFlavor(new SpecificClass());
            (instance as SpecificClass).Print(data, true, 0);
        }

        new public static void Print(object data, bool recurse)
        {
            SpecificClass.SetFlavor(new SpecificClass());
            (instance as SpecificClass).Print(data, true, 0);
        }

        protected override void Print(object data, bool recurse, int depth)
        {
            Console.WriteLine(string.Format("Derived class with data {0}", data));
            base.Print(data, true, 0);
        }
    }

    public class Program
    {
        static void Main()
        {
            UtilClass.Print("Call to Base");
            SpecificClass.SetFlavor(new SpecificClass());
            SpecificClass.Print("Call to Derived");
        }
    }
}

If you have a more elegant solution than this, I would be happy se see your suggestion in the comments.

Some of the reading material I have read through to solve this mystery.

http://www.yoda.arachsys.com/csharp/beforefieldinit.html

http://ondotnet.com/pub/a/dotnet/2003/07/07/staticxtor.html

http://bytes.com/topic/c-sharp/answers/258322-static-constructor-derived-class

http://bytes.com/topic/c-sharp/answers/496182-invoking-static-constructors-base-classes

Getting SyntaxHighlighter to work with Blogger.com

2010-01-27T10:13:00.005+01:00

Just a quick guide to get SyntaxHighlighter to work with Blogger.com
Step 1 - Get the code:
Download the source from here.

Step 2 - Change the JavaScript:
src/shCore.js
On line 99:
I found these flags, which I turned on.

/** Blogger mode flag. */

bloggerMode : true,

stripBrs : true,

And after line 1198 I added the following line of code

code.replace(//gi,'\n')

Step 3 - Host the script:
Find somewhere to host the SyntaxHighlighter code on the net.

Step 4 -
Setup:
Follow the guide to setup.
When adding the link ans script references you need to change the HTML of the template. As the last part of the <head> section add the following

<script src='http://YOURHOST/src/shCore.js' type='text/javascript'/>
<script src='http://YOURHOST/scripts/shBrushCSharp.js' type='text/javascript'/>
<script src='http://YOURHOST/scripts/shBrushXml.js' type='text/javascript'/>
<link href='http://YOURHOST/styles/shCore.css' rel='stylesheet' type='text/css'/>
<link href='http://YOURHOST/styles/shThemeDefault.css' rel='stylesheet' type='text/css'/>
<script type='text/javascript'>
SyntaxHighlighter.config.clipboardSwf = 'http://YOURHOST/scripts/clipboard.swf';
SyntaxHighlighter.all();
</script>

As you ca see I have added the cSharp and Xml brush, but you can change that to your own needs.

Step 5 - Embed code in your posts.
Now you can embed code snippets into you posts using the script tag:

<script type="syntaxhighlighter" class="brush: js"><![CDATA[
]]></script>

When you can't trust the stack trace

2009-09-18T15:24:00.018+02:00

Disclaimer: This article is for x86 Jit compiler Only.

Why did I notice that the stack trace was different from what was expected?
We have an abstract base class that our test script derive from, which provides all the necessary functionality to make the logging of data transparent for the script author. To put data into the log (database, file, whatever) the script just invoke the log method from the base class and it will then find out from where that method came from based on the information on the stack.

The problem that I encountered was that we have some methods that only acts as proxies and thus are very small, e.i. 2-3 lines of code, with one being the call to the log method. These methods where in-lined, thus giving some strange data.

When is code in-lined?
To answer when the JIT compiler does not in-line code, and thus also indicated when it might in-line code, here is an excerpt from David Notario's WebLog (link)

These are some of the reasons for which we won't inline a method:

Size of inlinee is limited to 32 bytes of IL

Method is marked as not inline with the CompilerServices.MethodImpl attribute.

Virtual calls

Call targets that are in MarshalByRef classes won't be inlined

VM restrictions

loops, methods with exception handling regions, etc...

Other: Exotic IL instructions, security checks that need a method frame, etc...

Why does the release build have the full call stack in VS
If you try to debug this behavior by setting the configuration manager to "Release" and run the executable from within Visual Studio, you will notice that the stack looks just as if it was run in "Debug". This is because that VS has its own host process (vshost.exe) that starts up the CLR which tells the JIT'er not to in-line code.

The code below gives an example on what the problem is:

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;

class Program
{
 public Program()
 {
  NotInlined();
  Attribute();
  Inlined();
 }

 private void NotInlined()
 {
  try
  {return;}
  finally
  {CallerID();}
 }

 [MethodImpl(MethodImplOptions.NoInlining)]
 private void Attribute()
 {
  CallerID();
 }

 private void Inlined()
 {
  CallerID();
 }

 protected void CallerID()
 {
  StackTrace st = new StackTrace(true);
  StackFrame sf = st.GetFrame(1);
  Console.WriteLine("Caller is: " + sf.GetMethod().Name);
 }

 static void Main(string[] args)
 {
  new Program();
 }
}

Running the debug and release builds from the command line the gives the following:

output from a Debug build:

Caller is: NotInlined
Caller is: Attribute
Caller is: Inlined

And output from a Release build:

Caller is: NotInlined
Caller is: Attribute
Caller is: .ctor

Reading Data From OpenXML Spreadsheets

2009-07-16T13:11:00.027+02:00

During one of my assignments I had the task to read information out of a spreadsheet created with Excel 2007 (.xlsx). I choose to use the Open XML Format SDK 2.0 (april 2009 ctp) to read data from the spreadsheet.

As I Googled for the standard way of retrieving data of different type from individual cells I could not find how to interpret data from a cell with the format of "tt:mm:ss" but could not find any information on how to do it.

So after a little debugging looking into what the different cells looked like when different types of data was put into the cells I creates a small piece of code describing what to do.

Even though the example code doesn't look like it, every cell can have a style index, which also describes things like alignment and borders. But describing that will be a post of it's own if I even needs to figure out how to do that.

using (SpreadsheetDocument spreadsheet = SpreadsheetDocument.Open(Path, false))
{
    WorkbookPart wb = spreadsheet.WorkbookPart;
    List<cellformats> formats = new List<cellformats>(wb.WorkbookStylesPart.Stylesheet.Descendants<cellformats>());
    foreach (var sheet in wb.Workbook.Descendants<sheet>())
    {
        WorksheetPart wp = (WorksheetPart)spreadsheet.WorkbookPart.GetPartById(sheet.Id);
        SharedStringTablePart sstp = wb.GetPartsOfType<sharedstringtablepart>().First();
        SharedStringItems = sstp.SharedStringTable.Elements<sharedstringitem>().ToArray();
        foreach (var row in wp.Worksheet.Descendants<row>())
        {
            List<cell> cells = new List<cell>(row.Descendants<cell>());
            for (int i = 0; i < cells.Count; i++)
            {
                if (cells[i].CellValue == null)
                {
                    // What ever to to if data is null
                }
                else
                {
                    if (cells[i].DataType != null &&
                    cells[i].DataType.HasValue &&
                    cells[i].DataType.Value == CellValues.SharedString)
                    {
                        // look up the actual string value in the shared string table
                        SharedStringItem ssi = SharedStringItems[int.Parse(cells[i].CellValue.Text)];
                        // Do what you please with the string
                    }
                    else if (cells[i].StyleIndex != null &&
                    cells[i].StyleIndex.HasValue)
                    {
                        // look up the style used for the cell
                        int formatStyleIndex = Convert.ToInt32(cells[i].StyleIndex.Value);
                        CellFormat cf = formats[0].Descendants<cellformat>().ToList()[formatStyleIndex];

                        // now you can check the NumberFormatId
                        if (cf.NumberFormatId == 21) // 21 is the “tt:mm:ss” format
                        {
                            // and the culture seem to be english-US 
                            System.Globalization.CultureInfo ci = new System.Globalization.CultureInfo("EN-US");
                            // one second is
                            double second = Convert.ToDouble("1.1574074074074073E-5", ci.NumberFormat);
                            // get what’s in the cell
                            CellValue customValue = cells[i].CellValue;
                            // convert that value to a double
                            double cellSeconds = Convert.ToDouble(customValue.InnerText, ci.NumberFormat);
                            // and calculate the total amount of seconds
                            // this is an integer to compensate for the small deviation that can occur with doubles
                            int totalSeconds = (int)(cellSeconds / second);
                            // and from that you can make a TimeSpan representing “tt:mm:ss:”
                            TimeSpan ts = new TimeSpan(0, 0, totalSeconds);
                        }
                        else if (cf.NumberFormatId == 0) // 0 seems to be just a number
                        {
                            // Do stuff
                        }
                    }
                }
            }
        }
    }
}