The best result that can be achieved using mstest is a single testcase that will iterate through the dataset. There is one disadvantage: if the test fails for one entry in the dataset, the whole test case fails.

So, in order to overcome the previously mentioned limitation, I decided to create a text template that will generate the test cases for me. As an example, I will write some tests for an integer multiplication function that has 2 bugs in it:

public int Multiply(int a, int b)
{
    //This conditions are simulating the 2 bugs
    if (a == 0 && b == 1)
        return 100;
    if (a == 1 && b == 0)
        return -100;
    return a * b;
}

The classical approach (no dynamic test)

Without using any ‘hacks’, one could write the tests for the Multiply function in the following way:

//Tuple description <value of param a, value of param b, expected result>
private static readonly Tuple<int, int, int>[] TestData = new Tuple<int, int, int>[]{
    new Tuple<int, int, int>(0,0,0),
    new Tuple<int, int, int>(2,3,6),
    new Tuple<int, int, int>(1,0,0), //These will trigger one of the bugs
    new Tuple<int, int, int>(-2,-3,6),
    new Tuple<int, int, int>(0,1,0) //These will trigger one of the bugs
};
[TestMethod]
public void TestMultiply()
{
    foreach (var data in TestData)
    {
        Assert.AreEqual(data.Item3, Multiply(data.Item1, data.Item2),
                        "Failed for input ({0}, {1})", data.Item1, data.Item2);
    }
}

Running the test will surface only one of the bugs, the one triggered by the input (1,0):

This is not only bad because it doesn’t give a complete overview of the bugs but it also violates the principle of one assertion per test because more than one assertion could be triggered in the test case above.

The T4 approach (dynamic test)

A text templates, from MSDN:

… is a mixture of text blocks and control logic that can generate a text file. The control logic is written as fragments of program code in Visual C# or Visual Basic. The generated file can be text of any kind, such as a Web page, or a resource file, or program source code in any language. Text templates can be used at run time to produce part of the output of an application. They can also be used for code generation, in which the templates help build part of the source code of an application.

Text templates are invoked before compilation in order to generate some code that will be used in the compilation process. Preprocessed text templates are used to generate templates that can be invoked at runtime in order to generate new files. I am going to use the former one.

So, the goal is to have one assertion per test and show all bugs. For this, different test cases, for each input, are needed. A possible approach would be to write manually each test:

[TestMethod]
public void TestMultiply_Input_0_0()
{
    TestMultiply(0, 0, 0);
}
[TestMethod]
public void TestMultiply_Input_2_3()
{
    TestMultiply(2,3,6);
}
[TestMethod]
public void TestMultiply_Input_1_0()
{
    TestMultiply(1, 0, 0);
}
[TestMethod]
public void TestMultiply_Input_Minus2_Minus3()
{
    TestMultiply(-2, -3, 6);
}
[TestMethod]
public void TestMultiply_Input_0_1()
{
    TestMultiply(0, 1, 0);
}
public void TestMultiply(int a, int b, int expected)
{
    Assert.AreEqual(expected, Multiply(a, b), "Failed for input ({0}, {1})", a, b);
}

While this approach doesn’t violate the two principles above, it creates a code that is hard to maintain and is a pain to write it for many inputs. Just imagine having 100 tuples in the dataset. The result is the expected one:

A smarter approach is to generate all those test methods. Can you see the pattern they follow?

• The title of the method is composed of the string “TestMultiply_Input_” followed by the first input value, followed by the string “_” and then followed by the second input value
• The body of the method is made by a call to a generic test method (TestMultiply) using the two input values and the expected result
• For negative values, the minus sign is replaced by the literal “Minus”

So, a text template (not a preprocessed text template!) can be written to the test cases. It can be added to a Visual Studio 2010 project by adding a new item of type “Visual C# Items\General\Text Template”. I will name the file “GeneratedTestCases.tt” and the generated code file will be “GeneratedTestCases.generated.cs”.

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".generated.cs" #>
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Tests
{
    [TestClass]
    public class MultiplicationTests
    {
<#
//Tuple description <value of param a, value of param b, expected result>
Tuple<int, int, int>[] TestData = new Tuple<int, int, int>[]{
    new Tuple<int, int, int>(0,0,0),
    new Tuple<int, int, int>(2,3,6),
    new Tuple<int, int, int>(1,0,0), //These will trigger one of the bugs
    new Tuple<int, int, int>(-2,-3,6),
    new Tuple<int, int, int>(0,1,0) //These will trigger one of the bugs
};
foreach (var data in TestData)
{
#>
		[TestMethod]
		public void TestMultiply_Input_<#= data.Item1.ToString().Replace("-", "Minus") #>_<#= data.Item2.ToString().Replace("-", "Minus") #>()
		{
			TestMultiply(<#= data.Item1 #>, <#= data.Item2 #>, <#= data.Item3 #>);
		}
<#
}
#>
		public void TestMultiply(int a, int b, int expected)
        {
            Assert.AreEqual(expected, Multiply(a, b), "Failed for input ({0}, {1})", a, b);
        }
	//Just write this method here. In reality, this method will be somewhere else
	public int Multiply(int a, int b)
        {
            //This conditions are simulating the 2 bugs
            if (a == 0 && b == 1)
                return 100;
            if (a == 1 && b == 0)
                return -100;
            return a * b;
        }
    }
}

This text template will generate the test class. It looks quite ugly and writing it is not trivial because there is not intellisense or syntax coloring in Visual Studio.

Let me explain what it does:

1. All the text that is not between <# #>, <#@ #> or <#= #> is just copied to the output file (ex: lines 3-12)
2. Line 2 specifies the extension of the output file
3. Code between <# #> is C# code and will be executed at generation time
4. Code between <#= #> is C# code, will be executed at generation time and it’s output will be written to the generated file. It must be a single statement returning a non void value.
5. For each tuple in the data set, a test method is written to the output file.

It can be improved a little by working with partial classes. Instead of writing all the code in the tt file, the C# code can be placed in a cs file. So, I’ll do some changes to the tt file by removing the last methods and making the class partial:

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".generated.cs" #>
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Tests
{
    [TestClass]
    public partial class MultiplicationTests
    {
<#
//Tuple description <value of param a, value of param b, expected result>
Tuple<int, int, int>[] TestData = new Tuple<int, int, int>[]{
    new Tuple<int, int, int>(0,0,0),
    new Tuple<int, int, int>(2,3,6),
    new Tuple<int, int, int>(1,0,0), //These will trigger one of the bugs
    new Tuple<int, int, int>(-2,-3,6),
    new Tuple<int, int, int>(0,1,0) //These will trigger one of the bugs
};
foreach (var data in TestData)
{
#>
		[TestMethod]
		public void TestMultiply_Input_<#= data.Item1.ToString().Replace("-", "Minus") #>_<#= data.Item2.ToString().Replace("-", "Minus") #>()
		{
			TestMultiply(<#= data.Item1 #>, <#= data.Item2 #>, <#= data.Item3 #>);
		}
<#
}
#>
    }
}

Then, create a class called “MultiplicationTests” that is also partial and contains the methods removed from the tt file:

using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Tests
{
    partial class MultiplicationTests
    {
        public void TestMultiply(int a, int b, int expected)
        {
            Assert.AreEqual(expected, Multiply(a, b), "Failed for input ({0}, {1})", a, b);
        }
        //Just write this method here. In reality, this method will be somewhere else
        public int Multiply(int a, int b)
        {
            //This conditions are simulating the 2 bugs
            if (a == 0 && b == 1)
                return 100;
            if (a == 1 && b == 0)
                return -100;
            return a * b;
        }
    }
}

Now regenerate the template and compile.

Conclusion

The presented approach is good and definetely has some advantages but is not perfect. Here are some dissadvantages:

• Text Template editor, in VS, is just plain text with not syntax coloring or intellisense
• The compilation errors are sometime ambiguous
• Debugging a text template is something you would like to avoid :)
• For a few test cases, more code is written
• In case of new test cases, the code must be recompiled

Advantages:

• Shows more bugs earlier
• Allows one assertion per test even for large data sets
• The code is compiled and not evaluated at runtime (maybe there is a performance gain)
• Less manual code duplication

Advice: try to write as less code as possible in the tt file. Move as much as possible to cs files. Any assembly, except the one in which the tt file is, can be referenced at generation time.

If you have troubles going through this tutorial, download the complete C# project: T4_mstest (3.56 kB)

Create a fancy-looking application that displays the preview of the open applications.

• Enumerating windows and getting various information about them
• Creating the Aero glass effect
• Using the DWM windows preview feature

• Windows Vista/7 with the Aero theme active
• Visual Studio 2010 (or 2008 but requires some changes in code which are not covered by this tutorial)

TaskSwitcher (13.07 KB)

The basic idea behind this application is the following: upon start, we create snapshot (a list) of all the available windows and we use it to decide what previews to display. Once the list is created, a preview is drawn for each item. There is a drawback for this approach: if new windows are created or some existing are closed the interface will not display them (actually for closed windows will replace the preview with an icon). The advantage: is a simple implementation.

There are three parts for this project.

1. Enumerating only the open applications’ windows
2. Make a glass window
3. Generate a live preview for each window

Enumerating windows

Enumerating all windows can be done with the EnumWindows function from user32.dll which can be easily imported in C#.

[DllImport("user32.dll")]
private static extern int EnumWindows(EnumWindowsCallbackDelegate callback, int lParam = 0);
private delegate bool EnumWindowsCallbackDelegate(IntPtr hWnd, int lParam);

However, the result of a pure enumeration will return hundreds of windows. The most powerful filtration is to keep just the windows that are visible. Again, a function from user32.dll called IsWindowVisible is used to check whether a hWnd belongs to a visible window. Probably, after this step you will have just 30-40 windows left in the list.

[DllImport("user32.dll")]
private static extern bool IsWindowVisible(IntPtr hWnd);

The next step is to decide which is the most meaningful representative window from each cluster of windows related by ownership. The Old New Thing blog presents an algorithm for this problem. The logic behind this algorithm is: “For each visible window, walk up its owner chain until you find the root owner. Then walk back down the visible last active popup chain until you find a visible window. If you’re back to where you’re started, then put the window in the Alt+Tab list.” A few Dll imports and the translation of the pseudocode to C# gives the following code.

private static bool IsWindowChainVisible(IntPtr hWnd)
{
    // Start at the root owner
    IntPtr hwndWalk = GetAncestor(hWnd);
    // Basically we try get from the parent back to that window
    IntPtr hwndTry;
    while ((hwndTry = GetLastActivePopup(hwndWalk)) != hwndTry)
    {
        if (IsWindowVisible(hwndTry)) break;
        hwndWalk = hwndTry;
    }
    return (hwndWalk == hWnd);
}

At this point you probably filtered most windows. However, there are still a few that refuse to be filtered out:

1. The desktop window
2. Our application window
3. The taskbar

Removing the desktop window

Depending on what you want to do, you may decide to keep this window. The task switcher in Windows 7 provides also the preview for the desktop. However, if you decide to to remove it, you have the check each handle against the desktop handle (which can be obtained using the GetShellWindow from user32.dll).

[DllImport("user32.dll")]
private static extern IntPtr GetShellWindow();

Removing our application window

One naive approach would be to ignore the windows with a specific title. This is bad because many windows can have the same title. The correct approach is to filter based on the window handle. I created a list of ignored handled and, after the main window was created, I added its handle in this list. Because WPF is used, the handle of a window can be obtained using WindowInteropHelper class.

Removing the taskbar

This was tricky and I’m still not sure is the correct approach. There is one window in the list that is not filtered by the previous filters. Even more, is not visible with Spy++ (!!!) and it’s preview is the taskbar. The only solution I found and seems to remove just that window, is to filter out all windows that don’t have the WS_EX_APPWINDOW style. If you find any window that is not displayed because of this, let me know.

Finally, the method that decides which window goes into the snapshot is presented below:

//This function will be called for each available window
private bool EnumWindowsCallback(IntPtr hWnd, int lParam)
{
    bool IsDesktopWindow = (hWnd == GetShellWindow());
    bool IsVisible = IsWindowVisible(hWnd);
    bool IsChainVisible = IsWindowChainVisible(hWnd);
    bool IsInIgnoreList = (WindowHandlesToIgnore.Contains(hWnd));
    //Filters the taskbar
    bool IsApplicationWindow = ((GetWindowLong(hWnd) & WS_EX_APPWINDOW) == WS_EX_APPWINDOW);
    if (!IsDesktopWindow && IsVisible && IsChainVisible && !IsInIgnoreList && IsApplicationWindow)
    {
        windowsSnapshot.Add(new WindowInfo(hWnd));
    }
    return true;
}

Once we have a snapshot of the visible windows we plan to display them. As seen in the objective screenshot, the main window is transparent and has a glass effect.

The glass window

It is very important to understand that the glass effect is available only on Windows Vista and 7 and works as long as you have the Aero theme enabled!

The glass effect functions are part of the Desktop Window Manager API represented by the library dwmapi.dll. All the functions were imported from that DLL.

In order to make (a part of) a window transparent you need to:

1. Make the windows background transparent (paint it with a transparent brush)
2. Call the DwmExtendFrameIntoClientArea function specifying the window handle and the inner region of the window that will have the glass effect (you specify the margins from the inner border). If you want the whole window to be transparent specify a negative (-1) margin for all sides.

private void MakeGlassEffect()
{
    if (DwmIsCompositionEnabled())
    {
        IntPtr mainWindowPtr = new WindowInteropHelper(this).Handle;
        HwndSource mainWindowSrc = HwndSource.FromHwnd(mainWindowHandle);
        mainWindowSrc.CompositionTarget.BackgroundColor = Colors.Transparent;
        this.Background = Brushes.Transparent;
        MARGINS margins = new MARGINS();
        margins.ExtendToWholeClientArea(); //Sets all values to -1
        int result = DwmExtendFrameIntoClientArea(mainWindowSrc.Handle, ref margins);
        if (result < 0)
        {
            MessageBox.Show("An error occured while extending the glass unit.");
            Application.Current.Shutdown();
        }
    }
}

Live windows preview

As you might already know, when you press Alt+Tab in Windows Vista/7 (and Aero is active!) you see a live preview of the running applications. In the past, the only method of generating a preview for a window was to copy whatever was visible from it to a bitmap. This approach works as long as the windows is completely visible (no other window is on top, the windows is not out of the screen and the window is not minimized). Trying to save a screenshot with this method will fail, unless you take every window, restore it’s state, bring it to front, take a screenshot and move it back – by the way, this action takes too much time and is messy.

In dwmapi.dll we have a set of functions that will generate thumbnails for any opened window. The interesting part is that the preview is not static! It will modify as the window changes. The function DwmRegisterThumbnail defines a region on which the Desktop Window Manager is allowed to draw the preview for a specific window. So, instead of you drawing the picture, you just specify a region and the DWM will do it for you. One important aspect is that DWM will draw the preview as the top layer – everything on the window will be behind the preview. There are some parameters that you can specify for how the drawing is made (transparency, visibility, etc.) but these are out of the scope of this tutorial.

To ‘translate’ the drawing into code we are first going to check if the window has already registered a preview (if so, unregister it), the register a new preview, set the region of the drawing and center the image and finally draw (update) the preview – which will continue to be updated until is unregistered.

private void DrawThumbnail(WindowInfo win, int thumbnailIndex)
{
    IntPtr thumbnail = win.Thumbnail;
    if (thumbnail != IntPtr.Zero)
        DwmUnregisterThumbnail(thumbnail);
    int hResult = DwmRegisterThumbnail(mainWindowHandle, win.HWnd, out thumbnail);
    if (hResult == 0)
    {
        PSIZE size;
        DwmQueryThumbnailSourceSize(thumbnail, out size);
        DWM_THUMBNAIL_PROPERTIES props = new DWM_THUMBNAIL_PROPERTIES();
        props.dwFlags = DWM_TNP_VISIBLE | DWM_TNP_RECTDESTINATION | DWM_TNP_SOURCECLIENTAREAONLY;
        props.fVisible = true;
        props.fSourceClientAreaOnly = true;
        //Set the region where the live preview will be drawn
        int left = (thumbnailIndex % MaxThumbnails) * (ThumbnailSize + ThumbnailSpacing);
        int top = (int)(thumbnailIndex / MaxThumbnails) * (ThumbnailSize + ThumbnailSpacing) + WindowTopOffset;
        int right = left + ThumbnailSize;
        int bottom = top + ThumbnailSize;
        props.rcDestination = new RECT(left, top, right, bottom);
        //Center the live preview
        if (size.x < size.y)
        {
            double ScaleFactor = ThumbnailSize / (double)size.y;
            int scaledX = (int)(size.x * ScaleFactor);
            int xOffset = (ThumbnailSize - scaledX) / 2;
            props.rcDestination.Left += xOffset;
            props.rcDestination.Right -= xOffset;
        }
        if (size.y < size.x)
        {
            double ScaleFactor = ThumbnailSize / (double)size.x;
            int scaledY = (int)(size.y * ScaleFactor);
            int yOffset = (ThumbnailSize - scaledY) / 2;
            props.rcDestination.Top += yOffset;
            props.rcDestination.Bottom -= yOffset;
        }
        DwmUpdateThumbnailProperties(thumbnail, ref props);
    }
}

For each available window we are going to choose a region in which its preview can be displayed. Basically, the preview region is a grid (filled from left to right, top to bottom) where each cell is a preview.

Known Issues

The application offered as download is not perfect and has a series of inconveniences. They are not big problems but I couldn’t find the time to fix them.

• If the list of available windows is modified, the update is not reflected in the application.
• Previews are no longer centered if you change the size of the window they represent.
• There should be a “glow” effect behind the text on glass in order to be visible on any surface. Just like in the Alt-Tab window.
• If clicking an application in the preview list, the focus is not transferred to it.

If you use Windows Vista/7 then you know that buttons and links which elevate privileges are preceded by a shield icon. This is the way Microsoft decided to inform the user about the effect of clicking that control.

The first idea that might pop up is the reinvention of the wheel (or shield). In other words you could draw the shield on a button. This is OK except that:

1. Is not easy
2. Will require you to recompile the interface if Microsoft decides to change the icon
3. You need the icon in many sizes 16×16, 24×24, 32×32, etc. (extract it from MS’ DLLs)
4. Will create a lot of overhead with layout (position icon relative to text size/position)

The second method is easier, safer and recommended by MS. All you need to do is send a specific message (BCM_SETSHIELD) to the button if the user has limited privileges and pressing that button will trigger the UAC window. Actually there is a second, tricky, thing that must be done: the style of the button must be “System” (in C# “System.Windows.FlatStyle.System”). Without this you will not be able to see the shield.

The code provided in part 1 of this article will be modified in order to display the shield on the two buttons. Moreover, the shield will be displayed only when the user runs under an account with limited privileges or non-elevated administrator.

In order to display the shield one needs to send the BCM_SETSHIELD (=0x0000160C) message to the button. This can be done by using the SendMessage function from user32.dll. This article will not cover what is and how to use SendMessage, if you need more information about it follow the previous link.

To set the shield of the “Elevate this application” button one needs to send the message in the following way:

SendMessage(btnElevate.Handle, BCM_SETSHIELD, 0, 1);

The first parameter is the handle of the button, the second one is the message, the third one is not used and must be ’0′ and the last argument must be non-zero in order to draw the shield, zero otherwise.

If you try this it will not work :) Remember the ‘tricky’ thing told before? This is the full code to display the shield for btnElevate:

btnElevate.FlatStyle = FlatStyle.System;
SendMessage(btnElevate.Handle, BCM_SETSHIELD, 0, 1);

There is only one thing that must be done in order to work properly. Remove the shield if the user has elevated privileges. I don’t know if this is against MS’ recommendation but in my opinion one must not be shown information that cannot be used in that context; in our case don’t show the elevate shield if there is nothing to elevate.

Part 1 described how to check if a user has full rights. Now we are just using that boolean variable:

if (!hasAdministrativeRight)
    SetUACShields();

Where SetUACShields will send the message to all buttons that require the shield drawn.

The full updated code from Part 1: UAC Code 3 (10.13 KB)

1. To show the pages correctly
2. To show as much as possible from a page (to remove the need of scrolling)
3. To provide me with an easy way of accessing pages.

What I don’t like at Firefox

• The search bar is superfluous. I really like what Chrome is doing (and the latest version of Opera?): use the address bar as search bar.
• There is no ad blocker
• There is a lot of wasted space: bookmarks toolbar, menu bar (just think how often you use the top menu), big icons

After a few tweaks I got a browser looking like the one in the picture below that satisfies almost all my needs.

Tweaks applied and how/why to use them

1. Remove the bookmark toolbar. You just don’t need that bar! How often do you click a bookmark? If you need a page opened all the time you just don’t close it. Why do you minimize the working are just to see some buttons that you click them in an infinite small amount of the time you spend in browser? How to apply: right click the menu bar -> Uncheck Bookmarks Toolbar.
2. Remove the menu bar. Just like the bookmark toolbar, you don’t use it to often. If you want to see it just press Alt+F. How to apply: Install the Hide Menubar extension.
3. Merge address bar and search bar. Is not practical to need to think if you want to search or you want to enter an a priori known address. There should be just on input field and the browser should be able to decide if you want to search or go to some specific place. How to apply: First remove the search bar by right clicking the menubar -> Customize and drag the search bar out of the menu. Second navigate to “about:config” and search for “keywork.url”. Replace its value with “http://google.com/search?q=”. This will make Firefox search on Google when it cannot resolve a name.
4. Remove ads. Most of the time you just don’t want to see “Super/Extra/Mega/Ultra discount for X”. Also you don’t want to see links that are on top of the search list just because they paid. How to apply: Install the Adblock Plus extension.
5. Move icons and make them smaller. This is just a personal preference. I want the bookmarks button in the left corner. And in order to maximize working area I want small icons. How to apply: Right click a toolbar -> Customize. Drag/drop the icons you want. For small icons check the appropriate box.
6. Mouse gestures. I like the back button on the toolbar because of the drop down menu but usually I go back by holding the right mouse button and dragging left. The gesture functionality saves a lot of time and movement. How to apply: Install the FireGesture extension.
7. Protect/sync bookmarks. Sometimes one might accidentally delete an important bookmark or, even worse, the entire bookmark collection. Is a good idea to backup bookmarks online. This also gives you the possibility of synchronizing bookmarks across multiple machines. How to apply: Install the Xmarks extension.

Future work

1. Remove the status bar. Currently this cannot be done because there is no other way of knowing where a link is sending. Any suggestion?
2. Remove the tabs bar. The tabs bar should be removed in order to get more space but I have no idea where it could go…

When the C# compiler encounters an #if directive, followed eventually by an #endif directive, it will compile the code between the directives only if the specified symbol is defined. Unlike C and C++, you cannot assign a numeric value to a symbol; the #if statement in C# is Boolean and only tests whether the symbol has been defined or not.

A predefined (by default) symbol on the “Debug” build configuration is DEBUG. Using this symbol you can define code that will be compiled only in Debug; for example, a debug window will be shown only when needed.

using System;
using System.Text;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
#if DEBUG
            Console.WriteLine("Debugging information");
#endif
            Console.WriteLine("Code that always executes");
        }
    }
}

The code above will print “Debugging information” and “Code that always executes” when build on Debug and will display only “Code that always executes” when build on another configuration.

You can suppress the definition of the DEBUG symbol from the project properties or by removing the DEBUG from the build argument “/define:DEBUG”. Also, you can define your own symbols in order to accommodate your needs.

Define as many build configurations and symbols you need but don’t abuse this feature!

• Ask people about the ROM you want to install. Make sure it did not brake any phone.
• The phone’s battery must be at least 50% charged (better 100%)
• Make sure you have and UPS. Or a laptop with good battery because if you cancel the process after it started the results might be unexpected.
• Make sure the USB cable is firmly connect and is not broken!

I cannot be made responsible for any damages caused directly or indirectly by this article.

On PortegeClub.com there is a WM 6.5 ROM Release Candidate for the G900. Because PortegeClub is not always working I uploaded the ROM on my server  and you can download it from this link. It is not the kitchen version (clean version) and it includes some software but it is reasonable and it is not bloated.

The upgrade process is simple:

1. Get the ROM
2. Get SuperRUU
3. Run SuperRUU on a 32 bit Windows machine
4. Select the ROM image and check the “OS” radio button
5. Click “Upgrade target”.
6. Turn off the phone and start it while pressing the left softkey. A red screen should appear informing you that you need USB connection.
7. Connect the phone to the PC running SuperRUU and the upgrade process should start. Do not interrupt it!!! It takes about two minutes.

WM6.5 brings a new startup logo and animation and a lot of other visual changes.

The first thing you will notice after startup is the new redesigned Today screen which supports widgets just like the HTC home screen. It’s aspect is nice but you will find out soon that it cannot be customized. The only item supporting customization is the favorites widget :( Like usual there are widgets for time, messages, calls, pictures and music. Also you can use the classical Today screen items but you will use the eye-candy widgets. What I really enjoyed is that you can scroll through items by moving your finger over the screen in any region not just on the right side – this is a nice addition and also works for menus.

Another major interface change is the start menu. Well it is no longer MENU, it’s a start screen that displays shortcuts to applications and phone settings. They are all arranged in the well-known WM6.5 combs and have a nice aspect. You can also scroll through items with your finger and when you get to the top/bottom of the menu there is a visual bounce effect that creates a realistic sensation. What is hard here is to navigate with the hardware DPad through items because pressing right many times cycles through a “row” of the comb and is not going the lower items. You must use all directions to navigate.

There are some other major visual changes but I don’t have screenshots for them. The first thing is the unlock screen which has an object that must be slide in order to unlock the phone just like on iPhone. The second are the menus that are larger and more “finger-friendly” – you can navigate easily with the finger through them.

On my G900 screen rotation took almost 10 seconds (from portrait to landscape). While using the PDA in landscape the icons seemed crowded, hard to follow and the Today screen was not so good looking.

Because it is not an official release I cannot say it works bad. There could be “unofficial” reasons why this is not working properly. Anyhow, I haven’t seen other major changes except the interface. The problem with interface changes is that you get used to them quickly and then you start to see what is not working. The ringtones are corrupted in this ROM and the SD card is disconnecting after a few hours so I reverted the ROM to a kitchen version of Windows Mobile 6.1 – you should try the 6.5, it’s a nice experience!

However there are some situations when an application cannot be run without administrative rights. For example a system configuration utility requires administrative rights to change some global policies.

In order to force an application to run only if the current user is administrator or can provide administrative credentials you must add a manifest to the C# project.

The manifest is an XML file named <application_name>.exe.manifest with the following content:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
   <assemblyIdentity version="1.0.0.0" processorArchitecture="X86" name="UACApp" type="win32"/>
      <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
      <security>
         <requestedPrivileges>
            <requestedExecutionLevel level="requireAdministrator"/>
         </requestedPrivileges>
      </security>
   </trustInfo>
</assembly>

What is important is the requestedExecutionLevel element. It specifies what permissions (execution level) the application needs in order to start. If the current user does not have the required level then an elevation window is displayed (see part one of the tutorial that describes the elevation window).

The default value of requestedExecutionLevel if it is not specified in the manifest or the manifest does not exist is asInvoker. Except asInvoker and requireAdministrator there is another execution level. All three are described below:

In order to embed the manifest in the aplication’s executable you can choose one of the following options:

1. The hard way – mt.exe

The Mt.exe file is a tool that generates signed files and catalogs. It is available in the Microsoft Windows Software Development Kit (SDK). Mt.exe requires that the file referenced in the manifest be present in the same directory as the manifest.

The manifest will be embedded after a successful build so we need to add this the call of Mt.exe in the post-build event. In order to do this right click the project -> Properties -> Choose “Build Events” from the vertical left tabs.

Mt.exe is found in many places on disk so the path to it might be different on your configuration. The post build command is:

“C:Program FilesMicrosoft.NETSDKv2.0 64bitBinmt.exe” -manifest “$(ProjectDir)$(TargetName).exe.manifest” –outputresource:”$(TargetDir)$(TargetFileName)”;#1

Make sure the paths to mt.exe and the .manifest file are correct. You should get something like this:

This method has a drawback. If you start the application with debugging from Visual Studio it will start with limited privileges. Running without debugging will ask you to elevate the parent process (in our case Visual Studio).

2. The easy way – designer

Just create the manifest file, include it in visual studio, go to the “Application” tab in project’s properties and choose the manifest file from the Manifest combo box.

Build.

This method that has another advantage. Even if running with Debug you will still be prompted to elevate Visual Studio.

The source code can be downloaded below (it is the application from part 1 but includes the manifest file):

Download source

IMPORTANT: This tutorial is useless if you disabled UAC because all you processes (considering you are the administrator) run elevated.

Why should we use this? Most applications DO NOT require full privileges. Think to the applications you have written and ask yourself if most of the job can be done without full writes (if you write to disk think if you could write in the user’s folder or an isolated storage, if writing in registry to HKLM think if you could write to HKLU, etc). The answer is mostly sure “Yes”.

So why run applications with full privileges when they can be run with limited? Running with more privileges than required is just a security vulnerability -  If an attacker exploits a vulnerability in your application he will gain more control.

There are two mistakes developers tend to do:

1. Request the end-user to run an application with full rights even though this is not necessarily (most of the time because of bad design practices)
2. Do not request to user to run the application elevated but try to perform operations that require more rights

By design UAC can only elevate code at process level and only at process’ startup (means that a running process cannot be elevated). In the .NET world this also means that you cannot elevate code running in another app domain because the app domain is part of a running process. In order to elevate an existing application this must be closed and reopen with more privileges.

There are two types on UAC dialogs: blue and yellow. When you see a blue dialog you can be sure that the application requesting privileges is signed and trusted. The yellow dialog shows for any application that is not digitally signed and is not fully trusted.

User Account Control also prevents a lower privilege process to do the following (list below taken from MSDN):

• Perform a window handle validation of higher process privilege.
• SendMessage or PostMessage to higher privilege application windows. These Application Programming Interfaces (APIs) return success but silently drop the window message.
• Use thread hooks to attach to a higher privilege process.
• Use Journal hooks to monitor a higher privilege process.
• Perform DLL injection to a higher privilege process.

Let’s see how an UAC aware application should look.

It should be composed of two executables (one that will be run with limited privileges and another one that will be started only with needed and with full rights) or two working modes (a mode for limited rights and another one for full rights). Either way you must remember that once you elevated the application and finalized the administrative tasks, the process should be destroyed in order to reduce an attacker’s privileges.

In order to launch an elevated process in Windows Vista the process must be started with the “runas” verb. The Verb property is part of System.Diagnostics.Process.StartInfo class. The code snippet that launches “notepad.exe” with full rights is showed below:

    ProcessStartInfo processInfo = new ProcessStartInfo();
    processInfo.Verb = "runas";
    processInfo.FileName = "notepad.exe";
    Process.Start(processInfo);

If you choose to have only one executable file that acts differently based on permissions you should check if the user is part of the administrative group. In Vista even if your user is part of the Administrators group it runs with reduced privileges by default and gains his full rights on demand. The code below stores true in the hasAdministrativeRight boolean variable if the user’s privileges are administrative and false otherwise.

    WindowsPrincipal pricipal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
    bool hasAdministrativeRight = pricipal.IsInRole(WindowsBuiltInRole.Administrator);

To elevate the current application you must create a process with elevated rights and close the existing instance. However you cannot start a process with limited privileges – I couldn’t find a solution. Anyone knows how to start a less privilege process from a higher privilege one? The sample creates an elevated instance of the current executable and closes the existing one.

    RunElevated(Application.ExecutablePath);
    this.Close();

RunElevated is a method that takes the name of an executable and spawns it in a new elevated process (see the attached code).

I have created a sample application that illustrates all the things written so far: it displays the user’s rights, elevates the current application and starts a process with more privileges. In order to see all features of the application you must have UAC enabled. You can download the code from this link.

Please note that here I recommend to run applications with limited privileges but there are situations when applications need to run unrestricted – this is the case of system configuration utilities or other special applications. What I want to say is that you should run applications in an unprivileged environment when possible.

This is part one of the tutorial. Part 2 will explain how to use the manifest file to specify that an executable must be always run with full privleges.

Download Source Code

Let’s assume that we have a simple class with a private field called “someHiddenValue”.

class ClassThatHidesSomething
{
    private int someHiddenValue = 5;
}

We want to modify that field from outside the class. This can be done extremely easy through Reflection. First of all we need to get the Type of the ClassThatHidesSomething and get some information about the someHiddenValue field.

Type classThatHidesSomethingType = typeof(ClassThatHidesSomething);
FieldInfo field = classThatHidesSomethingType.GetField(
                         "someHiddenValue",
                         BindingFlags.NonPublic | BindingFlags.Instance);

• BindingFlags.NonPublic specifies that we want to search in all fields; by default it searches only the public fields – actually here is the trick that violates encapsulation.
• BindingFlags.Instance specified that we want to search in instance fields also; by default it searches only in static ones.

Now that we have the FieldInfo of that specific field we can do whatever we want with it. Let’s display its value. But first, because the field is an instance field we need an instance of ClassThatHidesSomething.

ClassThatHidesSomething c = new ClassThatHidesSomething();
 
int hiddenFieldValue = (int)field.GetValue(c);
Console.WriteLine("Hidden field value: {0}", hiddenFieldValue);

Using the same instance c we can set the private field’s value.

field.SetValue(c, 6);

Below you can see the entire code (it is a console application):

using System;
using System.Reflection;
 
namespace Reflection
{
    class ClassThatHidesSomething
    {
        private int someHiddenValue = 5;
    }
 
    class Reflection
    {
        const int ANumber = 10;
 
        public static void Main(string[] args)
        {
            Type classThatHidesSomethingType = typeof(ClassThatHidesSomething);
            FieldInfo field = classThatHidesSomethingType.GetField(
                                     "someHiddenValue",
                                     BindingFlags.NonPublic | BindingFlags.Instance);
            //It is good to check this because
            //we don't want a NullReferenceException
            if (field == null)
                Console.Write("Field not found");
            else
            {
                ClassThatHidesSomething c = new ClassThatHidesSomething();
 
                int hiddenFieldValue = (int)field.GetValue(c);
                Console.WriteLine("Hidden field value: {0}", hiddenFieldValue);
 
                field.SetValue(c, 6);
 
                int newHiddenFiledValue = (int)field.GetValue(c);
                Console.WriteLine("New hidden field value: {0}", newHiddenFiledValue);
            }
        }
    }
}

The code outputs:

Hidden field value: 5
New hidden field value: 6

The article describes how to create a custom control in which you add elements and you can move/resize them.

The article can be found here.