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
Using Constructors  27 Feb 2023
An Inconvenient API  18 Feb 2023
Method Archetypes  11 Sep 2022
A bash puzzle, solved  02 Jul 2022
A bash puzzle  25 Jun 2022
Improve your troubleshooting by aggregating errors  11 Jun 2022
Improve your troubleshooting by wrapping errors  28 May 2022
Keep your promises  14 May 2022
When are you done?  18 Apr 2022
Fixing GitHub Authentication  28 Nov 2021
Archives
April 2009
2009