Performant string check

Question

I have this function in my C# app:

public static string SafeTrim(object str) 
{
    if ( str == null || str == DBNull.Value )
      return string.Empty;
    else
      return str.ToString().Trim();
}

It works fine, but in my import utility it is called millions of times while processing hundreds of thousands of records. The ANTS profiler stated that this function consumes a lot of CPU cycles because it is called so often.

EDIT: I neglected to mention that a very common usage of SafeTrim() in my app is for DataRow/DataColumn values. Example: SafeTrim(dt.Rows[0]["id"]) - it's common for that to contain a DBNull.Value, and it's also common for that to contain edge spaces that need to be trimmed.

Can it be optimized in any way?

EDIT: I'll be trying these different approaches, under load, and reporting back tomorrow. Thanks all!

Answer 1

Seems to me a couple of simple overloads might be useful:

public static string SafeTrim(object str)
{
    return str is string x ? SafeTrim(x) : String.Empty;
}

public static string SafeTrim(string str)
{
    return str?.Trim() ?? string.Empty;
}

I don't understand what the return value should be if the object str is some other type so I haven't put this in.

---

Here's my test code:

void Main()
{
    var rnd = new Random();
    var strings = Enumerable.Range(0, 1000000).Select(x => x.ToString() + (rnd.Next(2) == 0 ? " " : "")).ToArray();

    var results = new [] { new { source = 0, elapsed = TimeSpan.Zero } }.Take(0).ToList();

    for (int i = 0; i < 100; i++)
    {

        var sw = Stopwatch.StartNew();
        var trimmed0 = strings.Select(x => SafeTrim0(x)).ToArray();
        sw.Stop();
        results.Add(new { source = 0, elapsed = sw.Elapsed });

        sw = Stopwatch.StartNew();
        var trimmed1 = strings.Select(x => SafeTrim1(x)).ToArray();
        sw.Stop();
        results.Add(new { source = 1, elapsed = sw.Elapsed });      
    }

    results.GroupBy(x => x.source, x => x.elapsed.TotalMilliseconds).Select(x => new { x.Key, Average = x.Average() }).Dump();
}

public static string SafeTrim1(string str)
{
    return str?.Trim() ?? string.Empty;
}

public static string SafeTrim0(object str) 
{
    if ( str == null || str == DBNull.Value )
      return string.Empty;
    else
      return str.ToString().Trim();
}

That's given a 155.8 ms versus 147.7 ms average run length between SafeTrim0 and SafeTrim1 respectively.

Answer 2

Possible solution
public static string SafeTrim(object str)
{
     string result = (str as string)?.Trim() ?? null;
     if (result == null)
           return string.Empty;
     return result;
}

Answer 3

Using ReferenceEquals you can cut down on some nested function calls from the operator overloading.

public static string SafeTrim(object str) 
{
    if(ReferenceEquals(str, null) || 
       ReferenceEquals(str, DBNull.Value)) //DbNull.Value is singleton
    { 
        return string.Empty;
    }

    return str.ToString().Trim();
}