David Berg said:

Joshua,

I just saw your post and looked at your code.  It's an interesting way to measure performance, but I think you're unfairly assuming that any non-success code is due to a hang situation; however, it could also be due to a timeout, which you've set to only 2ms.

So what's happening is this - every second you take the pulse of VS, and if at that particular instant in time, it's doing anything that takes longer than 2 ms, then you're counting the entire second as being hung.  I don't think that's really fair.

As a general rule of thumb, I tell people that it's okay to hang the UI thread for up to 100 ms during typing (although I prefer they keep it to under 50ms) and up to 4000 ms when displaying a dialog box (although I prefer they keep it well under 2000 ms).

Of course, I'm not saying that VS doesn't have some performance issues that we need to address, just that I don't think they're as bad as your program implies.

If you'd like to discuss the issue further, you can e-mail me at DevPerf@Microsoft.com.

Regards,

David Berg
Microsoft Developer Division
Performance Engineering Team

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;

namespace CalulateHangTime
{
    [Flags]
    public enum SendMessageTimeoutFlags : uint
    {
        SMTO_NORMAL = 0x0000,
        SMTO_BLOCK = 0x0001,
        SMTO_ABORTIFHUNG = 0x0002,
        SMTO_NOTIMEOUTIFNOTHUNG = 0x0008
    }

    public static class ExternalMethods
    {
        [DllImport("user32.dll", SetLastError = true)]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern IntPtr SendMessageTimeout(IntPtr hWnd, uint Msg,
           UIntPtr wParam, IntPtr lParam, SendMessageTimeoutFlags fuFlags,
           uint uTimeout, out UIntPtr lpdwResult);
    }

    class Program
    {
        static readonly uint WAIT_MILLISECONDS = 2;
        static readonly int SLEEP_MILLISECONDS = 1000;

        static void Main(string[] args)
        {
            long seconds = 0;
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            while (true)
            {
                IntPtr hWnd = ExternalMethods.FindWindow("wndclass_desked_gsk", null);
                if (hWnd == IntPtr.Zero)
                    throw new InvalidOperationException("Handle to window could not be found");


                UIntPtr result;
                IntPtr success = ExternalMethods.SendMessageTimeout(hWnd, 0, UIntPtr.Zero, IntPtr.Zero, 
				SendMessageTimeoutFlags.SMTO_ABORTIFHUNG, WAIT_MILLISECONDS, out result);
                
                if (success == IntPtr.Zero)
                {
                    seconds += SLEEP_MILLISECONDS / 1000;

                    Console.WriteLine("Visual Studio is hung. {0}/{1} seconds wasted", seconds, stopWatch.Elapsed.TotalSeconds);
                }
                else
                {
                    Console.WriteLine("Visual Studio is running fine.");
                }

                Thread.Sleep(SLEEP_MILLISECONDS);
            }
        }
    }
}

Regardless of what its called this is the best shell ever!

Cheers.

 $connObj.Open()
 
 $reader = $cmdObj.ExecuteReader()
 while ($reader.Read()) {
  $result = new-object System.Management.Automation.MshObject
  
  for ($i=0;$i -lt ($reader.FieldCount) ;$i++) {
   $fld = new-object System.Management.AUtomation.MshNoteProperty $reader.GetName($i), $reader[$i]
   $result.MshObject.Members.Add($fld);
  }
  
  $result
  
 }

 $reader.Close()
 $reader.Dispose()

 $connObj.Close();
}


Enjoy