Chris Cavanagh's Blog

Silverlight 3 + ClearType

Chris Cavanagh — Thu, 09 Jul 2009 19:03:37 +0000

As we knew, Silverlight 3 includes ClearType support. Now it’s released we can finally see it in action :

More importantly, it works great with SilverGlulxe!

WPF 2D Physics Plus

Chris Cavanagh — Thu, 25 Jun 2009 19:01:59 +0000

Rohit Gupta is working on some great enhancements to the WPF 2D Physics demo I posted. Features include:

Click to remove a body from the world
Click and “push” the body in any given direction

Be sure to take a look! The project is here on CodePlex and you can run it as a ClickOnce app here.

MVC IsAuthorized and AuthorizedActionLink

Chris Cavanagh — Thu, 11 Jun 2009 13:23:35 +0000

UPDATE: Fixed broken IsAuthenticated logic (thanks Travis).

Robert Dean published a great post last year about his Security Aware Html.ActionLink. It allowed you to conditionally render links based on the [AuthorizeAttribute] assigned to a controller’s action methods.

Here’s an alternative implementation based on expressions, so you get type safety, intellisense and slightly simpler code First, a helper to determine if an action is authorized:

public static class AuthorizationExtensions
{
    private static Dictionary expressionAuthorizers = new Dictionary();

    /// 
    /// Determines whether the specified action is authorized.
    /// 
    /// The type of the controller.
    /// The helper.
    /// The action method.
    /// 
    ///     true if the specified helper is authorized; otherwise, false.
    /// 
    public static bool IsAuthorized( this HtmlHelper helper, Expression> action )
    {
        var call = action.Body as MethodCallExpression;

        if ( call == null ) return false;

        var authorizers = expressionAuthorizers.ContainsKey( action )
            ? expressionAuthorizers[ action ]
            : expressionAuthorizers[ action ] = GetAttributes( call );

        return ( authorizers.Length > 0 )
            ? authorizers.All( a => a.IsAuthorized( helper.ViewContext.HttpContext.User ) )
            : true;
    }

    /// 
    /// Gets the specified attributes for an action method.
    /// 
    /// The call.
    /// 
    private static TAttribute[] GetAttributes( MethodCallExpression call ) where TAttribute : Attribute
    {
        return call.Object.Type.GetCustomAttributes( typeof( TAttribute ), true )
            .Union( call.Method.GetCustomAttributes( typeof( TAttribute ), true ) )
            .Cast()
            .ToArray();
    }

    /// 
    /// Determines whether the specified  authorizes the specified user.
    /// 
    /// The .
    /// The user.
    /// 
    ///     true if the specified user is authorized; otherwise, false.
    /// 
    public static bool IsAuthorized( this AuthorizeAttribute authorize, IPrincipal user )
    {
        if ( !user.Identity.IsAuthenticated ) return false;

        var users = authorize.Users.SplitString();
        if ( users.Length > 0 && !users.Contains( user.Identity.Name, StringComparer.OrdinalIgnoreCase ) ) return false;

        var roles = authorize.Roles.SplitString();
        if ( roles.Length > 0 && !roles.Any( user.IsInRole ) ) return false;

        return true;
    }

    /// 
    /// Splits and trims the specified string.
    /// 
    /// The original.
    /// 
    public static string[] SplitString( this string original )
    {
        return string.IsNullOrEmpty( original )
            ? new string[ 0 ]
            : original.Split( '.' ).Select( s => s.Trim() ).Where( s => !string.IsNullOrEmpty( s ) ).ToArray();
    }
}

With that, it’s possible to write markup like this:

<% if ( Html.IsAuthorized( c => c.Index() ) ) {%>
    My conditional content...
<%}%>

If you’re using ASP.NET MVC Futures, it’s straightforward to write an authorized ActionLink:

public static class LinkExtensions
{
    /// 
    /// Render an HTML action link if authorized by the target action.
    /// 
    /// The type of the controller.
    /// The helper.
    /// The action.
    /// The link text.
    /// 
    public static string AuthorizedActionLink( this HtmlHelper helper, Expression> action, string linkText )
        where TController : Controller
    {
        return AuthorizedActionLink( helper, action, linkText, null );
    }

    /// 
    /// Render an HTML action link if authorized by the target action.
    /// 
    /// The type of the controller.
    /// The helper.
    /// The action.
    /// The link text.
    /// The HTML attributes.
    /// 
    public static string AuthorizedActionLink( this HtmlHelper helper, Expression> action, string linkText, object htmlAttributes )
        where TController : Controller
    {
        var routeValuesFromExpression = ExpressionHelper.GetRouteValuesFromExpression( action );

        return helper.IsAuthorized( action )
            ? helper.RouteLink( linkText, routeValuesFromExpression, new RouteValueDictionary( htmlAttributes ) )
            : null;
    }
}

NOTE – You could do the same thing without MVC Futures, but would need a little more code (you’d need something like ExpressionHelper’s GetRouteValuesFromExpression method).

Here’s a markup example:

<%= Html.AuthorizedActionLink( c => c.Index(), "Modeling" ) %>

Pretty Printing Exceptions

Chris Cavanagh — Sun, 31 May 2009 08:24:20 +0000

Here are some snippets you might find useful for pretty-printing exception stack traces (using the trace string rather than the StackTrace class).

First, a regular expression to extract namespace, method name, argument and source details from a stack trace string:

\sat\s(?.*?)\.(?(\.ctor|<\.ctor>[^(]*?|[^.(]+))\(\s*(((?[^,\s)]+)\s+(?[^,\s)]+)\s*,?\s*?)*?)\s*\)( in (?.*?):line (?[0-9]*))?

Next, a helper class that uses the regex to return a collection of method details:

public class ExceptionParser
{
    private static Regex stackTraceExpr = new Regex(
        @"\sat\s(?.*?)\.(?(\.ctor|<\.ctor>[^(]*?|[^.(]+))\(\s*(((?[^, )]+)\s+(?[^, )]+)\s*,?\s*?)*?)\s*\)( in (?.*?):line (?[0-9]*))?" );

    /// 
    /// Parses the stack trace.
    /// 
    /// The stack trace.
    /// 
    public static IEnumerable ParseStackTrace( string stackTrace )
    {
        var matches = stackTraceExpr.Matches( stackTrace ).Cast();

        foreach ( var match in matches )
        {
            var line = match.Groups[ "line" ].Value;

            yield return new Method
            {
                Namespace = match.Groups[ "namespace" ].Value,
                Name = match.Groups[ "method" ].Value,
                Arguments = ParseArguments( match ).ToArray(),
                Source = match.Groups[ "source" ].Value,
                Line = !string.IsNullOrEmpty( line ) ? (int?)int.Parse( line ) : null
            };
        }
    }

    /// 
    /// Parses the arguments.
    /// 
    /// The match.
    /// 
    private static IEnumerable ParseArguments( Match match )
    {
        var type = match.Groups[ "type" ];
        var arg = match.Groups[ "arg" ];
        var types = type.Captures.Cast().Select( c => c.Value ).Union( new[] { type.Value } ).GetEnumerator();
        var args = arg.Captures.Cast().Select( c => c.Value ).Union( new[] { arg.Value } ).GetEnumerator();

        while ( types.MoveNext() && args.MoveNext() )
        {
            yield return new Argument
            {
                Type = types.Current,
                Name = args.Current
            };
        }
    }

    public struct Argument
    {
        public string Type;
        public string Name;
    }

    public struct Method
    {
        public string Namespace;
        public string Name;
        public Argument[] Arguments;
        public string Source;
        public int? Line;
    }
}

From there you might want to render it as a WPF FlowDocument or series of Inlines in WPF or Silverlight (you can use this directly or as an IValueConverter):

public class PrettyExceptionConverter : DependencyObject, IValueConverter
{
    #region Dependency properties

    public static readonly DependencyProperty ErrorStyleProperty = RegisterStyle( "ErrorStyle", MakeStyle( Colors.Red, FontStyles.Italic, FontWeights.Bold ) );
    public Style ErrorStyle { get { return (Style)GetValue( ErrorStyleProperty ); } set { SetValue( ErrorStyleProperty, value ); } }
    private Inline Error( string text ) { return new Run( text ) { Style = ErrorStyle }; }

    public static readonly DependencyProperty NamespaceStyleProperty = RegisterStyle( "NamespaceStyle", MakeStyle( Colors.Blue ) );
    public Style NamespaceStyle { get { return (Style)GetValue( NamespaceStyleProperty ); } set { SetValue( NamespaceStyleProperty, value ); } }
    private Inline Namespace( string text ) { return new Run( text ) { Style = NamespaceStyle }; }

    public static readonly DependencyProperty MethodNameStyleProperty = RegisterStyle( "MethodNameStyle", MakeStyle( Colors.Black, null, FontWeights.Bold ) );
    public Style MethodNameStyle { get { return (Style)GetValue( MethodNameStyleProperty ); } set { SetValue( MethodNameStyleProperty, value ); } }
    private Inline MethodName( string text ) { return new Run( text ) { Style = MethodNameStyle }; }

    public static readonly DependencyProperty BracketStyleProperty = RegisterStyle( "BracketStyle", MakeStyle( Colors.DarkRed ) );
    public Style BracketStyle { get { return (Style)GetValue( BracketStyleProperty ); } set { SetValue( BracketStyleProperty, value ); } }
    private Inline Bracket( string text ) { return new Run( text ) { Style = BracketStyle }; }

    public static readonly DependencyProperty SeparatorStyleProperty = RegisterStyle( "SeparatorStyle", MakeStyle( Colors.DarkBlue ) );
    public Style SeparatorStyle { get { return (Style)GetValue( SeparatorStyleProperty ); } set { SetValue( SeparatorStyleProperty, value ); } }
    private Inline Separator( string text ) { return new Run( text ) { Style = SeparatorStyle }; }

    public static readonly DependencyProperty SpaceStyleProperty = RegisterStyle( "SpaceStyle", null );
    public Style SpaceStyle { get { return (Style)GetValue( SpaceStyleProperty ); } set { SetValue( SpaceStyleProperty, value ); } }
    private Inline Space() { return new Run( " " ) { Style = SpaceStyle }; }

    public static readonly DependencyProperty TypeNameStyleProperty = RegisterStyle( "TypeNameStyle", MakeStyle( Colors.Teal ) );
    public Style TypeNameStyle { get { return (Style)GetValue( TypeNameStyleProperty ); } set { SetValue( TypeNameStyleProperty, value ); } }
    private Inline TypeName( string text ) { return new Run( text ) { Style = TypeNameStyle }; }

    public static readonly DependencyProperty ArgumentStyleProperty = RegisterStyle( "ArgumentStyle", MakeStyle( Colors.DarkGreen ) );
    public Style ArgumentStyle { get { return (Style)GetValue( ArgumentStyleProperty ); } set { SetValue( ArgumentStyleProperty, value ); } }
    private Inline Argument( string text ) { return new Run( text ) { Style = ArgumentStyle }; }

    public static readonly DependencyProperty SourceStyleProperty = RegisterStyle( "SourceStyle", MakeStyle( Colors.Gray ) );
    public Style SourceStyle { get { return (Style)GetValue( SourceStyleProperty ); } set { SetValue( SourceStyleProperty, value ); } }
    private Inline Source( string text ) { return new Run( text ) { Style = SourceStyle }; }

    public static readonly DependencyProperty LocationStyleProperty = RegisterStyle( "LocationStyle", MakeStyle( Colors.DarkRed ) );
    public Style LocationStyle { get { return (Style)GetValue( LocationStyleProperty ); } set { SetValue( LocationStyleProperty, value ); } }
    private Inline Location( string text ) { return new Run( text ) { Style = LocationStyle }; }

    public static DependencyProperty ChildIndentProperty = DependencyProperty.Register( "ChildIndent", typeof( double ), typeof( PrettyExceptionConverter ), new PropertyMetadata( 25d ) );
    public double ChildIndent { get { return (double)GetValue( ChildIndentProperty ); } set { SetValue( ChildIndentProperty, value ); } }

    #endregion

    #region Static helpers

    private static DependencyProperty RegisterStyle( string name, Style defaultStyle )
    {
        return DependencyProperty.Register(
            name,
            typeof( Style ),
            typeof( PrettyExceptionConverter ),
            new PropertyMetadata( defaultStyle ) );
    }

    private static Style MakeStyle( Color color )
    {
        return MakeStyle( color, null, null );
    }

    private static Style MakeStyle( Color color, FontStyle? fontStyle )
    {
        return MakeStyle( color, fontStyle, null );
    }

    private static Style MakeStyle( Color color, FontStyle? fontStyle, FontWeight? fontWeight )
    {
        var style = new Style();
        style.Setters.Add( new Setter( Run.ForegroundProperty, new SolidColorBrush( color ) ) );
        if ( fontStyle.HasValue ) style.Setters.Add( new Setter( Run.FontStyleProperty, fontStyle.Value ) );
        if ( fontWeight.HasValue ) style.Setters.Add( new Setter( Run.FontWeightProperty, fontWeight.Value ) );
        return style;
    }

    #endregion

    #region FlowDocument helpers

    /// 
    /// Renders the specified .
    /// 
    /// The ex.
    /// 
    public FlowDocument Render( Exception ex )
    {
        var doc = new FlowDocument
        {
            FontFamily = new FontFamily( "Arial" ),
            FontSize = 14d,
            PagePadding = new Thickness( 0 )
        };

        doc.Blocks.AddRange( RenderExceptions( ex ) );

        return doc;
    }

    private Inline LineBreak()
    {
        return new LineBreak();
    }

    #endregion

    #region Rendering helpers

    /// 
    /// Renders the  and inner Exceptions.
    /// 
    /// The ex.
    /// 
    public IEnumerable RenderExceptions( Exception ex )
    {
        var indent = 0d;
        var hanging = ChildIndent / 2;

        for ( ; ex != null; ex = ex.InnerException )
        {
            foreach ( var block in RenderException( ex, indent, hanging ) ) yield return block;
            indent += ChildIndent;
        }
    }

    /// 
    /// Renders the .
    /// 
    /// The ex.
    /// The indent.
    /// The hanging indent.
    /// 
    public IEnumerable RenderException( Exception ex, double indent, double hanging )
    {
        var paragraph = new Paragraph
        {
            TextAlignment = TextAlignment.Left,
            IsHyphenationEnabled = false,
            TextIndent = -hanging,
            Margin = new Thickness( indent + hanging, 0, 0, 0 )
        };

        paragraph.Inlines.AddRange( RenderException( ex ) );

        yield return paragraph;
    }

    /// 
    /// Renders the .
    /// 
    /// The ex.
    /// 
    public IEnumerable RenderException( Exception ex )
    {
        if ( ex != null )
        {
            yield return Error( ex.Message );

            if ( ex.StackTrace != null )
            {
                yield return LineBreak();
                foreach ( var method in RenderStackTrace( ex.StackTrace ) ) yield return method;
            }
        }
    }

    /// 
    /// Renders the stack trace.
    /// 
    /// The stack trace.
    /// 
    public IEnumerable RenderStackTrace( string stackTrace )
    {
        if ( stackTrace != null )
        {
            var first = true;

            foreach ( var method in ExceptionParser.ParseStackTrace( stackTrace ) )
            {
                if ( !first ) yield return LineBreak();
                else first = false;

                foreach ( var inline in RenderMethod( method ) ) yield return inline;
            }
        }
    }

    /// 
    /// Renders the method.
    /// 
    /// The method.
    /// 
    public IEnumerable RenderMethod( ExceptionParser.Method method )
    {
        foreach ( var ns in method.Namespace.Split( '.' ) )
        {
            yield return Namespace( ns );
            yield return Separator( "." );
        }

        yield return MethodName( method.Name );
        yield return Bracket( "(" );

        if ( method.Arguments.Length > 0 )
        {
            yield return Space();

            var first = true;

            foreach ( var arg in method.Arguments )
            {
                if ( !first )
                {
                    yield return Bracket( "," );
                    yield return Space();
                }
                else first = false;

                yield return TypeName( arg.Type );
                yield return Space();
                yield return Argument( arg.Name );
            }

            yield return Space();
        }

        yield return Bracket( ")" );
    }

    #endregion

    #region IValueConverter Members

    public object Convert( object value, Type targetType, object parameter, System.Globalization.CultureInfo culture )
    {
        return ( value is Exception )
            ? (object)Render( (Exception)value )
            : RenderStackTrace( value as string );
    }

    public object ConvertBack( object value, Type targetType, object parameter, System.Globalization.CultureInfo culture )
    {
        throw new NotImplementedException();
    }

    #endregion
}

You can set the Style properties to change the appearance. Here’s an example that puts the stack traces inside nested Expanders:

Maybe you’d prefer to render as HTML (useful for health monitoring emails etc):

public class PrettyExceptionPrint
{
    #region Properties

    public static readonly string ErrorStyle = "PEP_Error";
    private string Error( string text ) { return Span( text, ErrorStyle ); }

    public static readonly string NamespaceStyle = "PEP_Namespace";
    private string Namespace( string text ) { return Span( text, NamespaceStyle ); }

    public static readonly string MethodNameStyle = "PEP_MethodName";
    private string MethodName( string text ) { return Span( text, MethodNameStyle ); }

    public static readonly string BracketStyle = "PEP_Bracket";
    private string Bracket( string text ) { return Span( text, BracketStyle ); }

    public static readonly string SeparatorStyle = "PEP_Separator";
    private string Separator( string text ) { return Span( text, SeparatorStyle ); }

    public static readonly string SpaceStyle = "PEP_Space";
    private string Space() { return Span( " ", SpaceStyle ); }

    public static readonly string TypeNameStyle = "PEP_TypeName";
    private string TypeName( string text ) { return Span( text, TypeNameStyle ); }

    public static readonly string ArgumentStyle = "PEP_Argument";
    private string Argument( string text ) { return Span( text, ArgumentStyle ); }

    public static readonly string SourceStyle = "PEP_Source";
    private string Source( string text ) { return Span( text, SourceStyle ); }

    public static readonly string LocationStyle = "PEP_Location";
    private string Location( string text ) { return Span( text, LocationStyle ); }

    public double ChildIndent { get; set; }

    #endregion

    #region HTML helpers

    private string Span( object content )
    {
        return Span( content, null );
    }

    private string Span( object content, string css )
    {
        return string.Format( "{1}", string.IsNullOrEmpty( css ) ? null : " class='" + css + "'", content );
    }

    private string LineBreak()
    {
        return "
\n";
    }

    #endregion

    #region Rendering helpers

    /// 
    /// Renders the  and inner Exceptions.
    /// 
    /// The ex.
    /// 
    public IEnumerable<string> RenderExceptions( Exception ex )
    {
        var indent = 0d;
        var hanging = ChildIndent / 2;

        for ( ; ex != null; ex = ex.InnerException )
        {
            foreach ( var block in RenderException( ex, indent, hanging ) ) yield return block;
            indent += ChildIndent;
        }
    }

    /// 
    /// Renders the .
    /// 
    /// The ex.
    /// The indent.
    /// The hanging indent.
    /// 
    public IEnumerable<string> RenderException( Exception ex, double indent, double hanging )
    {
        foreach ( var markup in RenderException( ex ) ) yield return markup;
    }

    /// 
    /// Renders the .
    /// 
    /// The ex.
    /// 
    public IEnumerable<string> RenderException( Exception ex )
    {
        if ( ex != null )
        {
            yield return Error( ex.Message );

            if ( ex.StackTrace != null )
            {
                yield return LineBreak();
                foreach ( var method in RenderStackTrace( ex.StackTrace ) ) yield return method;
            }
        }
    }

    /// 
    /// Renders the stack trace.
    /// 
    /// The stack trace.
    /// 
    public IEnumerable<string> RenderStackTrace( string stackTrace )
    {
        if ( stackTrace != null )
        {
            var first = true;

            foreach ( var method in ExceptionParser.ParseStackTrace( stackTrace ) )
            {
                if ( !first ) yield return LineBreak();
                else first = false;

                foreach ( var inline in RenderMethod( method ) ) yield return inline;
            }
        }
    }

    /// 
    /// Renders the method.
    /// 
    /// The method.
    /// 
    public IEnumerable<string> RenderMethod( ExceptionParser.Method method )
    {
        foreach ( var ns in method.Namespace.Split( '.' ) )
        {
            yield return Namespace( ns );
            yield return Separator( "." );
        }

        yield return MethodName( method.Name );
        yield return Bracket( "(" );

        if ( method.Arguments.Length > 0 )
        {
            yield return Space();

            var first = true;

            foreach ( var arg in method.Arguments )
            {
                if ( !first )
                {
                    yield return Bracket( "," );
                    yield return Space();
                }
                else first = false;

                yield return TypeName( arg.Type );
                yield return Space();
                yield return Argument( arg.Name );
            }

            yield return Space();
        }

        yield return Bracket( ")" );
    }

    #endregion
}

Then just add some CSS for the PEP_* classes to change the appearance:

<style>
    html, body { font-family: Arial; }
    .PEP_Namespace { color: darkblue; }
    .PEP_MethodName { color: black; font-weight: bold; }
    .PEP_Bracket { color: darkgreen; }
    .PEP_TypeName { color: teal; }
    .PEP_Argument { color: darkred; }
style>

It’ll look something like this:

Rendering to XML is even easier:

public class PrettyExceptionPrint
{
    /// 
    /// Renders the  and inner Exceptions.
    /// 
    /// The ex.
    /// 
    public static IEnumerable RenderExceptions( Exception ex )
    {
        for ( ; ex != null; ex = ex.InnerException ) yield return RenderException( ex );
    }

    /// 
    /// Renders the .
    /// 
    /// The ex.
    /// 
    public static XElement RenderException( Exception ex )
    {
        return new XElement( "Exception",
            new XAttribute( "Type", ex.GetType() ),
            new XAttribute( "Message", ex.Message ),
            new XElement( "StackTrace", RenderStackTrace( ex.StackTrace ) ) );
    }

    /// 
    /// Renders the stack trace.
    /// 
    /// The stack trace.
    /// 
    public static IEnumerable RenderStackTrace( string stackTrace )
    {
        return from method in ExceptionParser.ParseStackTrace( stackTrace )
               select RenderMethod( method );
    }

    /// 
    /// Renders the method.
    /// 
    /// The method.
    /// 
    public static XElement RenderMethod( ExceptionParser.Method method )
    {
        return new XElement( "Method",
            new XAttribute( "Namespace", method.Namespace ),
            new XAttribute( "Name", method.Name ),
            new XElement( "Arguments",
                from arg in method.Arguments
                select new XElement( "Argument",
                    new XAttribute( "Type", arg.Type ),
                    new XAttribute( "Name", arg.Name ) ) ) );
    }
}

Then you could transform it to HTML with some XSLT like this:

xml version="1.0" encoding="UTF-8" ?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" exclude-result-prefixes="xsl">

    <xsl:output method="html"/>

    <xsl:variable name="lineFeed" select="'
'"/>

    <xsl:template match="/">

        <style>
            p.exception { border: 1px solid #AAAAAA; background-color: #FFAEB9; padding: 4px; }
            table.error { border: 1px solid lightsteelblue; border-collapse: collapse; font-size: 9pt; margin-bottom: 8px; }
            table.error th { text-align: left; background-color: lightsteelblue; padding: 4px 4px 4px 4px; }
            table.error td { border: 1px solid lightsteelblue; padding: 4px 4px 4px 4px; }
            .title { background-color: white; }
            .namespace { color: navy; }
            .method { font-weight: bold; }
            .type { color: green; }
            .var { color: gray; }
            .trace { padding-left: 2em; text-indent: -2em; font-size: 8pt; }
        style>

        <xsl:copy-of select="Exceptions/Header/*"/>

        
        <xsl:for-each select="Exceptions/Exception">
            <table class="error">
                <tr>
                    <th>
                        <xsl:value-of select="@Type"/>
                    th>
                tr>
                <tr>
                    <td>
                        <xsl:value-of select="@Message"/>
                    td>
                tr>
                <xsl:if test="StackTrace/Method">
                    <tr>
                        <td colspan="2">
                            <xsl:for-each select="StackTrace/Method">
                                <div class="trace">
                                    <span class="namespace">
                                        <xsl:if test="@Namespace">
                                            <xsl:value-of select="@Namespace"/>
                                            <xsl:text>.xsl:text>
                                        xsl:if>
                                        <xsl:if test="@Type">
                                            <xsl:value-of select="@Type"/>
                                            <xsl:text>.xsl:text>
                                        xsl:if>
                                        <span class="method">
                                            <xsl:value-of select="@Method"/>
                                        span>
                                    span>
                                    <xsl:text>(xsl:text>
                                    <xsl:for-each select="Parameter">
                                        <xsl:if test="position()>1">,xsl:if>
                                        <xsl:if test="@Type">
                                            <xsl:text> xsl:text>
                                            <span class="type">
                                                <xsl:value-of select="@Type"/>
                                            span>
                                        xsl:if>
                                        <xsl:text> xsl:text>
                                        <span class="var">
                                            <xsl:value-of select="@Name"/>
                                        span>
                                    xsl:for-each>
                                    <xsl:text> )xsl:text>
                                div>
                            xsl:for-each>
                        td>
                    tr>
                xsl:if>
            table>
        xsl:for-each>

    xsl:template>

xsl:stylesheet>

Disabling HTML Input Elements

Chris Cavanagh — Thu, 28 May 2009 19:36:21 +0000

If you’re using IE, you can disable all input elements inside a div by setting “disabled=true”. Unfortunately (thanks to standards compliance nonsense ) it doesn’t work anywhere else.

If you’re using jQuery, take a look here. If not, this bit of script might help:

function SetDisabledStates( container, newStates )
{
    var states = [];

    var replace = function( element )
    {
        states[ element.id ] = element.disabled;
        element.disabled = isArray( newStates ) ? newStates[ element.id ] : newStates;
    };

    var inputs = container.getElementsByTagName("input");
    for ( var i = 0; i < inputs.length; ++ i ) replace( inputs[ i ] );

    var selects = container.getElementsByTagName( "select" );
    for ( var i = 0; i < selects.length; ++ i ) replace( selects[ i ] );

    return states;
}

function isArray( obj )
{
   return obj.constructor.toString().indexOf("Array") != -1;
}

To preserve and override the states, do something like this:


var disabledStates = SetDisabledStates( myContainer, true );

Then to restore the states, do this:


SetDisabledStates( myContainer, disabledStates );

HomeLight – 100% Silverlight website, plus physics

Chris Cavanagh — Sat, 23 May 2009 00:27:10 +0000

Speaks for itself: http://rene-schulte.info/ It almost works with Moonlight Preview 3 too! (fingers crossed Preview 4 will nail it ).

Unfortunately I didn’t write or have anything to do with the site; I just thought it looked cool

ASP.NET 4.0 Beta 1 and IIS App Pools

Chris Cavanagh — Thu, 21 May 2009 16:42:41 +0000

If you install .NET 4.0 Beta 1 on a machine that also needs to run ASP.NET 1.1 applications, you may need to tweak some IIS settings. The Beta 1 installer appears to assign .NET 4.0 to all existing application pools. Make sure your ASP.NET 1.1 pool looks like this:

Hope this helps!

ASP.NET WebForm Routing with SiteMaps

Chris Cavanagh — Wed, 20 May 2009 04:36:08 +0000

I’ve updated my ASP.NET WebForm Routing demo with basic SiteMap support. It’s targeting ASP.NET 3.5 SP1 and expects your WebForm (Page) to implement the IRoutablePage interface (or you can derive from RoutablePage). If you’re using ASP.NET 4.0 you can omit this dependency (as RequestContext is already available on the Page ).

SiteMap raises the SiteMapResolve event whenever its CurrentNode property is read. This gives you an opportunity to determine the current node based on the route, without requiring a custom SiteMapProvider. The example below takes the current route URL, removes any route values and looks for a matching SiteMapNode:

private SiteMapNode SiteMap_SiteMapResolve( object sender, SiteMapResolveEventArgs e )
{
    var routable = e.Context.CurrentHandler as IRoutablePage;

    if ( routable != null )
    {
        var rc = routable.Routing.RequestContext;
        var route = rc.RouteData.Route;
        var segments = route.GetVirtualPath( rc, null ).VirtualPath.Split( '/' );
        var path = "~/" + string.Join( "/", segments.Take( segments.Length - rc.RouteData.Values.Count ).ToArray() );

        return SiteMap.Provider.FindSiteMapNodeFromKey( path );
    }

    return null;
}

You create a .sitemap file in the usual way, but put your “routed” URLs in instead:

xml version="1.0" encoding="utf-8" ?>
<siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0" >
    <siteMapNode url="~/" title="Home" description="Home">
        <siteMapNode url="~/Search" title="Search" description="Search" />
        <siteMapNode url="~/Details" title="Details" description="Details" />
        <siteMapNode url="~/NoMaster" title="No Master" description="No Master">
            <siteMapNode url="~/NoMaster/MySub" title="My Subpage" description="My Subpage"/>
        siteMapNode>
    siteMapNode>
siteMap>

You can use the regular SiteMapPath control to show the current location. However, you might prefer to render your own. The sample project includes a couple of helper methods to achieve just that:

/// 
/// Gets SiteMap path for the current request.
/// 
/// 
public string SiteMapPath()
{
    var pages = SiteMap.CurrentNode.For( n => n != null, n => n.ParentNode ).Reverse().Select( n => SiteMapLink( n ) );

    return string.Join( " > ", pages.ToArray() );
}

/// 
/// Gets a SiteMap link.
/// 
/// The node.
/// 
private string SiteMapLink( SiteMapNode node )
{
    var span = string.Format( "{0}", node.Title );

    return ( node != SiteMap.CurrentNode )
        ? string.Format( "{1}", node.Url, span )
        : span;
}

You can read more about the “For” extension method in my earlier post.

Source code for the sample project is available on CodePlex. You can try the demo online right here .

IF + Silverlight + Linux … Almost!

Chris Cavanagh — Tue, 19 May 2009 06:04:11 +0000

Using the latest preview of Moonlight 2.0, SilverGlulxe (Interactive Fiction interpreter) is [almost] running on Linux!

Here’s what it currently looks like:

Text is missing formatting (there should be some bold and italic in there) and the Enter key doesn’t work, which makes it tricky to give it commands Also the scale slider has some issues (text not reformatting to fit when it’s resized). Other than that it’s looking great!

SilverGlulxe does some interesting things with threads, so it could be that’s behind the “Enter issue”. I’ll probably wait a few more [Moonlight] previews, then have a closer look at my code…

More Extension Methods

Chris Cavanagh — Tue, 19 May 2009 05:35:17 +0000

Here are a couple more extension methods you may find useful:

Collection splitter:

Split a collection into a sequence of fixed-size groups:

/// 
/// Splits the specified items into fixed-size groups.
/// 
/// 
/// The source.
/// The group size.
/// Returns collection of groups.
public static IEnumerableint, T>> Split( this IEnumerable source, int size )
{
    var index = 0d;

    return source.GroupBy( v => (int)( ( index++ ) / size ) );
}

You could use it like this:

var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
var chunks = items.Split( 5 );

“For” enumerator:

Generate a sequence of elements like a for loop:

/// 
/// Generates a sequence of elements while  is .
/// 
/// 
/// The initial value.
/// A predicate to control continuation of the sequence.
/// A function to retrieve the next element.
/// Returns a sequence of elements.
public static IEnumerable For( this T value, Predicate predicate, Func selector )
{
    while ( predicate != null && predicate( value ) )
    {
        yield return value;

        value = ( selector != null ) ? selector( value ) : default( T );
    }
}

It’s good for making non-enumerable sequences enumerable:

var pages = SiteMap.CurrentNode.For( n => n != null, n => n.ParentNode ).Reverse();

return string.Join( " > ", pages.Select( p => p.Title ).ToArray() );

Comments, suggestions and improvements always welcome!