Sometimes we developers do things the hard way for no better reason that not knowing that a better way is there.

Here’s an example, posted with permission of the author:

XAttribute idAttribute = element.Attribute(XName.Get("id"));
XAttribute typeAttribute = element.Attribute(XName.Get("type"));
XAttribute isSystemCalculatedAttribute = element.Attribute(XName.Get("isSystemCalculated"));
XElement descriptionElement = element.Element(XName.Get("description"));
string name = string.Empty;
string type = string.Empty;
string description = string.Empty;
bool isSystemCalculated = false;

if (idAttribute != null)
{
    name = idAttribute.Value;
}

if (typeAttribute != null)
{
    type = typeAttribute.Value;
}

if (isSystemCalculatedAttribute != null)
{
    bool.TryParse(isSystemCalculatedAttribute.Value, out isSystemCalculated);
}

if (descriptionElement != null)
{
    description = descriptionElement.Value;
}

imputationMethodEntity.PutImputationInfo(name, type, isSystemCalculated, description);

This code works - it’s doing nothing more than setting up an object based on information available in an XElement.

Problem is, the code works too hard. What the author didn’t know at the time is this: There are predefined explicit casts on XAttribute that take care of the null checks for you.

For example, instead of

string name = string.Empty;
XAttribute idAttribute = element.Attribute(XName.Get("id"));
if (idAttribute != null)
{
    name = idAttribute.Value;
}

You may instead write this:

string name = (string) element.Attribute("id");

Using Reflector, we can look at the implementation of the string conversion and see how it works:

public static explicit operator string(XAttribute attribute)
{
    if (attribute == null)
    {
        return null;
    }

    return attribute.value;
}

This means that our original large block of code can be economically rewritten like this:

var name = (string) element.Attribute("id");
var type = (string)element.Attribute("type");
var description = (string)element.Element("description");
var isSystemCalculated = (bool) element.Attribute("isSystemCalculated");
imputationMethodEntity.PutImputationInfo(name, type, isSystemCalculated, description);

This pattern repeats itself throughout the .NET framework - features are waiting to be discovered, features that can save you a lot of work, if you could only find them.

I guess that’s the point - the discoverability of this kind of thing is poor.

But once you know, you’ll never look back.

Comments

blog comments powered by Disqus
Next Post
How not to set up Tests  17 Apr 2009
Prior Post
Defining Polymorphism  07 Apr 2009
Related Posts
Error Methods  25 Nov 2017
Pass implementations, not representations  14 Oct 2017
Avoiding the Singleton Pattern  22 Jul 2017
Implementing the Singleton Pattern  15 Jul 2017
Static Analysis tools for the Win  15 Apr 2017
Exception Logging  19 Jan 2016
On the Merits of Simple Code  28 Nov 2015
Semantic Types  27 Sep 2015
Command Line Processing  21 Sep 2014
Easy String Conversion  24 Aug 2014
More smart-code posts »
Related Pages
April 2009 archive