Iterating over IEnumerable, special casing last element

Question

I'm building a string based on an IEnumerable, and doing something like this:

public string BuildString()
{
    var enumerable = GetEnumerableFromSomewhere(); // actually an in parameter,
                                                   // but this way you don't have to care
                                                   // about the type :)

    var interestingParts = enumerable.Select(v => v.TheInterestingStuff).ToArray();

    stringBuilder.Append("This is it: ");

    foreach(var part in interestingParts)
    {
        stringBuilder.AppendPart(part);

        if (part != interestingParts.Last())
        {
            stringBuilder.Append(", ");
        }
    }
}

private static void AppendPart(this StringBuilder stringBuilder, InterestingPart part)
{
    stringBuilder.Append("[");
    stringBuilder.Append(part.Something");
    stringBuilder.Append("]");

    if (someCondition(part)) 
    {
         // this is in reality done in another extension method,
         // similar to the else clause
         stringBuilder.Append(" = @");
         stringBuilder.Append(part.SomethingElse");
    }
    else
    {
         // this is also an extension method, similar to this one
         // it casts the part to an IEnumerable, and iterates over
         // it in much the same way as the outer method.
         stringBuilder.AppendInFilter(part);
    }
}

I'm not entirely happy with this idiom, but I'm struggling to formulate something more succinct.

This is, of course, part of a larger string building operation (where there are several blocks similar to this one, as well as other stuff in between) - otherwise I'd probably drop the StringBuilder and use string.Join(", ", ...) directly.

My closest attempt at simplifying the above, though, is constructs like this for each iterator:

stringBuilder.Append(string.Join(", ", propertyNames.Select(prop => "[" + prop + "]")));

but here I'm still concatenating strings with +, which makes it feel like the StringBuilder doesn't really contribute much.

How could I simplify this code, while keeping it efficient?

Answer 1

You can replace this:

string.Join(", ", propertyNames.Select(prop => "[" + prop + "]"))

With c# 6 string interpolation:

string.Join(", ", propertyNames.Select(prop => $"[{prop}]"))

In both cases the difference is semantic only and it doesn't really matter. String concatenation like in your case in the select isn't a problem. The compiler still creates only 1 new string for it (and not 4, one for each segment and a 4th for the joint string).

Putting it all together:

var result = string.Join(", ", enumerable.Select(v => $"[{v.TheInterestingStuff}]"));

---

Because body of foreach is more complex that to fit in a String Interpolation scope you can just remove the last N characters of the string once calculated, as KooKiz suggested.

string separator = ", ";
foreach(var part in interestingParts)
{
    stringBuilder.Append("[");
    stringBuilder.Append(part);
    stringBuilder.Append("]");

    if (someCondition(part)) 
    {
        // Append more stuff
    }
    else
    {
        // Append other thingd
    }
    stringBuilder.Append(separator);
}
stringBuilder.Length = stringBuilder.Lenth - separator;

In any case I think that for better encapsulation the content of the loop's scope should sit in a separate function that will receive a part and the separator and will return the output string. It can also be an extension method for StringBuilder as suggested by user734028

Answer 2

Aggregate solution:

var answer = interestingParts.Select(v => "[" + v + "]").Aggregate((a, b) => a + ", " + b);

Serialization solution:

var temp = JsonConvert.SerializeObject(interestingParts.Select(x => new[] { x }));
var answer = temp.Substring(1, temp.Length - 2).Replace(",", ", ");

Answer 3

Use Aggregate extension method with StringBuilder.
Will be more efficiently then concatenate strings if your collection are big

        var builder = new StringBuilder();
        list.Aggregate(builder, (sb, person) =>
        {
            sb.Append(",");
            sb.Append("[");
            sb.Append(person.Name);
            sb.Append("]");
            return sb;
        });
        builder.Remove(0, 1); // Remove first comma

As pure foreach is always more efficient then LINQ then just change logic for delimeter comma

var builder = new StringBuilder();
foreach(var part in enumerable.Select(v => v.TheInterestingStuff))
{
    builder.Append(", ");
    builder.Append("[");
    builder.Append(part);
    builder.Append("]");
}

builder.Remove(0, 2); //Remove first comma and space

Answer 4

the code:

public string BuildString()
{
    var enumerable = GetEnumerableFromSomewhere();
    var interestingParts = enumerable.Select(v => v.TheInterestingStuff).ToArray();

    stringBuilder.Append("This is it: ");

    foreach(var part in interestingParts)
    {
        stringBuilder.AppendPart(part)

    }
    if (stringBuilder.Length>0)
        stringBuilder.Length--;
}

private static void AppendPart(this StringBuilder stringBuilder, InterestingPart part)
{
    if (someCondition(part)) 
    {
        stringBuilder.Append(string.Format("[{0}] = @{0}", part.Something));         

    }
    else
    {
         stringBuilder.Append(string.Format("[{0}]", part.Something));
         stringBuilder.AppendInFilter(part); //
    }
}

much better now IMO.

Now a little discussion on making it very fast. We can use Parallel.For. But you would think (if you would think) the Appends are all happening to a single shareable resource, aka the StringBuilder, and then you would have to lock it to Append to it, not so efficient! Well, if we can say that each iteration of the for loop in the outer function creates one single string artifact, then we can have a single array of string, allocated to the count of interestingParts before the Parallel for starts, and each index of the Parallel for would store its string to its respective index.

Something like:

string[] iteration_buckets = new string[interestingParts.Length];
System.Threading.Tasks.Parallel.For(0, interestingParts.Length,
    (index) =>
    {
        iteration_buckets[index] = AppendPart(interestingParts[index]);
    });

your function AppendPart will have to be adjusted to make it a non-extension to take just a string and return a string. After the loop ends you can do a string.Join to get a string, which is what you may be doing with the stringBuilder.ToString() too.