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
Avoid hardcoded wait times  26 May 2018
Guaranteed Progression  19 May 2018
Prefer declarative method names  03 Feb 2018
Using Premeditation  27 Jan 2018
With Relocation  20 Jan 2018
Using Consolidation  13 Jan 2018
Using Semantic Types  06 Jan 2018
Using Extension Methods  30 Dec 2017
Error Methods  25 Nov 2017
Pass implementations, not representations  14 Oct 2017
More smart-code posts »
Archives
April 2009
2009