2 Lines of C# Code that replaced my bloated 44 lines - The Reductionist's View

 

2 Lines of C# Code that replaced my bloated 44 lines - The Reductionist's View

Rate This
  • Comments 11

Could you reduce my 44 lines down to just 2?

Sometimes as a developer you are humbled by something dumb that you did. I had written this huge, poorly designed piece of code that was supposed to remove blank strings that are in a relatively small array of strings. I felt smart and not smart at the same time. But the end result was good.

All I wanted to do is remove blank strings in an array of strings. That means if I had a string array of 35 with a 31 one of them blank, I just wanted that to be converted to a nice small 4 element string array with my data.

So I wrote this goofy piece of code. It was even named poorly.

Bloated Algorithm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public static string[] KillSingleBlanks(string[] arr)
{

    // if find two blanks, copy one, next char, and skip all
    // if found one blank, copy current
    //
    int max_size = arr.Length;
    string[] new_arr = new string[max_size];
    int src = 0;
    int trg = 0;
    int hdr_count = 0;
    while (src < max_size && (arr[src].Trim() == "" || arr[src] == null))
    {
        src++;
    }
    while (src < max_size)
    {
        if (arr[src].Trim() == "" && arr[src + 1].Trim() == "")
        {
            // found 2 in a row, so copy one blank and skip to end
            //new_arr[trg++] = "";
            while (src < max_size && arr[src].Trim() == "")
            {
                src++;
            }
            break;
        }
        else
        {
            // here because no two blanks in a row, so copy and advance
            if (arr[src] != "")
            {
                new_arr[trg++] = arr[src];
            }
            src++;
        }
    }
    hdr_count = trg;
    while (src < max_size)
    {
        if (arr[src].Trim() != "")
        {
            new_arr[trg++] = arr[src];
        }
        src++;
    }
    return new_arr;
}

How I ended up with two lines

Stop. Have you tried to find an answer yourself? Here it is ? two lines of code that do an infinitely better job at removing blank string entries.


The Reductionist's Algorithm
1
2
3
4
5
6
7
public static string[] KillSingleBlanks(string[] arr)
{
    var array = arr.Where(r=>!String.IsNullOrEmpty(r.Trim()));
    string[] str = array.ToArray<string>();
    return str;

}

Follow up

Now I need to go for manual loops in arrays and then try to work with them as IEnumerables and collections that are processed with LINQ.

  • For me it seems your long code sample does something different than eliminating all empty lines. More like if it reduces more empty lines to a single one.

    Oh, and any Special reason you don't use String.IsNullOrWhitespace instead of trimming the string and using IsNullOrEmpty?

  • You can reduce this to a single line

    return arr.Where(r=>!String.IsNullOrEmpty(r.Trim())).ToArray<string>();

  • I don't understand, why is the first code that Long ?? u Need just to Loop and trim , and this is what ur linq query does!!

  • Your original code is too long and not readable. Sorry, it is horrible actually.

    You can accomplish what you wanted in a shorter and better way even without Linq. For example, you could just insert the not-empty strings to a new list and then call ToArray(). Just one small loop...

    var list = new List<string>(arr.Length);

    foreach(var item in arr)

       if( String.IsNullOrWhiteSpace(item))

                 list.Add(item)

    return list.ToArray();

  • That was one of those routines that morphed over time, doing something different without refactoring. It was for a little utility that builds html tables with lines in the clipboard. Initially, it was calculating how many columns before it built the html table. Then that was done before the function, so that code just snuck through with me removing. I bet many readers have code they aren't proud of :-)

  • I shudder to think of the VB6 code I wrote back in the late 90's.

  • Indeed... return arr.Where(r=>!string.IsNullOrEmpty(r.Trim())).ToArray<string>();

  • It's a very rare occurrence when I look at old code that I wrote and think "this is an amazing piece of code". Usually, that last word is different.

    It's why whenever I have to look at someone else's code I don't judge them based on that code. If the code I write today was the same as the code I wrote five, two or even one year ago, I had learned nothing and made no progress.

    With your specific piece of code, I find I almost never use IsNullOrEmpty anymore. I have no use for strings that only have spaces in them and as others mentioned here, IsNullOrWhitespace does that trick for you. I assume performance wise it ends up doing the same thing, but at least your code is clearer

  • Make this an extension method of IEnumerable<String> and return an IEnumerable<String>, cut it down to a single line of code, and check for null references on the input:

    public static IEnumerable<String>ExceptEmpty(this IEnumerable<string> arg) {

       return arg != null ? arg.Where((s) => !string.IsNullEmptyOrWhiteSpace(s)) : Enumerable.Empty<String>();

    }

  • You could even go inline:

    array = array.Except(array.Where(String.IsNullOrWhiteSpace)).ToArray();

  • Reductionist? Shouldn't it be minimalist?

Page 1 of 1 (11 items)
Leave a Comment
  • Please add 2 and 3 and type the answer here:
  • Post