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.

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
}

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

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.

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.

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

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

2. Ever wanted to get the parent folder name of file 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

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.