Ryan Farber's WebLog

Reorder Elements with XLinq

2008-07-22T21:46:55Z

So recently I was dealing with an internal program that was easily confused and would create XML files with the elements in the wrong order for the schemas used in other internal programs that read these Xml files. I started looking for a fast way to reorder these elements and found this forum post which while on the right track was a bit more complicated than I really needed. So I came up with this solution.

Bad File

Good File

<data name="ConfigName">
  <One>Item One</One>
  <Three>
    <A>Item A</A>
    <C>Item C</C>
    <C>Item C-2</C>
    <B>Item B</B>
  </Three>
  <Two>Item Two</Two>
</data>

<data name="ConfigName">
  <One>Item One</One>
  <Two>Item Two</Two>
  <Three>
    <A>Item A</A>
    <B>Item B</B>
    <C>Item C</C>
    <C>Item C-2</C>
  </Three>
</data>

Reorder Solution

string[] rootOrder = new string[] { "One", "Two", "Three" };
string[] threeOrder = new string[] { "A", "B", "C" };
          
XDocument xdoc = XDocument.Load("file.xml");
Reorder(xdoc, rootOrder);
Reorder(xdoc.Root.Elements("Three"), threeOrder);

void Reorder(XDocument xdoc, params string[] order)
{
  xdoc.Root.ReplaceWith(Reorder(xdoc.Root, order));
}

void Reorder(IEnumerable<XElement> els, params string[] order)
{
  foreach (XElement el in els.ToArray())
    el.ReplaceWith(Reorder(el, order));
}

XElement Reorder(XElement root, params string[] order)
{
  return new XElement(root.Name,
                      from el in order
                      select root.Elements(el),
                      root.Attributes());
}

Class Extensions for XLinq

2008-05-30T20:57:49Z

I love XLinq!! It really has made editing and manipulated Xml files much easier for me. However there are some features missing that I really wanted to use all the time so I added them using the new class extensions feature in .NET. So here's what I have. I am looking for a merge nodes functions in XLinq if anyone has any.

Function	Purpose
IsValid	Validates an XElement against a schemas. I'm really surprised this feature wasn't in XLinq already. I hope its added in the future.
GetAttributeValue	There is a SetAttributeValue but no get attribute value. I've overloaded this nicely so it can return defaults and the proper casting. It would be fun to also have it try to look up the declared scema for default values but I haven't had the time or need for that yet. Also I've used the default keyword in this function which I thought was pretty spiffy. :) I most commonly use this for boolean test if (myEl.GetAttributeValue<bool>() == true) { do something }
GetElementValue	Ok maybe this function isn't needed that much but I kept finding myself writing the if null and casting code repeatedly plus this nicely matched with GetAttributeValue.
RemoveElements	This is another function that really should have existed. They give us Remove, RemoveAll, RemoveAttributes, RemoveNodes, but nothing for removing just the elements and leaving attributes and comments alone. I know its a one liner foreach but it still ticks me off that it wasn't there.
HasAttribute	A simple test, does this attribute exist. Certainly a common need.
EncodeForXmlAttribute	Ok this one doesn't really belong here but heck I like it being right there at my fingertips to use before setting items or during comparisons.

using System;
using System.Xml.Linq;
using System.Xml.Schema;
using System.Xml;
using System.Diagnostics;
using System.Linq;

/// <summary>
/// Class extensions for XElement
/// </summary>
/// <see cref="IsValid"/>
/// <see cref="GetAttributeVlue"/>
/// <see cref="GetElementValue"/>
/// <see cref="RemoveElements"/>
/// <see cref="HasAttribute"/>
/// <see cref="EncodeForXmlAttribute"/>
public static class Extensions
{
    #region XElement class extensions
    #region IsValid (against schemas) Extension for XElement
    /// <summary>
    /// Validates Xml element against schemas
    /// </summary>
    /// <param name="xEl">Element to verify</param>
    /// <param name="schemaPath">List locations of schemas to compare</param>
    /// <returns>True/False (if false details in Debug)</returns>
    public static bool IsValid(this XElement xEl, params string[] schemaPath)
    {
        XmlSchemaSet schemas = new XmlSchemaSet();

        foreach (String sp in schemaPath)
        {
            if (sp.Contains("<"))
            {
                schemas.Add(String.Empty, XElement.Parse(sp).CreateReader());
            }
            else
            {
                schemas.Add(String.Empty, XmlReader.Create(sp));
            }
        }

        return CompareToSchemas(xEl, schemas);
    }

    /// <summary>
    /// Validates xml element against schemas
    /// </summary>
    /// <param name="xEl">Element to verify</param>
    /// <param name="schemaReader">List of schemas to compare</param>
    /// <returns>True/False (if false details in Debug)</returns>
    public static bool IsValid(this XElement xEl, params XmlReader[] schemaReader)
    {
        XmlSchemaSet schemas = new XmlSchemaSet();

        foreach (XmlReader sr in schemaReader)
            schemas.Add(String.Empty, sr);

        return CompareToSchemas(xEl, schemas);
    }

    private static bool CompareToSchemas(XElement xEl, XmlSchemaSet schemas)
    {
        bool errors = false;
        XDocument doc = xEl.Document;
        if (doc == null)
        {
            doc = XDocument.Parse(xEl.ToString());
        }

        doc.Validate(schemas, (sender, e) =>
        {
            Debug.WriteLine(e.Message, "ValidateErrror");
            errors = true;
        });


        return !errors;
    }
    #endregion

    #region GetAttributeValue
    /// <summary>
    /// Gets the value of an attribute
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="attName">An XName that contains the name of the attribute to retrieve.</param>
    /// <param name="defaultReturn">Default return if the attribute doesn't exist</param>
    /// <returns>Attribute value or default if attribute doesn't exist</returns>
    public static string GetAttributeValue(this XElement xEl, XName attName, string defaultReturn)
    {
        XAttribute att = xEl.Attribute(attName);
        if (att == null) return defaultReturn;
        return att.Value;
    }

    /// <summary>
    /// Gets the value of an attribute
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="attName">An XName that contains the name of the attribute to retrieve.</param>
    /// <returns>Attribute value or String.Empty if element doesn't exist</returns>
    public static string GetAttributeValue(this XElement xEl, XName attName)
    {
        return xEl.GetAttributeValue(attName, String.Empty);
    }

    /// <summary>
    /// Gets the value of an attribute
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="attName">An XName that contains the name of the attribute to retrieve.</param>
    /// <param name="defaultReturn">Default return if the attribute doesn't exist</param>
    /// <returns>Attribute value or default if attribute doesn't exist</returns>
    public static T GetAttributeValue<T>(this XElement xEl, XName attName, T defaultReturn)
    {
        string returnValue = xEl.GetAttributeValue(attName, String.Empty);
        if (returnValue == String.Empty) return defaultReturn;
        return (T)Convert.ChangeType(returnValue, typeof(T));
    }

    /// <summary>
    /// Gets the value of an attribute
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="attName">An XName that contains the name of the attribute to retrieve.</param>
    /// <returns>Attribute value or default of T if element doesn't exist</returns>
    public static T GetAttributeValue<T>(this XElement xEl, XName attName)
    {
        return xEl.GetAttributeValue<T>(attName, default(T));
    }
    #endregion

    #region GetElementValue
    /// <summary>
    /// Gets the value of a child element.
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="elName">An XName that contains the name of the child element to retrieve.</param>
    /// <param name="defaultReturn">Default return if the element doesn't exist</param>
    /// <returns>Element value or default if element doesn't exist</returns>
    public static string GetElementValue(this XElement xEl, XName elName, string defaultReturn)
    {
        XElement el = xEl.Element(elName);
        if (el == null) return defaultReturn;
        return el.Value;
    }

    /// <summary>
    /// Gets the value of a child element.
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="elName">An XName that contains the name of the child element to retrieve.</param>
    /// <returns>Element value or String.Empty if element doesn't exist</returns>
    public static string GetElementValue(this XElement xEl, XName elName)
    {
        return xEl.GetElementValue(elName, String.Empty);
    }

    /// <summary>
    /// Gets the value of a child element.
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="elName">An XName that contains the name of the child element to retrieve.</param>
    /// <param name="defaultReturn">Default return if the element doesn't exist</param>
    /// <returns>Element value or default if element doesn't exist</returns>
    public static T GetElementValue<T>(this XElement xEl, XName elName, T defaultReturn)
    {
        string returnValue = xEl.GetElementValue(elName, String.Empty);
        if (returnValue == String.Empty) return defaultReturn;
        return (T)Convert.ChangeType(returnValue, typeof(T));
    }

    /// <summary>
    /// Gets the value of a child element.
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="elName">An XName that contains the name of the child element to retrieve.</param>
    /// <returns>Element value or default of T if element doesn't exist</returns>
    public static T GetElementValue<T>(this XElement xEl, XName elName)
    {
        return xEl.GetElementValue<T>(elName, default(T));
    }
    #endregion

    #region RemoveElements
    /// <summary>
    /// Removes all child elements
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    public static void RemoveElements(this XElement xEl)
    {
       foreach (XElement el in xEl.Elements().ToArray()) el.Remove();
    }

    /// <summary>
    /// Removes all child elements matching the XName
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="name">The System.Xml.Linq.XName to match.</param>
    public static void RemoveElements(this XElement xEl, XName name)
    {
        foreach (XElement el in xEl.Elements(name).ToArray()) el.Remove();
    }
    #endregion

    /// <summary>
    /// Determines if attribute doesn't exist or exists but is empty
    /// </summary>
    /// <param name="xEl">Extends this XElement Type</param>
    /// <param name="attName">An XName that contains the name of the attribute to retrieve.</param>
    /// <returns>True if attribute exists and is not empty</returns>
    public static bool HasAttribute(this XElement xEl, XName attName)
    {
        return !String.IsNullOrEmpty(xEl.GetAttributeValue(attName));
    }

    /// <summary>
    /// Replaces invalid XML characters in a string with their valid XML equivalent.
    /// </summary>
    /// <remarks>
    /// Replaced characters are &lt; to &amp;lt;, &gt; to &amp;gt;, &apos; to &amp;apos;, &quot; to &amp;quot; and &amp; to &amp;amp;
    /// </remarks>
    /// <param name="text">The string within which to escape invalid characters.</param>
    /// <returns>The input string with invalid characters replaced.</returns>
    public static string EncodeForXmlAttribute(String text)
    {
        return System.Security.SecurityElement.Escape(text);
    }
    #endregion
}

Find and FindAll in .NET 2.0 collections

2006-07-28T18:25:00Z

I just found that Arrays, Lists, Collections all have these Find, FindAll, etc... functions that use the Predicate syntax. I guess I've noticed them a few times but never actually tried to use them. Check this out.

static void Main(string[] args)
{
   // List of Integers
   int[] intArray = new int[] { 1, 5, 10, 2, 15, 100, 20, 30 };
   int[] intFilter;

   // Get all the integers that are less than five [using inline predicate delage]
   intFilter = Array.FindAll<int>(intArray, delegate(int testInt) { return testInt < 5; });
   DisplayIntList(intFilter);

   // If I reused it a lot I can turn it into a function
   intFilter = Array.FindAll<int>(intArray, LessThanTen);
   DisplayIntList(intFilter);

   // If I wanted to pass in the limit I'd have to create a Predicate
   intFilter = Array.FindAll<int>(intArray, LessThan(50));
   DisplayIntList(intFilter);
}

static bool LessThanTen(int testInt)
{
return testInt < 10;
}

static Predicate<int> LessThan(int limit)
{
return delegate(int testInt) { return testInt < limit; };
}

static void DisplayIntList(int[] intFilter)
{
foreach (int testInt in intFilter) { Console.WriteLine(testInt); } Console.WriteLine();
}

High Contrast Mode

2005-10-22T00:32:00Z

We are working on a simple helper tool for testing accessibility in IE pages. One of the few tests that is pretty hard to automate since it has to be reviewed first, although once reviewed screen shot comparisons of regressions could be useful assuming the pages are reasonably static. Either way this tool is a simple set of options for IE. Turn on/off IE settings for Images, Colors, and CSS; resize IE window for resolution testing (ok not the same thing but reasonably the same effect), Alt text expand, and font size. The tool sets the IE registry settings then opens IE on the test url. After you are done it resets all the registry setting. Nice, simple, and easy to hand to a dev for unit tests. The only feature we wanted to add the was somewhat difficult was setting Windows into High Contrast Mode. After long searching for how to change high contrast mode in .NET I came up with the following.

Public Structure tagHIGHCONTRAST
   Dim cbSize As Integer
   Dim dwFlags As Integer
   Dim lpszDefaultScheme As Integer
End Structure

Public Const HCF_HIGHCONTRASTON As Integer = &H1
Public Const SPI_GETHIGHCONTRAST As Integer = 66
Public Const SPI_SETHIGHCONTRAST As Integer = 67
Public Const SPIF_UPDATEINIFILE As Integer = &H1
Public Const SPIF_SENDWININICHANGE As Integer = &H2
Public Const SPIF_SENDCHANGE As Integer = SPIF_SENDWININICHANGE

Declare Function SystemParametersInfo Lib "user32" Alias "SystemParametersInfoA" ( _
      ByVal uAction As Integer, _
      ByVal uParam As Integer, _
      ByRef lpvParam As tagHIGHCONTRAST, _
      ByVal fuWinIni As Integer) As Integer

Private Sub SetHighContrast(ByVal TurnOn As Boolean)
   Dim udtHighContrast As tagHIGHCONTRAST
   Dim lngWin32apiResultCode As Long

   udtHighContrast.cbSize = Len(udtHighContrast)
   lngWin32apiResultCode = SystemParametersInfo(SPI_GETHIGHCONTRAST, Len(udtHighContrast), udtHighContrast, 0)

   If TurnOn Then
      udtHighContrast.dwFlags = udtHighContrast.dwFlags Or HCF_HIGHCONTRASTON
   Else
      udtHighContrast.dwFlags = udtHighContrast.dwFlags Xor HCF_HIGHCONTRASTON
   End If

   lngWin32apiResultCode = SystemParametersInfo(SPI_SETHIGHCONTRAST, Len(udtHighContrast), udtHighContrast, SPIF_UPDATEINIFILE Or SPIF_SENDCHANGE)
End Sub

Teaching non-enthusiastic students

2005-06-22T20:15:00Z

I work with several really good black box testers who know that it is time to increase their skills and learn to program. These skills hopefully will add them to list of people who can fix test automations, create simple automations and better understand potential weaknesess in developers code. All in all better testers. The problem is that even though their review goals emphasize increasing technical skills and they even take classes on Intro to C# or Programming Principles or even weekly brown-bag programming talks these training sessions never turn into actual productive skills.

Then one day I notice that one of these testers has found an API for automating dialogs through sending key strokes to window handles. He went hog wild. The code wasn't great and completely unsustainable but there he was building projects in C#. So I sat down with another trainer and started discussing this. We looked at what kind of programs we would like these testers to write and built and API that allowed them to more easily run these tasks. Specifically for our needs we wrapped functions needed for writing batch programs (better File Copy/Move, Modify XML file settings, Simple search and replace of values in text files, abilities to determine file encoding) and IE UI automation thourgh the IE DOM. Then built a custom template for BatchCode and IEUICode that created the projects, added needed references, and supplied sample code.

Wow did this work. At first they started converting some of their batch programs, then writing test cases. If a tricky problem came up that was reusable we would add a function to the API. In less than a month we had adoption by about a dozen people who were debugging, writing functions and discussing code. Adding FAQ documents and modifying the templates to push toward sustainable programming techniques helped as well.

In summary we developed an easy to use API that very directly affected our business. This API allowed people new to programming to produce useful results quickly. These fast wins turn into excitement which in turn increases technical skills much more efficiently than any training courses we developed or sent people to. From there training becomes more effective.

Capturing web page images

2005-06-22T19:47:00Z

After fiddling with DrawToDC I discovered it won't capture DXFilters since they aren't technically in the DC. Not to mention that getting the copied image in a state for actually saving to a file is more pain that I wanted to go to. I decided the best way to handle this was to deal with the limitation that it won't work on Locked Machine or in Service Instances (though with screensavers is fine) and I've built a form with a AxBrowser control on it. and used this code for capturing.

private Bitmap m_CapturedImage = null;

/// <summary>
/// Captures the current web page
/// </summary>
/// <overloads>
/// <summary>
/// Captures the current web page
/// </summary>
/// <example>
/// Capture the full image of a page (scrolls down the page) and returns an image
/// <code>
/// Image pageCapture = browser.CapturePage();
/// pageCapture.Save("C:\\test.bmp", ImageFormat.Bmp);
/// </code>
/// </example>
/// <example>
/// Capture top section of a page
/// <code>
/// Image pageCapture = browser.CapturePage(new Rectangle(0,0, 50, 50), false);
/// pageCapture.Save("C:\\test.bmp", ImageFormat.Bmp);
/// </code>
/// </example>
/// </overloads>
/// <example>
/// Capture the full image of a page (scrolls down the page) and save to the harddrive.
/// <code>
/// Image pageCapture = browser.CapturePage();
/// pageCapture.Save("C:\\test.bmp", ImageFormat.Bmp);
/// </code>
/// </example>
/// <returns>Image object of the requested capture</returns>
public Image CapturePage() { return CapturePage(new Rectangle(0,0,0,0), true); }

/// <summary>
/// Captures the current web page
/// </summary>
/// <example>
/// Capture top section of a page
/// <code>
/// Image pageCapture = browser.CapturePage(new Rectangle(0,0, 50, 50), false);
/// pageCapture.Save("C:\\test.bmp", ImageFormat.Bmp);
/// </code>
/// </example>
/// <param name="captureRegion">Coordinates to capture on the page.</param>
/// <param name="scrollDownPage">Scroll down the page when capturing
///                              (this is better disabled on framesets)</param>
/// <returns>Image object of the requested capture</returns>
public Image CapturePage(Rectangle captureRegion, bool scrollDownPage)
{
if(this.ParentForm != null)
{
  if(this.ParentForm.Opacity < 1.0)
  {
   this.ParentForm.Top = SystemInformation.VirtualScreen.Top - this.ParentForm.Height - 100;
   this.ParentForm.Left = SystemInformation.VirtualScreen.Left - this.ParentForm.Width - 100;
   this.ParentForm.Opacity = 1.0;
  }
}

int   VScrollBarOffset  = 0;
int   HScrollBarOffset  = 0;
int   PixelsScrolled   = 0;
int   CaptureHeight   = 0;
int   CaptureWidth   = 0;
int   FinalPageHeight   = 0;
int   CaptureDestinationY  = 0;
int   CaptureDestinationX  = 0;
Rectangle CaptureRectangle;

// Captured page specific properties.
bool m_ScrollV = true;

// Get fresh copy of the doc objects (they need to be updated whenever the Navigation changes)
HTMLDocumentClass m_HTMLDoc = (HTMLDocumentClass)this.Document;
HTMLBodyClass m_HTMLBody = (HTMLBodyClass) m_HTMLDoc.body;

#region Figure Max Height and Set destination bitmap
// Check if there is a Horizontal Scroll bar
if(m_HTMLBody.scrollWidth > m_HTMLBody.clientWidth)
{
HScrollBarOffset = SystemInformation.HorizontalScrollBarHeight;
}

// Get final page height and height of capture area
CaptureHeight = browser.Height -
                 SystemInformation.Border3DSize.Height -
                 HScrollBarOffset;

if(m_ScrollV) // || m_HTMLBody.scrollHeight < m_PageHeight)
{
  FinalPageHeight = m_HTMLBody.scrollHeight;
}
else
{
  FinalPageHeight = CaptureHeight;
}
#endregion

#region Figure Width minus Vertical Scroll bar
VScrollBarOffset = SystemInformation.Border3DSize.Width;

// Set offset (0 if scroll bar is on right, VSBarWidth if on left (RTL)
if((m_HTMLDoc.dir != null && m_HTMLDoc.dir.ToLower() == "rtl") ||
(m_HTMLBody.dir != null && m_HTMLBody.dir.ToLower() == "rtl"))
{
VScrollBarOffset += SystemInformation.VerticalScrollBarWidth;
}

CaptureWidth = browser.Width -
                SystemInformation.VerticalScrollBarWidth -
                SystemInformation.Border3DSize.Width -
                SystemInformation.Border3DSize.Width;
#endregion

#region Capture Full Web Page
// Create a Bitmap of the final size
m_CapturedImage = new Bitmap(CaptureWidth, FinalPageHeight);

PixelsScrolled = CaptureHeight - SystemInformation.Border3DSize.Height;

m_HTMLBody.scrollTop = 0;

// Build a full picture from each section of the page.
if(!m_ScrollV)
{
  CaptureRectangle = new Rectangle(VScrollBarOffset, CaptureHeight - PixelsScrolled, CaptureWidth, CaptureHeight);
  AddToScreenShot(CaptureRectangle, CaptureDestinationX, CaptureDestinationY);
}
else
{
  int MaxScrolls = 0;

  if(scrollDownPage)
  {
   MaxScrolls = m_HTMLBody.scrollHeight / CaptureHeight;
  }

  do
  {
   CaptureRectangle = new Rectangle(VScrollBarOffset, CaptureHeight - PixelsScrolled, CaptureWidth, PixelsScrolled);
   AddToScreenShot(CaptureRectangle, CaptureDestinationX, CaptureDestinationY);

   CaptureDestinationY = CaptureDestinationY + PixelsScrolled;
   PixelsScrolled = scrollDown(HScrollBarOffset);
   MaxScrolls--;
  }
  while(MaxScrolls > -1);
}
#endregion

if(captureRegion.Width != 0 && captureRegion.Height != 0)
{
return m_CapturedImage.Clone(captureRegion, m_CapturedImage.PixelFormat);
}
return m_CapturedImage;
}

/// <summary>
/// Scroll the page down one page.
/// </summary>
/// <returns>Number of pixels scrolled</returns>
private int scrollDown(int HScrollBarOffset)
{
HTMLDocumentClass m_HTMLDoc = (HTMLDocumentClass)this.Document;
HTMLBodyClass m_HTMLBody = (HTMLBodyClass) m_HTMLDoc.body;

int CaptureHeight  = m_HTMLBody.offsetHeight;
int ScrollTop   = m_HTMLBody.scrollTop;
int scrollAmount  = ScrollTop + CaptureHeight - (m_HTMLBody.clientTop * 2) - HScrollBarOffset;

m_HTMLBody.scrollTop = scrollAmount;

int ScrollTopAfterScroll = 0;

if(m_HTMLBody.scrollTop == 0 && m_HTMLBody.scrollHeight >= scrollAmount)
{
  Object parent = m_HTMLDoc.documentElement;
  PropertyInfo prop = parent.GetType().GetProperty("scrollTop");
  prop.SetValue(parent, scrollAmount, null);
  ScrollTopAfterScroll = (int)prop.GetValue(parent, null);
}
else
{
  ScrollTopAfterScroll = m_HTMLBody.scrollTop;
}

int PixelsScrolled = ScrollTopAfterScroll - ScrollTop;

if(PixelsScrolled <= 0)
{
return 0;
}
else
{
return PixelsScrolled;
}
}

/// <summary>
/// Copies visible image to a destination bitmap
/// </summary>
/// <param name="CaptureRectangle">Size within browser control to capture</param>
/// <param name="CaptureDestinationY">Starting Y postion for image in destination bitmap</param>
/// <param name="CaptureDestinationX">Starting X postion for image in destination bitmap</param>
private void AddToScreenShot(Rectangle CaptureRectangle, int CaptureDestinationX, int CaptureDestinationY)
{
if(this.ParentForm != null)
this.ParentForm.TransparencyKey = this.ParentForm.TransparencyKey; // Without this images off main montior won't display
Application.DoEvents(); // Makes sure the screen redraws

Graphics g1 = null;
Graphics g2 = null;

try
{
  // Get Graphic object for source and destination
  g1   = browser.CreateGraphics();
  g2   = Graphics.FromImage(m_CapturedImage);

  IntPtr  dc1   = IntPtr.Zero;
  IntPtr  dc2   = IntPtr.Zero;
  try
  {
   // Get the handles for the Graphics which are needed to perform the image copy
   dc1   = g1.GetHdc();
   dc2   = g2.GetHdc();

   // Create a destination image the size of the visible browser window
   BitBlt(dc2, CaptureDestinationX, CaptureDestinationY, CaptureRectangle.Width, CaptureRectangle.Height,
    dc1, CaptureRectangle.X , CaptureRectangle.Y , 13369376);
  }
  finally
  {
   // Release holds on handles
   if(dc1 != IntPtr.Zero) g1.ReleaseHdc(dc1);
   if(dc2 != IntPtr.Zero) g2.ReleaseHdc(dc2);
  }
}
finally
{
  // Release holds on graphics
  if(g1 != null) g1.Dispose();
  if(g2 != null) g2.Dispose();
}
}

/// <summary>
/// BitBlit it a core GDI call which can copy an image from one hdc to another
/// </summary>
[DllImport("GDI32.DLL", EntryPoint="BitBlt", SetLastError=true,
  CharSet=CharSet.Unicode, ExactSpelling=true,
  CallingConvention=CallingConvention.StdCall)]
static extern bool BitBlt(IntPtr hdcDest, int nXDest, int nYDest,
                          int nWidth, int nHeight, IntPtr hdcSrc,
                          int nXSrc, int nYSrc, System.Int32 dwRop);

DrawToDC

2004-10-12T16:06:00Z

I’m trying to take this code http://www.codeproject.com/internet/htmlimagecapture.asp?msg=783507 and convert it to C#.

I can’t seem cast from IHTMLElement down to IHTMLElementRender. Trying through late binding also fails.

IHTMLDocument2 doc = (IHTMLDocument2)Browser.Document;
IHTMLElement body = (IHTMLElement)doc.body;

// Render returns as null
IHTMLElementRender render = (IHTMLElementRender)body;

// Render is also null
IHTMLElementRender render = body.getType().GetInterface(“IHTMLElementRender”);

Does anyone have working C# calling DrawToDC?

Screen capture when machine is locked?

2004-10-07T22:45:00Z

Does anybody out there know how to get a screen capture (specifically of the WebControls web browser) when the screen is locked. When I move the window to the top left outside the monitor bounds it captures with a screen saver on but not when the machine is locked. Any ideas?

Fable

2004-10-07T17:56:00Z

If you haven't picked up a copy yet go and get Fable for the XBOX. This is a fun game. I think its the first adventure game I've played all the way through since Oddworld. It successfully put together game play fluidly with the story movies much like Prince of Persia but without the boredom of repetitive moves and simple puzzles. You can customize your character is so many ways it makes you want to go play the game again with a new outlook after completing it. Very nice!

Of course now I need to get my hands on Halo 2...November 9th....arrggg!!!

Speaking of Uri’s

2004-10-06T13:30:00Z

Changing my code to convert string Url’s to Uri objects (because FxCop said it was a good idea) really helped solidify my testing. I never really thought about picking up Url’s that may not be http. I can see where a user may have done this with my code. Now I catch it upfront.

void DoSomething(string url)

{

// Will throw ArgumentNull or UriFormatException if Url is not valid

Uri myUrl = new Uri(url);

if(myUrl.Scheme != Uri.UriSchemeHttp && myUrl.Scheme != Uri.UriSchemeHttps)

{

throw new ArgumentException("Expected HTTP or HTTPS url",url);

}

// Do Something

}

Use of included script samples are subject to the terms specified at http://www.microsoft.com/info/cpyright.htm

FxCop is your friend

2004-10-05T11:02:00Z

If you haven’t used FxCop and you are writing code in C# go get it at http://www.gotdotnet.com/team/fxcop/ . This program rocks and will make your code better. The hard part is that on first run you’re going to get a surprising amount of issues and start trying to ignore half of the bugs. I mean why program for global concerns if I know the code is always going to in English. Because it’s the right thing to do! You never know what you are going to reuse so take the time to write it correctly.

For example I was pretty bugged at the issue raised that any parameter containing the word “Url” should be turned into an Uri object or at least only be an overload that turns it into an Uri object to pass to the real code. I don’t need that. Well it bugged me enough that instead of excluding the error I tried changing my code. It really does make my code better. Thanks FxCop.

Two simple file tricks

2004-10-03T11:17:00Z

1. How do I know if a file path string has valid characters without resorting to catching an exception?

bool IsFileNameValid(string fileName)

{

if(filename != null && fileName.IndexOfAny(Path.InvalidPathChars) != -1)

{ return false; }

else { return true; }

}

2. Ever wanted to get the parent folder name of file path?

Path.GetFileName(Path.GetDirectoryName(path))

The GetDirectoryName strips off the file name and then the GetFileName returns the directory thinking it’s the file name. This of course assumes you know the path really ends with a file name.

Use of included script samples are subject to the terms specified at http://www.microsoft.com/info/cpyright.htm

Teaching C# to newbie testers

2004-10-02T12:54:00Z

I keep looking for simple books for programming C# but even the learn in 21 days books are trying to teach too much. I’d hazard to say 99% of any code needed to be written by testers is simple file manipulation. You need to know about int, string, building console apps, finding files, opening and saving files, loops, and simple string replacement and verification. That’s about it. I’m working on a paper to teach that basic things right now. I think it might be useful. Guess I’ll find out.

I love C#

2004-10-01T15:40:00Z

I love C#. It’s everything VB/VBS promised but didn’t quite give us. I was a hard core VB junky following the maxim “get it done today!” VB allowed me to do that. OK so every once in a while I needed code in C++ to keep my stuff reasonably speedy but 99% of the I could complete a functional program with no worries of memory leaks in a quarter of the time it took my C++ buddies to do. Of course they laughed at me during code reviews but heck I was productive. Now with C# the laughing has ended. I’m in the club now and still quickly getting things done.