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