TryParse for the Compact Framework

One of the annoying things about the Compact Framework is that it doesn’t contain the TryParse methods that are found in the full framework.

At the company I work for we have some applications and common libraries that have both compact and full framework versions. Rather than repeat the code in each, we share the class files between the two projects (full/compact versions) and use conditional compilation where necessary to alter the code to match one framework or the other… unfortunately there isn’t a good and simple solution for the missing TryParse methods.

In theory it is possible to write your own functionally correct TryParse methods, but I haven’t yet done this (I intend to eventually). What I have done, in the meantime, to allow our code to compile is created a static ParseAssistant class. This class has static method overloads for all the usual TryParse methods we use, and our developers have been told to use these methods instead of the normal .NET ones. This means their code will compile on either framework… the only downside is that because I haven’t yet written ‘proper’ try parse code I have just conditionally compiled in (for the compact framework) a Parse with exception handling to report if the parse failed. This isn’t performant, but only applies in the compact framework and is easily rectified at a later time when it becomes a problem. In the meantime, should anyone else have the same problem here is the code we’re currently using;

/// <summary>
/// Contains methods to assist with parsing one value into another.
/// </summary>
public static class ParseAssistant
{
  #region TryParse Overloads
  /// <summary>
  /// Attempts to parse the string provided into an integer value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out int result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = Convert.ToInt32(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = int.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into a byte value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out byte result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = Convert.ToByte(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = byte.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into an Int16 value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out Int16 result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = Convert.ToInt16(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = Int16.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into an Int64 value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out Int64 result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = Convert.ToInt64(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = Int64.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into a decimal value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out decimal result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = Convert.ToDecimal(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = decimal.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into a float value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out float result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = (float)Convert.ToDecimal(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = float.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into a double value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out double result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = Convert.ToDouble(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = double.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into an sbyte value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out sbyte result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = (sbyte)Convert.ToInt32(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = sbyte.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into a uint value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out uint result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = (uint)Convert.ToUInt64(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = uint.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into a ulong value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out ulong result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = (ulong)Convert.ToUInt64(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = ulong.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into a ushort value. 
  /// </summary>
  /// <remarks>Returns 0 in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or zero if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out ushort result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = (ushort)Convert.ToUInt64(s);
            retVal = true;
        }
        catch (FormatException) { result = 0; }
        catch (InvalidCastException) { result = 0; }
#else
    retVal = ushort.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into an <see cref="System.DateTime"/> value. 
  /// </summary>
  /// <remarks>Returns <see cref="System.DateTime.MinValue"/> in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or <see cref="System.DateTime.MinValue"/> if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out DateTime result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = Convert.ToDateTime(s);
            retVal = true;
        }
        catch (FormatException) { result = DateTime.MinValue; }
        catch (InvalidCastException) { result = DateTime.MinValue; }
#else
    retVal = DateTime.TryParse(s, out result);
#endif
    return retVal;
  }
  /// <summary>
  /// Attempts to parse the string provided into an integer value. 
  /// </summary>
  /// <remarks>Returns false in the result parameter if the parse fails.</remarks>
  /// <param name="s">The string to attempt to parse.</param>
  /// <param name="result">The result of the parsed string, or false if parsing failed.</param>
  /// <returns>A boolean value indicating whether or not the parse succeeded.</returns>
  [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "s")]
  public static bool TryParse(string s, out bool result)
  {
    bool retVal = false;
#if WindowsCE
        try
        {
            result = Convert.ToBoolean(s);
            retVal = true;
        }
        catch (FormatException) { result = false; }
        catch (InvalidCastException) { result = false; }
#else
    retVal = bool.TryParse(s, out result);
#endif
    return retVal;
  }
  #endregion
}

You’ll need to add a ‘Conditional Compilation Symbol’ called WindowsCE to the project build properties of your compact framework projects for the conditional compilation to work correctly.

Obviously you could turn these into extension methods where supported, but as I work mostly in the .NET 2.0 framework I haven’t done this.

---

Technorati Tags: Parse,TryParse,Compact Framework,Full Framework,C#,.Net,Code Sample

The WTF Operator

Do you know what the ?? operator does ? I like to call it the WTF operator, as a lot of people have never seen it and can’t pick what it does immediately and because it’s not uncommon to see ?? after WTF (WTF??). It’s actually called the null-coalescing operator.

Basically it returns the value to the left of itself if that value is NOT null, else it returns the value to the right. For example, the following code sets ‘customer’ to either the m_Customer field or a new Customer object depending on whether or not m_Customer is null;

CustomerBase customer = m_Customer ?? new Customer();

Of course you can nest the ?? operator to build a form of coalesce statement;

private CustomerBase GetCustomer(CustomerBase customer)
{
    return m_Customer ?? customer ?? new Customer();
}

Whether you should or not is another question, as readability and maintainability are more important than conciseness.

Hmmm, conciseness… is that really a word ? Spell check seems to think so.

---

Technorati Tags: .Net,C#,Operator,??,WTF,Null

You Don't Know Jack About Software Maintenance | November 2009 | Communications of the ACM

Contender for "Quote of the Day" (from article below:

"In software, adding a six-lane automobile expressway to a railroad bridge is considered maintenance—and it would be particularly valuable if you could do it without stopping the train traffic."

You Don't Know Jack About Software Maintenance November 2009 Communications of the ACM

If the comments are ugly, the code is ugly | ITworld

If the comments are ugly, the code is ugly ITworld

Sandcastle Help File Builder (SHFB)

If you’re looking to create developer help from the xml comments in your code, I recommend Sandcastle Help File Builder (SHFB) along with Microsoft’s Sandcastle itself.

Version 1.7.0.0 is a great stable release and excellent for manual generation of code (I’ve never tried scheduling it, had problems using it from MSBuild).

Version 1.8.0.2 looks like a complete re-write so it uses MSBuild and MSBuild file formats, which makes it excellent for integrating into Team Foundation Server, but it’s still in the beta stage.

If you’re looking to download Sandcastle itself, try the Visual Studio 2008 SDK or the Visual Studio 2005 SDK one.

---

Technorati Tags: Documentation,Help,Sandcastle,Sand Castle Help File Builder,SHFB,Visual Studio,SDK

Conspiracy Theories: Planned Obsolescence and Deliberate Bugs

Something that really annoys me is when otherwise intelligent people start buying into conspiracy theories around software development and software companies. If I had a dollar for every time someone had suggested that software companies and developers either deliberately plan for their products to be obsolete just so they can charge for upgrade, or deliberately implant bugs in their code to force users to pay for upgrades then I’d be a very rich man.

If you believe this, trust me, you are dead wrong. A few quick Google’s for phrases '”How to write better code”, “Improving Code Quality”, and “Unit Testing” should show you how hard the industry works to prevent bugs in the first place and remove bugs that do occur. Millions, if not billions of dollars, and hours and hours are spent on this. We build tools, create methodologies, work slower, think more, change designs, change architectures, change technologies all in an effort to get eliminate bugs one way or another. The fact is that writing great code is hard, if not impossible. Eric Lippert has on his blog (Fabulous Adventures In Coding) suggested that it is not rocket science… that it is harder than that. And he’s not the first to have done so.

As for planned obsolescence, I guess there is an element of truth. When a software company or developer begins a new project or product, they likely realise on some level that there will be a version 2, or 3, or 4 so long as the company doesn’t go broke before then. Where this theory is wrong is that is suggests we do this to make money. Typically, we do this to cut costs. We often know we can’t survive as a business if we try to create the first version with every feature in it we want. If we think we can or try anyway, the development process often turns out to be harder than we expect and features are dropped so we can start selling the product to pay for the rest of the development.

Even if we managed to produce a product that was a hundred percent feature complete (in terms of our original requirements), and had zero bugs, that wouldn’t guarantee there wouldn’t be another versions. Users request new features, or changes. Businesses, and their processes and requirements evolve and require the software to evolve with them. That’s without considering that most software is built on top of other software, and certainly hardware, and these things change in response to the requests made by other users of those systems… some of these changes will necessitate changes in the software built on top of them. No where in this process is there any thought that we should deliberately hold back on features or fixes just to sell the next version.

The really annoying thing is other industries have the same issue with planned obsolescence, but very few people if anybody, complain about them. When GM or Ford release a new model of car, does anybody, including the staff at the company producing it, think this is the last model they will ever produce ? Does anyone sit around saying, damn, last year I bought the Falcon XR8 and now they’ve released the Hawk QT80.. they must have done that just to make more money !

Of course, new models of car (and versions of software) are designed to generate revenue, they must for the company to survive. You want the company to survive because you want after sales support, improved products when you are ready to replace your existing items and so on… but really Ford and GM, and anyone else in business, releases new products because technology changes, knowledge increases and we find a way to build something better than we did last time.

This process isn’t designed to be hurt our customers, to charge them more. It designed to help them, and even if we wanted to avoid it we can’t. More to the point, the software industry isn’t the only one in which this happens but plenty of people call it out as if it was.

Why people are so ready to believe these conspiracy theories is beyond me. I can only presume they’ve had a bad experience, perhaps had to pay for an expensive upgrade or had one that didn’t go well. This has left them angry and looking for someone to blame so they start attacking the industry.

Unfortunately, they’re not only wrong but they come off looking stupid to anyone who actually understands the reality of the situation and how hard we work to avoid these issues.

---

Technorati Tags: Software Quality,Conspiracy Theories,Obsolescence,Bugs

cashto's blog : It's OK Not to Write Unit Tests

I'm still trying to figure out unit testing (in detail), but this is certianly food for thought where you agree or not;

cashto's blog : It's OK Not to Write Unit Tests

Shorten Your If’s By Avoiding ‘Or’

I’m not suggesting there’s necessarily a better language syntax or that we need one, but I find this annoying;

if (value == MyEnum.EnumValue1 || value == MyEnum.EnumValue3 || value == MyEnum.EnumValue4)

Why can’t I just type this and have the compiler know what I mean;

if (value == MyEnum.EnumValue1 || MyEnum.EnumValue3 || MyEnum.EnumValue4)

Now I know what you’re thinking, there’s multiple ways the compiler could interpret my use of or (||) in that scenario, but the point is this is a common type of statement to write and it’s unnecessarily verbose – especially if you have meaningful variable and type names which is something that should be encouraged.

Some of you are probably also thinking I should have used switch, which is fine some of the time but still takes up quite a lot room on the screen and isn’t really appropriate when your conditional has only the ‘true’ condition for one set of values.

What we really need is something equivalent to the ‘In’ keyword in t-sql, i.e

if (value in(MyEnum.EnumValue1, MyEnum.EnumValue3, MyEnum.EnumValue4))

Well, the good news is you can build one yourself… here’s some of mine;

#region StringInList Overloads
/// <summary>
/// Returns a boolean value indicating whether or not the specified search string appears in the specified list of values.
/// </summary>
/// <param name="searchValue">The string to search for.</param>
/// <param name="ignoreCase">A boolean indicating whether or not the search is case sensitive.</param>
/// <param name="listValues">A list of string values to search in.</param>
/// <returns>A boolean value, true if the searchValue parameter value appears in the listValues parameter set.</returns>
public static bool StringInList(string searchValue, bool ignoreCase, params string[] listValues)
{
    return StringInList(searchValue, ignoreCase, (IEnumerable<string>)listValues);
}
/// <summary>
/// Returns a boolean value indicating whether or not the specified search string appears in the specified list of values.
/// </summary>
/// <param name="searchValue">The string to search for.</param>
/// <param name="ignoreCase">A boolean indicating whether or not the search is case sensitive.</param>
/// <param name="listValues">An enumerable list of string values to search in.</param>
/// <returns>A boolean value, true if the searchValue parameter value appears in the listValues parameter set.</returns>
public static bool StringInList(string searchValue, bool ignoreCase, IEnumerable<string> listValues)
{
    bool retVal = false;
    foreach (string testString in listValues)
    {
        if (String.Compare(searchValue, testString, ignoreCase) == 0)
        {
            retVal = true;
            break;
        }
    }
    return retVal;
}
#endregion
 
And if you’re not dealing with strings;
#region ValueInList Overloads
/// <summary>
/// Returns a boolean indicating whether the specified item is in the list of values provided (true).
/// </summary>
/// <typeparam name="T">The type of value being tested.</typeparam>
/// <param name="value">The value to search the list for.</param>
/// <param name="list">A list of values to search in.</param>
/// <returns>A boolean, true if 'value' is one of the values provided in the list argument.</returns>
/// <exception cref="System.ArgumentNullException">Occurs if the value parameter is null</exception>
public static bool ValueInList<T>(T value, params T[] list)
{
    return ValueInList<T>(value, (IEnumerable<T>)list);
}
/// <summary>
/// Returns a boolean indicating whether the specified item is in the list of values provided (true).
/// </summary>
/// <typeparam name="T">The type of value being tested.</typeparam>
/// <param name="value">The value to search the list for.</param>
/// <param name="list">An enumerable set of values to be searched.</param>
/// <returns>A boolean, true if 'value' is one of the values contained in the list argument.</returns>
/// <exception cref="System.ArgumentNullException">Occurs if the value parameter is null</exception>
public static bool ValueInList<T>(T value, IEnumerable<T> list)
{
    if (value == null) throw new ArgumentNullException("value");
    bool retVal = false;
    foreach (T item in list)
    {
        if (item.Equals(value))
        {
            retVal = true;
            break;
        }
    }
    return retVal;
}
#endregion

If you’re working in .Net 3.5 and have access to Lambda Expressions and the Extension Methods built for Linq, you can make an even simpler version;

public static bool In<T>(this T e, params T[] list)
{
  return list.Any(l => e.Equals(l));
}

---

Technorati Tags: In,Or,||,if,switch,list,strings,generics