Rants of a Hippie Coder : .NET Programming

How to get the active Team Foundation Server and Project from an Add-In

hippietim — Wed, 29 Mar 2006 17:16:00 GMT

Ed Hintz posted "How to Write a Team Foundation Version Control Add-in for Visual Studio" which is a great guide to writing an add-in to integrate with Team Foundation version control. I won't repeat that info her. If you want to do something that is related to the active Team Server and/or Project from within a VS Add-In or VSIP package then read on.

First make sure you have a reference to Microsoft.VisualStudio.TeamFoundation - either follow Ed's steps to add them via the REG.EXE commands for convenience or load them using the Browse tab on the Add Reference dialog - in a default installation the assembly will be in "%programfiles%\Microsoft Visual Studio 8\Common7\IDE\PrivateAssemblies".

Next add a using clause:

using Microsoft.VisualStudio.TeamFoundation;

Create a member variable in your Connect class for the TeamFoundationServerExt object:

private TeamFoundationServerExt _tfsExt;

In your OnConnection method, initialize the _tfsExt object:

_tfsExt = _applicationObject.GetObject("Microsoft.VisualStudio.TeamFoundation.TeamFoundationServerExt") as TeamFoundationServerExt;

The TeamFoundationServerExt object exposes two things:

ActiveProjectContext - a property of type ProjectContextExt which contains the active server and project
ProjectContextChanged - an event which is fired when the current project and/or server is changed

public sealed class ProjectContextExt
{
    public string DomainName { get; }
    public string DomainUri { get; }
    public string ProjectName { get; }
    public string ProjectUri { get; }
}

DomainName is the display name of the current server and DomainUri is the actual URI of the current server. And ProjectName is the display name of the current server and ProjectUri is the Team Project URI. Note that these values can be null if there is no active server or project.

Your ProjectContextChanged handler should look like this:

void _tfsExt_ProjectContextChanged(object sender, EventArgs e)
{
}

Within your handler you requery the ActiveProjectContext property of the TeamFoundationServerExt object.

Flashing Dialogboxes

hippietim — Tue, 28 Mar 2006 18:22:00 GMT

This example demonstrates how to flash a dialog in the taskbar after performing a long running operation from the command line. A good example of how this is useful is in the VS Team Foundation version control toolset. Naturally, it includes a command line utility (TF.EXE) to perform source control operations. Sometimes these operations can be very lengthy and in the end result in a dialog box popping up - performing a lengthy GET operation that results in conflicts to resolve is a good example of when this would happen.

Our own UI framework does quite a bit more than this - this is just a scaled down example of what happens when a dialog is invoked from the command line. Many of our dialogs end up getting displayed in Visual Studio, standalone Windows apps, Excel, the command line, etc. So in our framework the method to show a modal dialog is actually virtual so the appropriate thing happens in each environment.

 using System;
 using System.Diagnostics;
 using System.Text;
 using System.Windows.Forms;
 using System.Runtime.InteropServices;
 using System.Threading;
  
 namespace ConsoleFlasher
 {
     class Program
     {
         static void Main(string[] args)
         {
             Thread.Sleep(5000); //  Lengthy operation... 
             using (MyForm form = new MyForm())
             {
                 UIHost.ShowModalDialog(form);
             }
         }
     }
  
     static class UIHost
     {
         static public DialogResult ShowModalDialog(Form form)
         {
             return ShowModalDialog(form, null);
         }
  
         //********************************************************************************************
         /// <summary>
         /// Display a modal dialog a windows application.
         /// </summary>
         /// <param name="form">The form to display.</param>
         /// <param name="parent">The parent window for window stack ordering.</param>
         //********************************************************************************************
         static public DialogResult ShowModalDialog(Form form, IWin32Window parent)
         {
             bool isTopLevel = parent == null;
  
             form.ShowInTaskbar = isTopLevel;
             form.MinimizeBox = isTopLevel;
             form.ShowIcon = isTopLevel;
  
             if (isTopLevel)
             {
                 //  Attach an event handler so maybe we'll flash the title in the taskbar
                 form.Activated += new EventHandler(OnModalDialogFormActivate);
  
                 //  This is where you would also set your app icon on the dialog as well.
             }
         
             DialogResult result = form.ShowDialog(parent);
         
             if (isTopLevel)
             {
                 form.Activated -= new EventHandler(OnModalDialogFormActivate);
             }
         
             return result;
         }
  
         //********************************************************************************************
         /// <summary>
         /// On form activate for a modal dialog for the console.  We check to see if we are the 
         /// foreground window and flash the taskbar if we aren't.
         /// </summary>
         /// <param name="sender">Form to activate</param>
         /// <param name="e">Standard event args</param>
         //********************************************************************************************
         static private void OnModalDialogFormActivate(object sender, EventArgs e)
         {
             Form form = sender as Form;
  
             if (form != null)
             {
                 Debug.Assert(form.Visible, "Form should already be visible for FormActivate");
  
                 IntPtr foregroundHwnd = NativeMethods.GetForegroundWindow();
  
                 //  First see if we're in the foreground
  
                 if (foregroundHwnd != form.Handle)
                 {
                     IntPtr consoleHwnd = NativeMethods.GetConsoleWindow();
  
                     //  We're not in the foreground so let's see if our console is.
  
                     if (foregroundHwnd != consoleHwnd)
                     {
                         //  We're not in the foreground and neither is our console window so let's
                         //  flash the user.
                         int flashCount = 1;
  
                         //  make sure we read the count from the system and respect this for accessibility
                         NativeMethods.SystemParametersInfo(NativeMethods.SPI_GETFOREGROUNDFLASHCOUNT, 0, ref flashCount, 0);
  
                         NativeMethods.FLASHWINFO fwi = new NativeMethods.FLASHWINFO();
  
                         fwi.cbSize = (UInt32)Marshal.SizeOf(typeof(NativeMethods.FLASHWINFO));
                         fwi.dwFlags = NativeMethods.FLASHW_ALL;
                         fwi.dwTimeout = 0;      //  This will get the system default which is the caret blink rate
                         fwi.uCount = (UInt32)flashCount;
                         fwi.hwnd = form.Handle;
  
                         //  blinky, blinky, blinky
                         NativeMethods.FlashWindowEx(ref fwi);
                     }
                     else
                     {
                         //  Our console has the input focus so let's be a bit more agressive...
                         NativeMethods.SetForegroundWindow(new HandleRef(form, form.Handle));
                     }
                 }
  
                 //  Don't call us again...
                 form.Activated -= new EventHandler(OnModalDialogFormActivate);
             }
             else
             {
                 Debug.Fail("Invalid sender in OnModalDialogFormLoad");
             }
         }
  
     }
  
     static class NativeMethods
     {
         public const int SPI_GETFOREGROUNDFLASHCOUNT = 0x2004;
  
         public const int FLASHW_STOP = 0;
         public const int FLASHW_CAPTION = 0x00000001;
         public const int FLASHW_TRAY = 0x00000002;
         public const int FLASHW_ALL = (FLASHW_CAPTION | FLASHW_TRAY);
         public const int FLASHW_TIMER = 0x00000004;
         public const int FLASHW_TIMERNOFG = 0x0000000C;
  
         [StructLayout(LayoutKind.Sequential)]
         internal struct FLASHWINFO
         {
             public UInt32 cbSize;
             public IntPtr hwnd;
             public UInt32 dwFlags;
             public UInt32 uCount;
             public UInt32 dwTimeout;
         }
  
         [DllImport("user32", SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
         public extern static int FlashWindowEx(ref FLASHWINFO fwi);
  
         [DllImport("user32", CharSet = CharSet.Auto)]
         public static extern bool SystemParametersInfo(int nAction, int nParam, ref int value, int ignore);
  
         [DllImport("user32", SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
         internal static extern IntPtr SetForegroundWindow(HandleRef hwnd);
  
         [DllImport("user32", SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
         internal static extern IntPtr GetForegroundWindow();
  
         [DllImport("kernel32", SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
         internal static extern IntPtr GetConsoleWindow(); 
     }
 }

Overcoming a .NET ListView CheckBoxes quirk

hippietim — Mon, 27 Mar 2006 22:10:00 GMT

In the Visual Studio Team Foundation version control UI, we display your pending changes in a ListView control. That ListView has CheckeBoxes set to true as we allow you to perform a variety of operations on the checked items.

At the same time we want you to be able to double click on an item in the list and have the file open in the editor.

Unfortunately, the .NET ListView component automatically toggles the checked state of items when you double click on them. I know that this is not the behavior of the underlying Win32 ListView control so it has to be something in the WinForms code.

At this point it's worth examing how this all works. In a traditional C/C++ application, the ListView control sends WM_NOTIFY messages to the window that is the parent of the ListView. This is typically a dialog box window. In WinForms, events are exposed directly from the controls themselves. So internally WinForms will take the WM_NOTIFY message and reflect it back to the child control and then the child control handles the message by firing events that you add your event handlers too. This happens for other messages besides WM_NOTIFY - such as WM_COMMAND.

A few minutes with a program such as Spy++ will show you the message traffic. When you double click a ListView item the underlying Win32 ListView sends a WM_NOTIFY message to the parent window (typically your Form). The WinForms message handler for the parent window then reroutes the message back to the ListView by sending it a new message - WM_REFLECT + WM_NOTIFY. The WinForms ListView message handler then dispatches it. When the WinForms ListView sees a NM_DBLCLK notification it then sends a message (LVM_HITTEST) to the Win32 ListView control asking where the click occurred. If it was on an item, the WinForms ListView code will then toggle the checked state of the item.

Since none of this behavior is exposed via the properties of the ListView control we'll have to work around it using less convenient means. The solution I came up with for Team Foundation was to set a flag during the NM_DBLCLK notification that we're in the midst of a double click notification and then we intercept the LVM_HITTEST call and return that no item was found.

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Windows.Forms;
 
namespace ListViewCheckBoxes
{
    class MyListView : ListView
    {      
        private bool m_doubleClickDoesCheck = true;  //  maintain the default behavior
        private bool m_inDoubleClickCheckHack = false;
 
        //****************************************************************************************
        // This function helps us overcome the problem with the managed listview wrapper wanting
        // to turn double-clicks on checklist items into checkbox clicks.  We count on the fact
        // that the base handler for NM_DBLCLK will send a hit test request back at us right away.
        // So we set a special flag to return a bogus hit test result in that case.
        //****************************************************************************************
        private unsafe void OnWmReflectNotify(ref Message m)
        {
            if (!DoubleClickDoesCheck && CheckBoxes)
            {
                NativeMethods.NMHDR* nmhdr = (NativeMethods.NMHDR *)m.LParam;
 
                if (nmhdr->code == NativeMethods.NM_DBLCLK)
                {
                    m_inDoubleClickCheckHack = true;
                }
            }
        }
 
        [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
        protected override void WndProc(ref Message m)
        {
            switch (m.Msg)
            {
                //  This code is to hack around the fact that the managed listview
                //  wrapper translates double clicks into checks without giving the 
                //  host to participate.
                //  See OnWmReflectNotify() for more details.
                case NativeMethods.WM_REFLECT + NativeMethods.WM_NOTIFY:
                    OnWmReflectNotify(ref m);
                    break;
 
                //  This code checks to see if we have entered our hack check for
                //  double clicking items in check lists.  During the NM_DBLCLK
                //  processing, the managed handler will send a hit test message
                //  to see which item to check.  Returning -1 will convince that
                //  code not to proceed.
                case NativeMethods.LVM_HITTEST:
                    if (m_inDoubleClickCheckHack)
                    {
                        m_inDoubleClickCheckHack = false;
                        m.Result = (System.IntPtr)(-1);
                        return;
                    }
                    break;
            }
 
            base.WndProc(ref m);
        }
 
        [Browsable(true), 
         Description("When CheckBoxes is true, this controls whether or not double clicking will toggle the check."), 
         Category("My Controls"),
         DefaultValue(true)]
        public bool DoubleClickDoesCheck
        {
            get
            {
                return m_doubleClickDoesCheck;
            }
 
            set
            {
                m_doubleClickDoesCheck = value;
            }
        }
    }
 
    //****************************************************************************************
    //  This is stuff you would normally put in a separate file with all the other interop
    //  you have to work with.
    //****************************************************************************************
    public class NativeMethods
    {
        public const int WM_USER = 0x0400;
        public const int WM_REFLECT = WM_USER + 0x1C00;
        public const int WM_NOTIFY = 0x004E;
        public const int LVM_HITTEST = (0x1000 + 18);
        public const int NM_DBLCLK = (-3);
 
        [StructLayout(LayoutKind.Sequential)]
        public struct NMHDR
        {
            public IntPtr hwndFrom;
            public UIntPtr idFrom;
            public int code;
        }
    }
 
}

Give the .NET loader a hand - how to load assemblies from VS PrivateAssemblies

hippietim — Fri, 24 Mar 2006 18:41:00 GMT

This program demonstrates how to use the AppDomain.AssemblyResolve event to help the .NET loader get assemblies loaded that it can't find.

The VS Team Foundation edition ships with a number of assemblies you may want to reference in your own apps. Most of the important ones are installed in the GAC so you should have no problem loading them at runtime. However, some of them are installed under the VS PrivateAssemblies directory (by default this is C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\PrivateAssemblies). Your options are you can copy these DLLs around, put that directory in your path, put your tool in the same directory, or have .exe.config file for your app that tells the loader where to look. Quite frankly, none of these options is particularly appealing since they all make distributing your tool more cumbersome. So let's help the loader out!

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Text;
using Microsoft.Win32;
 
namespace TeamFoundationAssemblyLoadTest
{
    class Program
    {
        static void Main(string[] args)
        {
            AppDomain domain = AppDomain.CurrentDomain;
 
            domain.AssemblyResolve += new ResolveEventHandler(domain_AssemblyResolve);
 
            //  The following line triggers the AssemblyResolve event to fire because
            //  it uses a class in Microsoft.TeamFoundation.WorkItemTracking.Controls.dll
            //  which is not installed in the GAC or anywhere else convenient.
            ClassThatUsesTeamFoundation.SomeFunction();
        }
 
        static Assembly domain_AssemblyResolve(object sender, ResolveEventArgs args)
        {
            String[] assemblyParams = args.Name.Split(',');
            
            Debug.Assert(assemblyParams.Length > 0 && !String.IsNullOrEmpty(assemblyParams[0]), "Invalid assembly name arguments passed to domain_AssemblyResolve");
 
            //  Note that there are additional fields passed that indicate the 
            //  version, public key token, etc.  For this demonstration, we           
            //  are just looking at the assembly name.
 
            String assemblyName = assemblyParams[0];
            Assembly loadedAssembly = null;
 
            switch (assemblyName)
            {
                case "Microsoft.TeamFoundation.WorkItemTracking.Controls":
                case "Microsoft.VisualStudio.TeamFoundation":
                    // etc.
                    loadedAssembly = LoadVSPrivateAssembly(assemblyName);
                    break;
 
                default:
                    Debug.Fail(assemblyName + " is not supported by TeamFoundationAssemblyLoadTest.domain_AssemblyResolve");
                    break;
            }
 
            return loadedAssembly;
        }
 
        //  This function will load the named assembly from the Visual Studio PrivateAssemblies 
        //  directory.  This is where a number of Team Foundation assemblies are located that are
        //  not easily accessible to an app.  Fortunately, the .NET loader gives us a shot at 
        //  finding them and we just happen to know where to look.
        static Assembly LoadVSPrivateAssembly(String assemblyName)
        {
            Assembly loadedAssembly = null;
 
            using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\VisualStudio\8.0"))
            {
                if (key != null)
                {
                    Object obj = key.GetValue("InstallDir");
 
                    if ((obj != null) && (obj is String))
                    {
                        String vsInstallDir = obj as String;
                        String privateAssembliesDir = Path.Combine(vsInstallDir, "PrivateAssemblies");
                        String assemblyFile = Path.Combine(privateAssembliesDir, assemblyName + ".dll");
 
                        loadedAssembly = Assembly.LoadFile(assemblyFile);
                    }
                    else
                    {
                        Debug.Fail("VS 8.0 InstallDir value is missing or invalid");
                    }
                }
                else
                {
                    Debug.Fail("Could not open VS 8.0 registry key");
                }
            }
 
            return loadedAssembly;
        }
    }
}

WinForms ListView Performance - ListView collections

hippietim — Tue, 21 Mar 2006 17:50:00 GMT

The WinForms ListView has a few very handy collections - CheckedItems and CheckedIndices. SelectedItems is a collection of the ListViewItems that are selected. SelectedIndices is a collection of the indexes of the ListViewItems that are selected. Those values can be used to pick out ListViewItems from the ListView.Items collection. CheckedItems and CheckedIndices are just like the SelectedXXX collections only they are for the items that are checked.

The SelectedXXX collections perform very well. Underneath the covers they are implemented by sending the Win32 ListView control a LVM_GETNEXTITEM message specifying LVNI_SELECTED to find the next selected item. The Count properties are implemented by sending the Win32 ListView control a LVM_GETSELECTEDCOUNT message.

On the other hand...

The CheckedXXX collections are very expensive. Underneath the covers they enumerate the listview Items collection for just about every operation. To retrieve the Count for the CheckedXXX collections WinForms will walk the entire Items collection and test the Checked property of each ListView Item. Querying the Checked property of each item results in sending a LVM_GETITEMSTATE message to the Win32 ListView control to query for the checked state. To reference an item from the CheckedXXX collections iterates over the ListView Items collection stopping at the index you ask for. So the worst case performance is if all items in the ListView are checked.

My previous ListView examples were working with 5000 items. Well, for the CheckedXXX collections just a few hundred items is enough to exhibit performance problems depending on how you write your code. It doesn't make much difference whether you use the CheckedItems collection or the CheckedIndices collection since the CheckedItem collection basically does its job via the CheckedIndices collection. What makes a huge difference is how you access the items. Index lookup is very slow because of how the next item is found by starting at the beginning again each time. If for some reason you must do this, then at least cache the Count value at the start of your loop if possible because it is very expensive to recompute. The fastest way to use these collections is via enumeration such as a foreach() loop. Even that is not as fast as just enumerating the Items collection yourself and testing each item's Checked property yourself.

For the Team Foundation Server version control UI, we sometimes have 50,000 or more items if you are doing a big branch or adding an existing tree. I ended up keeping a separate cache of the checked items myself - I just updated the cache during ListView Checked events. Ideally we would have used a virtual ListView but there were other unrelated performance problems with sorting that made this actually perform worse in our case.

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
 
namespace ListViewPerf
{
    public partial class Form1 : Form
    {
        const int ListEntryCount = 500;
        static int seed = 7919;         //  use a constant for repeatable results
 
        String[] strings;
        bool[] checksInit;
        object dontCare;
        int processed;
 
        public Form1()
        {
            Random rand = new Random(seed);
            strings = new String[ListEntryCount];
            checksInit = new bool[ListEntryCount];
 
            for (int i = 0; i < ListEntryCount; i++)
            {
                strings[i] = rand.Next().ToString();
                checksInit[i] = (rand.Next() % 2) == 0;
            }
 
            InitializeComponent();
        }
 
        void FillListView()
        {
            ListViewItem[] items = new ListViewItem[ListEntryCount];
 
            for (int i = 0; i < ListEntryCount; i++)
            {
                items[i] = new ListViewItem(strings[i]);
                items[i].Checked = checksInit[i];
            }
            listView1.Items.AddRange(items);
        }
 
        //  make the compiler believe we're doing something important here...
        void ProcessListViewItem(ListViewItem lvi)
        {
            dontCare = lvi.Tag;
            processed++;
        }
 
        void CheckAll()
        {
            foreach (ListViewItem item in listView1.Items)
            {
                item.Checked = true;
            }
        }
 
        void FetchViaItems()
        {
            processed = 0;
            int count;
            DateTime start;
            TimeSpan tsCheckedIteratorWaySlow;
            TimeSpan tsCheckedIterator;
            TimeSpan tsCheckedEnumerator;
 
            start = DateTime.Now;
            for (int i = 0; i < listView1.CheckedItems.Count; i++)
            {
                ListViewItem lvi = listView1.CheckedItems[i];
                ProcessListViewItem(lvi);
            }
            tsCheckedIteratorWaySlow = DateTime.Now - start;
 
            start = DateTime.Now;
            count = listView1.CheckedItems.Count;
            for (int i = 0; i < count; i++)
            {
                ListViewItem lvi = listView1.CheckedItems[i];
                ProcessListViewItem(lvi);
            }
            tsCheckedIterator = DateTime.Now - start;
 
            start = DateTime.Now;
            foreach (ListViewItem lvi in listView1.CheckedItems)
            {
                ProcessListViewItem(lvi);
            }
            tsCheckedEnumerator = DateTime.Now - start;
 
            MessageBox.Show("Checked ListViewItems via CheckedItems collection:\n" +
                "CheckedIteratorWaySlow " + tsCheckedIteratorWaySlow.TotalMilliseconds.ToString() + " milliseconds\n" +
                "CheckedIterator " + tsCheckedIterator.TotalMilliseconds.ToString() + " milliseconds\n" +
                "CheckedEnumerator " + tsCheckedEnumerator.TotalMilliseconds.ToString() + " milliseconds\n" +
                "Processed " + processed.ToString()
            );
        }
 
        private void ViaItemsButton_Click(object sender, EventArgs e)
        {
            listView1.Items.Clear();
            FillListView();
            
            //  First test a random scattering of checked items
            FetchViaItems();
            
            //  Then test with all checked
            CheckAll();
            FetchViaItems();
        }
 
        void FetchViaIndeces()
        {
            processed = 0;
            int count;
            DateTime start;
            TimeSpan tsCheckedIteratorWaySlow;
            TimeSpan tsCheckedIterator;
            TimeSpan tsCheckedEnumerator;
 
            start = DateTime.Now;
            for (int i = 0; i < listView1.CheckedIndices.Count; i++)
            {
                ListViewItem lvi = listView1.Items[listView1.CheckedIndices[i]];
                ProcessListViewItem(lvi);
            }
            tsCheckedIteratorWaySlow = DateTime.Now - start;
 
            start = DateTime.Now;
            count = listView1.CheckedIndices.Count;
            for (int i = 0; i < count; i++)
            {
                ListViewItem lvi = listView1.Items[listView1.CheckedIndices[i]];
                ProcessListViewItem(lvi);
            }
            tsCheckedIterator = DateTime.Now - start;
 
            start = DateTime.Now;
            foreach (int index in listView1.CheckedIndices)
            {
                ListViewItem lvi = listView1.Items[index];
                ProcessListViewItem(lvi);
            }
            tsCheckedEnumerator = DateTime.Now - start;
 
            MessageBox.Show("Checked ListViewItems via CheckedIndices collection:\n" +
                "CheckedIteratorWaySlow " + tsCheckedIteratorWaySlow.TotalMilliseconds.ToString() + " milliseconds\n" +
                "CheckedIterator " + tsCheckedIterator.TotalMilliseconds.ToString() + " milliseconds\n" +
                "CheckedEnumerator " + tsCheckedEnumerator.TotalMilliseconds.ToString() + " milliseconds\n" +
                "Processed " + processed.ToString()
            );
        }
 
        private void ViaIndecesButton_Click(object sender, EventArgs e)
        {
            listView1.Items.Clear();
            FillListView();
 
            FetchViaIndeces();
 
            CheckAll();
            FetchViaIndeces();
        }
 
        void FetchViaManual()
        {
            processed = 0;
            int count;
            DateTime start;
            TimeSpan tsIteratorWaySlow;
            TimeSpan tsIterator;
            TimeSpan tsEnumerator;
 
            start = DateTime.Now;
            for (int i = 0; i < listView1.Items.Count; i++)
            {
                ListViewItem lvi = listView1.Items[i];
                if (lvi.Checked)
                {
                    ProcessListViewItem(lvi);
                }
            }
            tsIteratorWaySlow = DateTime.Now - start;
 
            start = DateTime.Now;
            count = listView1.Items.Count;
            for (int i = 0; i < count; i++)
            {
                ListViewItem lvi = listView1.Items[i];
                if (lvi.Checked)
                {
                    ProcessListViewItem(lvi);
                }
            }
            tsIterator = DateTime.Now - start;
 
            start = DateTime.Now;
            foreach (ListViewItem lvi in listView1.Items)
            {
                if (lvi.Checked)
                {
                    ProcessListViewItem(lvi);
                }
            }
            tsEnumerator = DateTime.Now - start;
 
            MessageBox.Show("Checked ListViewItems via Manual lookup:\n" +
                "IteratorWaySlow " + tsIteratorWaySlow.TotalMilliseconds.ToString() + " milliseconds\n" +
                "Iterator " + tsIterator.TotalMilliseconds.ToString() + " milliseconds\n" +
                "Enumerator " + tsEnumerator.TotalMilliseconds.ToString() + " milliseconds\n" +
                "Processed " + processed.ToString()
            );
        }
 
        private void ViaManual_Click(object sender, EventArgs e)
        {
            listView1.Items.Clear();
            FillListView();
 
            FetchViaManual();
 
            CheckAll();
            FetchViaManual();
        }
    }
}

WinForms ListView Performance - Initializing checked states

hippietim — Tue, 21 Mar 2006 00:56:00 GMT

CheckBoxes in a WinForms ListView are of course a bit simpler to use than dealing the underlying Win32 control directly. WinForms deals with the ListView structures and the WM_NOTIFY messages. Of course this comes at a cost. Here's a simple demonstration of how to tweak things for better performance. This is a simple example so the gains aren't monumental but when you add real world complexities to the Checked event handler and the computation of the Checked state of an item. There are real noticeable improvements by paying attention to some simple things.

When you are populating a ListView that has CheckBoxes, you really want to set the Checked property of the ListViewItem before you add it to the list. The reason is that once you have added the item to the ListView.Items collection, WinForms will always defer to the underlying Win32 control to query and set the Checked state of the item. Before it's added to the ListView the ListViewItem maintains the state itself. Calling down into the Win32 control is very expensive since it involved PInvoking SendMessage.

There are 5 examples with steady gains in improvement.

Set the checked state of the item after it is added to the ListView	1425 milliseconds
Set the checked state of the item after it is added to the ListView but at least check to see if it should be checked - this saves a marshaled SendMessage call to the Win32 ListView per item	1250 milliseconds
Set the checked state of the item before it is added to the ListView	1106 milliseconds
Add the items via AddRange and set the checked state of the items after they are added to the ListView - again you see that AddRange is MUCH faster than adding items one at a time.	343 milliseconds
Add the items via AddRange and have the checked state set before the items are added	234 milliseconds

using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
 
namespace ListViewPerf
{
    public partial class Form1 : Form
    {
        const int ListEntryCount = 5000;
        static int seed = 7919;         //  use a constant for repeatable results
 
        String[] strings;
        bool[] checksInit;
        DateTime start;
        int checkedEvents;
 
        public Form1()
        {
            Random rand = new Random(seed);
            strings = new String[ListEntryCount];
            checksInit = new bool[ListEntryCount];
 
            for (int i = 0; i < ListEntryCount; i++)
            {
                strings[i] = rand.Next().ToString();
                checksInit[i] = (rand.Next() % 2) == 0;
            }
 
            InitializeComponent();
        }
 
        void PreCall()
        {
            listView1.Items.Clear();
            checkedEvents = 0;
            start = DateTime.Now;
        }
 
        void PostCall(string s)
        {
            TimeSpan ts = DateTime.Now - start;
 
            MessageBox.Show(s + " took " + ts.TotalMilliseconds.ToString() + " milliseconds\nAnd generated " + checkedEvents.ToString() + " Checked events");
        }
 
        enum CheckMode { Before, After, AfterWithTest }
 
        void FillListViewWithStrings(CheckMode checkMode)
        {
            for (int i = 0; i < ListEntryCount; i++)
            {
                ListViewItem lvi = new ListViewItem(strings[i]);
                bool check = checksInit[i];
 
                switch (checkMode)
                {
                    case CheckMode.After:
                        listView1.Items.Add(lvi);
                        lvi.Checked = check;
                        break;
 
                    case CheckMode.Before:
                        lvi.Checked = check;
                        listView1.Items.Add(lvi);
                        break;
 
                    case CheckMode.AfterWithTest:
                        listView1.Items.Add(lvi);
                        if (check)
                        {
                            lvi.Checked = check;
                        }
                        break;
                }
            }
        }
 
        private void checkAfter_Click(object sender, EventArgs e)
        {
            PreCall();
 
            FillListViewWithStrings(CheckMode.After);
 
            PostCall("Check After");
        }
 
        private void checkAfterTest_Click(object sender, EventArgs e)
        {
            PreCall();
 
            FillListViewWithStrings(CheckMode.AfterWithTest);
 
            PostCall("Check After With Test");
        }
 
        private void checkBefore_Click(object sender, EventArgs e)
        {
            PreCall();
 
            FillListViewWithStrings(CheckMode.Before);
 
            PostCall("Check Before");
        }
 
        ListViewItem[] BuildListViewItems(bool setChecks)
        {
            ListViewItem[] items = new ListViewItem[ListEntryCount];
 
            if (setChecks)
            {
                for (int i = 0; i < ListEntryCount; i++)
                {
                    items[i] = new ListViewItem(strings[i]);
                    items[i].Checked = checksInit[i];
                }
            }
            else
            {
                for (int i = 0; i < ListEntryCount; i++)
                {
                    items[i] = new ListViewItem(strings[i]);
                }
            }                
 
            return items;
        }
 
        private void addRangeAfter_Click(object sender, EventArgs e)
        {
            PreCall();
 
            ListViewItem[] items = BuildListViewItems(false);
            listView1.Items.AddRange(items);
            
            for (int i = 0; i < ListEntryCount; i++)
            {
                listView1.Items[i].Checked = checksInit[i];
            }
 
            PostCall("AddRange After");
        }
 
        private void addRangeBefore_Click(object sender, EventArgs e)
        {
            PreCall();
 
            ListViewItem[] items = BuildListViewItems(true);
            listView1.Items.AddRange(items);
 
            PostCall("AddRange Before");
        }
 
        private void listView1_ItemChecked(object sender, ItemCheckedEventArgs e)
        {
            checkedEvents++;
        }
 
    }
}

WinForms ListView Performance

hippietim — Mon, 20 Mar 2006 23:05:00 GMT

While working on improving the performance of the version control UI for Visual Studio Team Foundation Server, I encountered a number of potential problems with the WinForms ListView control.

As it turns out, adding items to a ListView can be VERY expensive if the list is sorted (as they should be). Below is a test program I threw together to demonstrate some of the performance tradeoffs and mistakes I've encountered.

The first example is "Normal mode". I say this is normal because this is probably what most people do to start with - add a sorter to the ListView early on and be done with it - set it and forget it. Then you just add your of items. With a few hundred items it performs just fine. However, once you get over a certain threshold the performance degrades significantly. What happens is that ListView gets sorted after every ListViewItem is added to the Items collection. This is very sloooooow. On my computer it took 123,843 milliseconds to build the list and resulted in 70,621,263 calls to my Compare function. OUCH!

The next example, No Sorter1, is the first optimization folks seem to make. You remove the sorter, add your items, set the sorter back, and then call Sort. This is a noticeable improvement. The problem here is that there is no need to call Sort! When you set the sorter back WinForms will call Sort for you. On my computer it took 1812 milliseconds and resulted in 85,030 calls to my Compare function. Much better!

The next example, No Sorter2, is the optimization that a lot of folks miss because the previous one helped so much. This one really matters when you have an expensive Compare function. It's the same as the previous example with the unnecessary Sort call removed. On my computer it took 1765 milliseconds and resulted in 55,226 calls to my Compare function. Still better!

Next is to use AddRange. As it turns out WinForms has an opportunity to do an even better job than you internally because they have direct access to their interactions with the underlying Win32 ListView control. On my computer it took 546 milliseconds and resulted in 55,226 calls to my Compare function. This is LOTS better!

The final example uses the virtual capabilities of the ListView object. The way this works is you maintain your own cache of ListViewItem objects and supply them in a callback when you are asked. This results in a dramatic speed up when dealing with a large number of items. For this case I just used Array.Sort. On my computer it took 46 milliseconds and resulted in 91,800 calls to my Compare function.

Note that in one of the cases I was working on, the virtual mode performed worse than the AddRange and the No Sorter modes. Our IComparer in that case is far more expensive than the simple one in my example.

MEASURE!!!


using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
 
namespace ListViewPerf
{
    public partial class Form1 : Form
    {
        const int ListEntryCount = 5000;
        static int seed = 7919;         //  use a constant for repeatable results
 
        String[] strings;
        ListViewItem[] virtualItems;
        MySorter sorter;
        DateTime start;
 
        public Form1()
        {
            Random rand = new Random(seed);
            strings = new String[ListEntryCount];
 
            for (int i = 0; i < ListEntryCount; i++)
            {
                strings[i] = rand.Next().ToString();
            }
 
            sorter = new MySorter();
 
            InitializeComponent();
        }
 
        void PreCall()
        {
            listView1.ListViewItemSorter = null;
 
            if (!listView1.VirtualMode)
            {
                listView1.Items.Clear();
            }
            else
            {
                virtualItems = null;
            }
            listView1.VirtualMode = false;
            sorter.ResetCounter();
            start = DateTime.Now;
        }
 
        void PostCall(string s)
        {
            TimeSpan ts = DateTime.Now - start;
 
            MessageBox.Show(s + " took " + ts.TotalMilliseconds.ToString() + " milliseconds\nAnd resulted in " +  sorter.Counter.ToString() + " Compare calls");
        }
 
        void FillListViewWithStrings()
        {
            for (int i = 0; i < ListEntryCount; i++)
            {
                ListViewItem lvi = new ListViewItem(strings[i]);
                listView1.Items.Add(lvi);
            }
        }
 
        private void normalButton_Click(object sender, EventArgs e)
        {
            PreCall();
 
            listView1.ListViewItemSorter = sorter;
 
            FillListViewWithStrings();
 
            PostCall("Normal mode");
        }
 
        private void noSorter1Button_Click(object sender, EventArgs e)
        {
            PreCall();
 
            FillListViewWithStrings();
 
            listView1.ListViewItemSorter = sorter;
            listView1.Sort();
            
            PostCall("No Sorter1 mode");
        }
 
        private void noSorter2Button_Click(object sender, EventArgs e)
        {
            PreCall();
 
            FillListViewWithStrings();
 
            listView1.ListViewItemSorter = sorter;
 
            PostCall("No Sorter2 mode");
        }
 
        ListViewItem[] BuildListViewItems()
        {
            ListViewItem[] items = new ListViewItem[ListEntryCount];
 
            for (int i = 0; i < ListEntryCount; i++)
            {
                items[i] = new ListViewItem(strings[i]);
            }
 
            return items;
        }
 
        private void addRangeButton_Click(object sender, EventArgs e)
        {
            PreCall();
 
            listView1.ListViewItemSorter = sorter;
            ListViewItem[] items = BuildListViewItems();
            listView1.Items.AddRange(items);
            
            PostCall("AddRange mode");
        }
 
        private void virtualButton_Click(object sender, EventArgs e)
        {
            PreCall();
 
            virtualItems = BuildListViewItems();
            Array.Sort(virtualItems, sorter);
            listView1.VirtualMode = true;
            listView1.VirtualListSize = virtualItems.Length;
 
            PostCall("Virtual mode");
        }
 
        private void listView1_RetrieveVirtualItem(object sender, RetrieveVirtualItemEventArgs e)
        {
            e.Item = virtualItems[e.ItemIndex];
        }
    }
 
    public class MySorter : IComparer
    {
        int counter;
 
        public void ResetCounter()
        {
            counter = 0;
        }
 
        public int Counter
        {
            get { return counter; }
        }
 
        int IComparer.Compare(Object x, Object y)
        {
            ListViewItem lviX = (ListViewItem)x;
            ListViewItem lviY = (ListViewItem)y;
            counter++;
            return String.Compare(lviX.Text, lviY.Text);
        }
 
    }
}