NetFXHarmonics (Online Home of David Betz [MVP])

NetFXHarmonics Code Annotation Format

dfb@davidbetz.net — Fri, 24 Apr 2009 11:30:07 -0500

If you look at any of my open-source projects or even the Themelia source code, you will see that I use a special type of coding annotation. The annotation format I designed (based on the designs of Sky Morey at Digital Evolution Group) is intended to maximize code readability and understandability. The format is NOT a coding standard, but just what it says: an annotation format.

What’s that means? Essentially when you are reading code you are constantly parsing all the symbols that you see. Your brain can only work so fast, though, and some things have a higher parsing latency than others. For example, VB code is incredibly verbose and uses long symbols to representing even the smallest things. It will use the symbol “Then” where C# will use the symbol “}” (to some it may seem odd to think of a word as a symbol, but that’s all it is—you never read ever letter of a word you know. If you know the word, your brain treats it as a symbol, not a series of symbols.) It will also use two different character sets (what we call upper case and lower case) interchangeably, thus ever increasing the latency. Though C# was designed with extremely low latency in mind, it, like all other languages, still has excess latency.

Thus, my code annotation format comes on the scene to make mental code parsing extremely fast. It covers everything from how to case comments, when NOT to write comments, when to add metadata to class members, and how to deal with line breaks (the cardinal rule of the format!) Most importantly, every annotation rule has an extensive commentary explaining why the rule exists and what value it provides in the long run.

Now, as with ALL THINGS EVERYWHERE, when you first start to apply it, it’s going to seem odd and it will slow you down at first. After time, however, you will become extremely efficient at it and your code readability should dramatically improve. When this is used in groups, it should seriously lower decrease the time it takes to read and understand the purpose of code.

You can view the NetFXHarmonics Code Annotation Format at http://www.netfxharmonics.com/document/code/format.

New Silverlight 3 Features

dfb@davidbetz.net — Mon, 20 Apr 2009 22:29:13 -0500

Though I’m a member of the Silverlight 3 Early Adopter’s Program (and thus have been getting weekly builds of Silverlight long before the public beta), I’m probably not going to be writing anything about the new features. This isn’t because Silverlight 3 is boring, but, rather, because I have a strict policy of never doing something that other’s are already doing. So, I would like to direct your attention to a few web sites showing the awesome provided by Silverlight 3 (and you won’t find business-application boringness here).

First, Tim Huerer has a nice post giving a very quick rundown of the new features:

http://timheuer.com/blog/archive/2009/03/18/silverlight-3-whats-new-a-guide.aspx

Second, Jeff Prosise’s blog shows some of the cooler features of Silverlight 3. Maybe it’s just because I absolutely HATE business application development, but I find Jeff’s blog to be 100x more interesting than the “how to write use X to write your boring line-of-business application.” His work is also not for the naive or faint of heart. Instead, it’s for professional developers (i.e. the extremely rare people who aren’t afraid to do things the right way.) If Jeff adds more stuff, I’ll add them to this list.

Finally, you can always head over to the Mix ‘09 web site and watch some Silverlight 3 (and 2) videos. Most of them also have PowerPoint files associated with them. Personally, I can’t stand the torture of listening to someone take 30 minutes to say something that I can ready in 3 minutes. That’s one reason I turned Microsoft down when they asked me to turn my Understanding WCF Services in Silverlight 2 into a talk at Mix. Boring. Here’s the Mix link:

Jeff Prosise’s Silverlight Tips

dfb@davidbetz.net — Fri, 10 Apr 2009 22:10:10 -0500

This post may be completely meaningless to most of the developers out there as it deals with my type of development: non-business application development. More specifically, Jeff Prosise of Wintellect (the Navy SEALs of .NET) has posted a few really nice tips and tricks for Silverlight development. These are really great tricks that serve as great examples of some of the more powerful things you can do with Silverlight:

CitationAttribute for Citing Work

dfb@davidbetz.net — Sat, 04 Apr 2009 03:28:12 -0500

As a researcher, designer, and open-source developer, it's very important to me to both cite the work I reference as well as to be cited appropriately. Few things are more lame than finding my research some place on CodePlex disguised work different working under someone else's name... or a file from one of my many open-source systems in someone else's project without my copyright information.

To help me keep track of where a file or piece of research came from, I wrote a quick attribute to help keep some of this metadata around: CitationAttribute. This is in my Themelia Framework and I use it extensively in my projects to keep track of where research and files came from. Below is an example of how to use the attribute. Fritz Onion was kind enough to allow me to include his ViewState parser in my work. Notice the metadata in the attribute:

[Citation("http://www.pluralsight.com/fritz/", Copyright = "Copyright (c) 2008 Fritz Onion", DateUpdated = "03/25/2008")]
public static class ViewStateXmlBuilder
{
    //+ implementation here
}

Here you can see that the reference source is cited as well as the copyright and date the local file was updated with the appropriate version. Note that this does not replace a file copyright. I asked Fritz for a complete copyright comment block and he provided that for me. Above the actual file I include with my Themelia Framework is his actual C# comment stating his actual copyright/disclaimer.

Here's the CitationAttribute as seen in my Themelia Framework:

#region Copyright
//+ Themelia Framework 2.0 - Core Module
//+ Copyright © Jampad Technology, Inc. 2007-2009
//+
//+ This file is a part of the Themelia Framework.
//+ The use and distribution terms for this software are covered by the
//+ Microsoft Permissive License (Ms-PL) which can be found at
//+ http://www.microsoft.com/opensource/licenses.mspx.
#endregion
using System;
//+
namespace Themelia
{
    /// <summary>
    /// Used to signify that a particular type was pulled from a third part project or piece of research.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)]
    public class CitationAttribute : Attribute
    {
        private readonly String _source;

        //+
        //- @Copyright -//
        /// <summary>
        /// Represents the copyright of the referenced entity.
        /// </summary>
        public String Copyright { get; set; }

        //- @DateUpdated -//
        /// <summary>
        /// Represents the date the local version was updated with the referenced entity.
        /// </summary>
        public String DateUpdated { get; set; }

        //- @DateUpdated -//
        /// <summary>
        /// Represents the 2 (i.e. "en") or 5 (i.e. "en-US") character culture used to format the date (default = en-US)
        /// </summary>
        public String DateCulture { get; set; }

        //- @License -//
        /// <summary>
        /// Represents the license associated with this file (e.g. BSD, MIT, LGPL, Public Domain; default = Custom). This property is not legally binding.  It should only be used as a means of finding the general direction of where to look for the legally binding license.
        /// </summary>
        public String License { get; set; }

        //+
        //- @Ctor -//
        public CitationAttribute(String Source)
        {
            _source = Source;
            //+
            DateCulture = "en-US";
            License = "Custom";
        }
    }
}

There are a few things to notice about this attribute. First, there is also a property for DateCulture. This is very important. Depending on your culture 05 03 2009 or 03 05 2009 may be March 5th. Second, there's a License property. In this example, it's "Custom". As another example, if you were to cite Themelia, you would use "Ms-PL" as your License. Third, the source is required. It's not that it absolutely has to be a URL, but it's definitely required nonetheless.

Where should you use this file? Anywhere you cite someone's research, where you use someone's file, or derive from their work. This doesn't mean only in places where you copy/paste a class from another person's framework. This also means in places where you find an article online and you use the research in that article to write your own class.

For example, if you were looking online for a solution to create a solution for getting Silverlight to access the clipboard (the mother of all security breaches, but whatever!) and you find a blog post about that, then when you write your classes to use that, you need to cite the blog post. If you don't, then you are depriving a future developer from seeing the commentary of that code. By citing the research with the attribute, you are telling the future reader where to see the research. In the case of using a someone else's files, the attribute will tell future developer's (and you) where to find the updated version.

Exception Handlers for Silverlight 2.0

dfb@davidbetz.net — Tue, 31 Mar 2009 23:27:31 -0500

Whereas Themelia is my foundation for all .NET development, it’s a little known fact that I have an internal build of it specifically used for Silverlight. Among the many features of Themelia for Silverlight (hereafter called “ThemeliaSL”) is something I call Exception Handlers. This isn’t the same thing as the “catch” block of a try/catch. No, it’s a concept specific to Silverlight. Also, this is a fairly discrete feature that you can implement in your own Silverlight applications without the need of my full framework. However, before you can understand this feature, you need to understand Silverlight currently works with unhandled exceptions.

When Silverlight throws an exception that’s unhandled, it eventually gets bubbled up to your System.Windows.Application instance. If you are handling the UnhandledException event of this class, then you have an opportunity to handle this exception on your own. When your UnhandledException event handler is called, you are passed an instance of System.Windows.ApplicationUnhandledExceptionEventArgs. In this class you are provided a property named ExceptionObject of type System.Exception which holds the actual exception object that has been thrown. There’s one other property though: Handled. This property is a boolean which provides you with the ability to say whether you handled the exception or not. If you set this property to true, then you are telling Silverlight that the problem has been taken care of. If you set it to false, then you are telling Silverlight that it’s about to die.

That’s really all there is to Silverlight exception handling. You can, however, make things a bit more streamlined. Say, for example, you know of various types of exceptions that your application or underlying frameworks will throw. You also know that you want to handle some of them in a specific way. Or maybe, you just don’t want any communications exceptions to ever be sent back to the client. For situations like these, you can use the concept I refer to as exception handlers.

Before we implement this concept, lets see how it will be used first:

public class Application : Themelia.Windows.Application
{
    public Application()
        : base()
    {
        AddExceptionHandler(typeof(CommunicationException), delegate(Exception ex)
        {
            if (ex.InnerException == null)
            {

                ReportExceptionToFirebug(ex.InnerException);
                return true;
            }
            //+ 
            return false;
        });
    }
}

Essentially, call the base constructor of the Application class we are about to create. Then, for each exception that you want to handle, register it with the AddExceptionHandler method, sending it the type of the exception and a delegate of type Func<Exception, Boolean>. In this example, when an unhandled exception of type CommunicationException is thrown, we automatically check to see if it has an inner exception. If so, we report the exception in a special way and mark the exception as handled.

You could also add more exception handlers. Here’s another example:

AddExceptionHandler(typeof(ArgumentException), delegate(Exception ex)
{
    ReportValidationError(ex);
    return true;
});

While this example is a rather silly one (because validation shouldn’t throw exceptions!), it does go to show you this is essentially a declarative model for exception handling. Now it’s time to move on to build the thing.

First, create your own abstract version of System.Windows.Application. This is typically a good idea anyways. It allows you to control your applications in a very streamlined manner. In this class, add the following static member:

private static Dictionary<Type, Func<Exception, Boolean>> HandlerRegistry = new Dictionary<Type, Func<Exception, Boolean>>();

This represents a registry of all exceptions handlers registered to your application. It’s a dictionary with the key representing the Type of the exception and the value representing a delegate to be called when that exception is raised.

You’ll also need a standard .NET locking object:

private static Object _lock = new Object();

Now add the following method:

//- #AddExceptionHandler -// 
protected void AddExceptionHandler(Type type, Func<Exception, Boolean> handler)
{
    lock (_lock)
    {
        HandlerRegistry.Add(type, handler);
    }
}

This will allow you to register exception handlers from your concrete instance of your custom application class.

Now it’s on to the meat of the implementation. In your base class application class constructor, handle the UnhandledException event.

this.UnhandledException += new EventHandler<System.Windows.ApplicationUnhandledExceptionEventArgs>(OnUnhandledException);

Then, in the method that will be called upon the event being raised, do something like this:

//- #OnUnhandledException -// 
protected virtual void OnUnhandledException(Object sender, ApplicationUnhandledExceptionEventArgs ea)
{
    lock (_lock)
    {
        if (HandlerRegistry.Count > 0)
        {
            Exception exception = ea.ExceptionObject;
            Type type = exception.GetType();
            if (HandlerRegistry.ContainsKey(type))
            {
                ea.Handled = HandlerRegistry[type](exception);
            }
        }
    }
    if (!System.Diagnostics.Debugger.IsAttached && this.AutoReportErrorToDOM && !ea.Handled)
    {
        ea.Handled = true;
        Deployment.Current.Dispatcher.BeginInvoke(delegate { ReportErrorToDOM(ea); });
    }
}

Essentially, if there are any registered handlers, check to see if the currently thrown exception is one of those exception registered to be handled. If so, then pull the delegate from the registry and call it.

Notice that the delegate that we registered is Func<Exception, Boolean>. Functionally, this means is that the delegate will accept an Exception object and return a boolean. Interpreted, this means that in the delegate you register you need to return a boolean representing whether you want the exception handled or not.

You may also notice in the above code that there is a property named AutoReportErrorToDOM. This does exactly what it says and it’s nothing too exciting:

//- @AutoReportErrorToDOM -// 
public Boolean AutoReportErrorToDOM { get; set; }

The ReportErrorToDOM method is the same one that Visual Studio 2008 throws in with the Silverlight template. For completeness, here it is:

//- #ReportErrorToDOM -// 
protected void ReportErrorToDOM(ApplicationUnhandledExceptionEventArgs ea)
{
    try
    {
        String errorMsg = ea.ExceptionObject.Message + ea.ExceptionObject.StackTrace;
        errorMsg = errorMsg.Replace('"', '\'').Replace("\r\n", @"\n");
        System.Windows.Browser.HtmlPage.Window.Eval("throw new Error(\"Unhandled Error in Silverlight 2 Application " + errorMsg + "\");");
    }
    catch (Exception)
    {
    }
}

At this point, you have everything you need to make the samples that we went through work properly. Just be sure to base your application class on the new one and you’ll be set.

One important note is that when you are using custom visual entities in Silverlight, you need to make sure that you properly register the namespace in XAML. For example, say the above class was called “Application” in the “Themelia.Windows” CLR namespace in the “Themelia.Silverlight” assembly. For this configuration, you would use the following xaml:

<t:Application 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:t="clr-namespace:Themelia.Windows;assembly=Themelia.Silverlight" 
    x:Class="Sample.Application" />

With this, you’re all set.

Tip: Quick Reflector Loading for .NET and Silverlight

dfb@davidbetz.net — Wed, 18 Mar 2009 22:23:08 -0500

In my daily development there are three tools that I keep open almost constantly: Visual Studio 2008, Windows Debugger, and Reflector. The first is obvious, the second is for extreme-debugging, and the third so I can have a clue what I’m working with (...I have NO idea how people do .NET or Silverlight development without reflector!) The first two I access with icons, while the third is one that I open and close at least 10 times a day.

To quickly access reflector (as well as Notepad2 and a whole host of sysinternals apps!) I throw it in my Windows folder so I can access it from the Run box. Not only that, but I typically rename tools I throw in there to have only one letter. Reflector is “r”. So, I hit Win-R and type “r”. Up comes reflector. Here’s the thing though: I work in both .NET and Silverlight equally. Yet, Reflector only loads ONE of them. What to do?

The fix is simple: copy r.exe to rs.exe. When I load r.exe, I select .NET. When I load rs.exe, I select Silverlight. Now I when I hit Win-R, I can type either “r” or “rs” depending on what framework I want to inspect. You could even take the concept further by making a “rf.exe” for the compact framework” Each “x.exe” will have it’s own “x.cfg” so the configurations won’t bleed over each other.

Thanks for the feedback ! (Re: Understanding WCF Services in Silverlight 2)

dfb@davidbetz.net — Sat, 07 Mar 2009 14:21:07 -0600

A few months back I published a document on my web site entitled "Understanding WCF Services in Silverlight 2". I wrote this document so people could have a solid understand of how to use WCF as well as some of the core WCF best practices. The document explains everything from data contracts to service contracts, from asynchronous communication to SSL security, and from fault management to JSON communication. It did this for both .NET as well as Silverlight.

Well, goodness, it's definitely met my expectations. It's quickly become the absolute top most traffic mover on my web site. It even flew by my JavaScript Graphics Development publication, which was a traffic mover very hard to beat. The document also ended up on the Microsoft WCF homepage for three months and... a Senior Program Manager of the Connected Systems division even asked me to speak at the Mix conference on the topic of the document (of course I turned him down... it's just so much easier NOT to speak at a conference.)

So, thanks to everyone to came to the web site to read the document online or to download the PDF or XPS version of it. Thanks also to everyone who left positive feedback on the web site. Apparently, the document really has helped a lot of people in their pursuit to understand WCF better. As I expected (well, as I knew!), people are sick and tired of the same old boring drag-n-drop videos and template-based file creation nonsense which prohibits the actual learning of the technology.

Given the absolutely astounding lack of respect and gratitude I get in person, the comments from the web site have gone a long way in helping convince me that I should continue my research and publication of this type of material. It's my hope that people continue to find benefit in my research and continue to take the time to drop me a line telling me it was helpful.

Adding XmlNode to Silverlight

dfb@davidbetz.net — Tue, 17 Feb 2009 21:42:55 -0600

Of the many types of data I work with, XML shows up all the time. However, when working in Silverlight, your XML options are dramatically limited. For example, for some reason Microsoft totally forgot to add a simple XmlNode class. Microsoft seems to think that using LINQ for XML will solve all our XML problems. Well, most of the stuff that I do on a daily basis has nothing to do with extensive querying XML. I just need something simple to pull quick data. Not only that, but LINQ for XML is in the System.Xml.Linq assembly, which is not a native Silverlight assembly. I’m not going to bloat my XAP file for a single dependency.

So, in my internal build of Themelia for Silverlight, you will find the Themelia.Xml.XmlNode class. I use this all over the build entire XML trees and to search the same tree for elements I need. All this in one small discrete class that doesn’t require you to bloat your XAP file. Here’s a sample of how to use my XmlNode class:

XmlReader reader = XmlReader.Create(new StringReader(@"<s:Envelope xmlns:s=""http://schemas.xmlsoap.org/soap/envelope/"">
    <s:Body>
    <s:Fault>
      <faultcode>s:Client</faultcode>
      <faultstring xml:lang=""en-US"">This is the fault reason.</faultstring>
      <detail>
        <FaultDetail xmlns=""http://schemas.datacontract.org/2004/07/Sample.Service"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">
          <Reason>This is the fault reason.</Reason>
          <Source>GetPersonData</Source>
        </FaultDetail>
      </detail>
    </s:Fault>
    </s:Body>
    </s:Envelope>"));
XmlNode node = new XmlNode(reader);
XmlNode faultDetailNode = node.FindDescendant("faultDetail");
stackpanel01.Children.Add(new TextBlock
{
    Text = faultDetailNode.FirstChild.TextContent
});
stackpanel01.Children.Add(new TextBlock
{
    Text = faultDetailNode.AttributeDictionary["xmlns"]
});
stackpanel01.Children.Add(new TextBlock
{
    Text = faultDetailNode.AttributeDictionary["xmlns:i"]
});

It does a few more things that you can see by looking at the source for it, but this is essentially all I need in for XML processing on most days. Here’s the source for XmlNode.cs:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml;
//+
namespace Themelia.Xml
{
    public class XmlNode
    {
        //- @Name -//
        public String Name { get; set; }

        //- @TextContent -//
        public String TextContent { get; set; }

        //- @Children -//
        public List<XmlNode> NodeList { get; set; }

        //- @AttributeMap -//
        public Dictionary<String, String> AttributeDictionary { get; set; }

        //- @FirstChild -//
        public XmlNode FirstChild
        {
            get
            {
                if (NodeList.Count > 0)
                {
                    return NodeList[0];
                }
                //+
                return null;
            }
        }

        //+
        //- @Ctor -//
        private XmlNode()
        {
            NodeList = new List<XmlNode>();
            AttributeDictionary = new Dictionary<String, String>();
        }
        public XmlNode(XmlReader xmlReader)
            : this()
        {
            Initialize(xmlReader);
        }
        public XmlNode(Stream xmlStream)
            : this(XmlReader.Create(xmlStream))
        {
        }
        public XmlNode(String name)
            : this()
        {
            Name = name;
        }

        //- $Initialize -//
        private void Initialize(XmlReader reader)
        {
            reader.Read();
            this.Name = reader.Name;
            //+ attribute
            reader.MoveToElement();
            if (reader.HasAttributes)
            {
                reader.MoveToFirstAttribute();
                AttributeDictionary.Add(reader.Name, reader.Value);
                while (reader.MoveToNextAttribute())
                {
                    AttributeDictionary.Add(reader.Name, reader.Value);
                }
            }
            //+ node
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    NodeList.Add(new XmlNode(reader.ReadSubtree()));
                }
                else if (reader.NodeType == XmlNodeType.Text)
                {
                    TextContent = reader.ReadContentAsString();
                }
            }
        }

        //- @FindDescendant -//
        public XmlNode FindDescendant(String name)
        {
            XmlNode foundNode = NodeList.FirstOrDefault(p => p.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase));
            if (foundNode != null)
            {
                return foundNode;
            }
            foreach (XmlNode node in NodeList)
            {
                foundNode = node.FindDescendant(name);
                if (foundNode != null)
                {
                    return foundNode;
                }
            }
            //+
            return foundNode;
        }

        //- @FindDescendantList -//
        public List<XmlNode> FindDescendantList(String name)
        {
            List<XmlNode> nodeList = new List<XmlNode>();
            XmlNode foundNode = NodeList.FirstOrDefault(p => p.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase));
            if (foundNode != null)
            {
                nodeList.Add(foundNode);
                foundNode = null;
            }
            foreach (XmlNode node in NodeList)
            {
                foundNode = node.FindDescendant(name);
                if (foundNode != null)
                {
                    nodeList.Add(foundNode);
                    foundNode = null;
                }
            }
            //+
            return nodeList;
        }

        //- @GetChildDictionary -//
        public Dictionary<String, String> GetChildDictionary()
        {
            Dictionary<String, String> map = new Dictionary<String, String>();
            foreach (XmlNode node in NodeList)
            {
                if (!String.IsNullOrEmpty(node.TextContent))
                {
                    map.Add(node.Name, node.TextContent);
                }
            }
            //+
            return map;
        }
    }
}

Yeah, there’s more it could probably do and I’ll probably add more to it in the future, but this little class has worked in all my XML scenarios so far.

Obtaining Enumeration Names and Values in Silverlight 2.0

dfb@davidbetz.net — Thu, 12 Feb 2009 22:16:04 -0600

In .NET, when you are dealing with singular enumerations (the ones singular names) or flags enumerations (the ones with plural names), you have the ability to access the names and values of each of the items in the enumeration. For example, the below code iterates through and prints out both the values and names of the enumeration items:

using System;
//+
namespace Sample
{
    public enum Component
    {
        Keyboard,
        Mouse,
        Display,
        Disk,
        Memory,
        Network
    }

    public class Program
    {
        //- $Main -//
        private static void Main(String[] args)
        {
            //+ name
            foreach (String name in Enum.GetNames(typeof(Component)))
            {
                Console.WriteLine(name);
            }
            //+ value
            foreach (Object value in Enum.GetValues(typeof(Component)))
            {
                Console.WriteLine((Int32)value);
            }
        }
    }
}

Now let’s go to do the same thing in Silverlight 2.0.

Err... wait a minute. Where’s GetNames and GetValues? Well, they don’t exist. Fortunately, we have the ability to access these via reflection. To obtain the names, we just need to obtain the Type object of our enumeration and call GetFields with the Public and Static binding flags set, and look in the resulting FieldInfo array. Each FieldInfo object will have a Name property without item name. For the values, we simply use Enum.Parse to turn that name into the actual value. For the underlying value, we can just cast that to the underlying type of the enumeration. In the example above, that would be System.Int32. Here’s all that in action:

//- $OnLoaded -//
private void OnLoaded(Object sender, System.Windows.RoutedEventArgs e)
{
    Type enumType = typeof(Component);
    System.Reflection.FieldInfo[] fiArray = enumType.GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
    foreach (System.Reflection.FieldInfo fi in fiArray)
    {
        //+ name
        sp01.Children.Add(new TextBlock
        {
             Text = fi.Name
        });
    }
    foreach (System.Reflection.FieldInfo fi in fiArray)
    {
        //+ value
        sp01.Children.Add(new TextBlock
        {
            Text = ((Int32)Enum.Parse(enumType, fi.Name, false)).ToString()
        });
    }
}

I’ve left the namespaces of the items in the System.Reflection namespace in place so you can see exactly what types were working with here.

Of course, you can always wrap this up into it’s own class so you can reuse this logic all over:

namespace Themelia
{
    public class EnumReader
    {
        /// <summary>
        /// Gets the names of an enumeration type.
        /// </summary>
        /// <param name="enumerationType">Type of enumeration.</param>
        /// <returns>List of names of the enumeration.</returns>
        public static List<String> GetNameList(Type enumType)
        {
            if (!enumType.IsEnum)
            {
                throw new InvalidOperationException("Specified generic parameter must be an enumeration.");
            }
            List<String> nameList = new List<String>();
            //+ type
            FieldInfo[] fiArray = enumType.GetFields(BindingFlags.Public | BindingFlags.Static);
            foreach (FieldInfo fi in fiArray)
            {
                nameList.Add(fi.Name);
            }
            //+
            return nameList;
        }

        //- @GetNameList -//
        /// <summary>
        /// Gets the names of an enumeration type.
        /// </summary>
        /// <typeparam name="T">Type of enumeration.</typeparam>
        /// <returns>List of names of the enumeration.</returns>
        public static List<String> GetNameList<T>() where T : struct
        {
            return GetNameList(typeof(T));
        }

        //- @GetValueList -//
        /// <summary>
        /// Gets the values of an enumeration type.
        /// </summary>
        /// <typeparam name="T">Type of enumeration.</typeparam>
        /// <returns>List of values of the enumeration.</returns>
        public static List<T> GetValueList<T>() where T : struct
        {
            Type enumType = typeof(T);
            if (!enumType.IsEnum)
            {
                throw new InvalidOperationException("Specified generic parameter must be an enumeration.");
            }
            List<T> valueList = new List<T>();
            FieldInfo[] fiArray = enumType.GetFields(BindingFlags.Public | BindingFlags.Static);
            foreach (FieldInfo fi in fiArray)
            {
                valueList.Add((T)Enum.Parse(enumType, fi.Name, false));
            }
            //+
            return valueList;
        }
    }
}

In this example class, you can see that two of the methods are actually declared as generic. So, to use them like this:

//- $OnLoaded -//
private void OnLoaded(Object sender, System.Windows.RoutedEventArgs e)
{
    foreach (String name in EnumReader.GetNameList<Component>())
    {
        //+ name
        sp01.Children.Add(new TextBlock
        {
            Text = name
        });
    }
    foreach (Component component in EnumReader.GetValueList<Component>())
    {
        //+ value
        sp01.Children.Add(new TextBlock
        {
            Text = ((Int32)component).ToString()
        });
    }
}

One thing to keep in mind is that reflection does have a performance hit. However, given that most of WPF, Silverlight, and WCF are all about constant reflection, you can rest comfortably that it’s not nearly as bad as some people would say. Having said that, if your application profiling does say that you are reflecting too much, you can always cache the data returned from these method and access the cache instead. Don’t however, cache for the sake of caching. Saying “We’re always going to cache, just to be consistent” is as stupid as saying “We’re always going to drive 45mph, just to be consistent.” This kills people on both the interstate and in school zones. Make your caching decisions (and ALL other decisions!) based upon your current situation never upon dangerous mindless consistency.

Silverlight Feature Requests

dfb@davidbetz.net — Wed, 21 Jan 2009 21:50:53 -0600

Silverlight is probably the most important technology to be released since Firefox 1.0 and that since .NET 1.0. However, as with most early-edition pieces of software, there are some major things missing. Below is a list of things that I request that Microsoft add with a quick note on each. It ranges from a few UI things to the more hardcore mechanical things (...things that many developers will say are meaningless until they learn how to spell C-L-R).

GIF Support - Obvious. It's very odd that some manager somewhere said "no one ever uses GIF anymore".
Style Inheritance - Another obvious one. We who knew WPF long before Silverlight was around THRIVE on this.
DockPanel - COME ON! You MUST be joking! I shouldn't have to use a third party CodePlex control for this.
VisualBrush - The ability to paint controls on a background and in other places will go a long way in helping people creating more interactive help files and training software.
RelativeSource - The ability to bind one element's property to another is EXTREMELY important (i.e. my height == my parent's height).
MultiView - It takes almost no code to write this; just make it native so we don't have dozens of versions all over.
WebHttpBinding for JSON - POX is less important, but would be nice; JSON is the de facto web standard.
System.Security.Cryptography.RSA with providers - This would greatly increase the security of client-server communication.
Workflow Foundation - Even a light version with only the basic activities (for, if, while, etc...) would be nice.
SVG Viewer - This should shut up the anti-Microsoft cult.
Better font rendering - It's HORRIBLE in 2.0.
iPhone Support - I think this may take a miracle.
MultiTouch - Need this for iPhone support.
CSS3 DOM Selector (http://www.w3.org/TR/selectors-api/) - So we use it instead of jQuery's version for closer-to-native speed on EVERY browser without even needing JQuery.
A XMLHttpRequest object - This would allow us to use Silverlight's CrossDomainPolicy.xml stuff for cross domain stuff instead of playing games with browser detection nonsense and adding hacks for browsers which don't support it.
API for browser abstraction - Web developers HATE having to do lame detection to figure out if we are on IE so we can talk to it like a child. Give us the ability to create managed extensions to Silverlight so we can add in our pain-in-the-butt browser differences in Silverlight instead of relying on painfully slow JScript rendering and browser detection.
Service for extensions - This goes with the last one. We should have the ability to 1) extend the hardcore functionality of Silverlight and 2) have a centralize service that Silverlight calls to download our functionality when our application requests it. This would be very just like what Firefox does when it needs a plugin. It would also do auto-updating like with Firefox extensions.
JSON deserializer that actually works to deserialize data serialized by the JSON serializer - JSON is critically important to the web; it should be supported better.
The ability to get 500 HTTP status codes from Firefox, Chrome, and IE - This would allow us to use fault contracts in WCF. This would have to be a pain to implement, though. So, I wouldn't expect it for a while.
The ability for NPCTRL to communicate CLR configuration information to the CoreCLR to tweak GC things that are normally in configuration - If the hosting NPCTRL control would just allow us to give it configuration parameters to send to the CoreCLR, that would RULE (like we can already do in .NET with configuration).
Hosting documentation that doesn't SUCK - Using Win32/ATL to host a Silverlight control is insane right now. The documentation is very incomplete and there are NO samples (and the IDL is wrong!)
Background GC on Windows - I suspect that this would increase performance in many scenarios.
The missing GC methods - The System.GC class is missing a PUBLICLY ACCESSIBLE GetCollectionCount. This will help us with profiling. It's marked as internal now and if you try to access it via reflection or other fancy tricks you get security errors.
ICorProfilerCallback interface - This is my NUMBER ONE FEATURE REQUEST! This is REQUIRED to create a Silverlight profiler. Silverlight will NOT be a technology ready for enterprise usage without this. PERIOD.
Documentation on Silverlight's ETW - it's there and it's working in SL2, but I see absolutely zero docs on how to access it.
The native AGCORE and NPCTRL source code - This will aide in performance and feature creation
COM interface for hosting the CoreCLR - not really a Silverlight feature, but this would be REALLY nice.