by Patrik Hägne via On Development on 2/12/2009 8:03:00 PM
How many times have you written code similar to this?
1: var builder = new StringBuilder();
2:
3: foreach (string foo in bar)
4: {
5: builder.Append(foo);
6: }
7:
8: return builder.ToString();
I have hopefully done it for the last time since I created a couple of extension methods for IEnumerable<string>, well actually, one method with a couple of overloads.
The first one is really simple and just concatenates all the strings in the specified collection to a single string, something like:
1: var sequence = new string[] { "foo", "bar" };
2: string result = sequence.Concatenate();
In this case the result variable will contain the string “foobar”. One of the overloads will let you specify a separator:
2: string result = sequence.Concatenate(", ");
Now the result is “foo, bar”.
And the last one will let you specify a prefix and a suffix in addition to the separator:
2: string result = sequence.Concatenate(", ", "(", ")");
Giving you the result “(foo, bar)”. Quite neat!
Here’s the code for the extensions:
1: /// <summary>
2: /// Concatenates all the strings in the specified sequence.
3: /// </summary>
4: /// <param name="values">The values to concatenate.</param>
5: /// <returns>The concatenated sequence.</returns>
6: public static string Concatenate(this IEnumerable<string> values)
7: {
8: return values.Concatenate(string.Empty);
9: }
10:
11: /// <summary>
12: /// Concatenates all the strings in the specified sequence, separated by
13: /// the specified separator.
14: /// </summary>
15: /// <param name="values">The values to concatenate.</param>
16: /// <param name="separator">A string that will be inserted between all the values
17: /// in the resulting string.</param>
18: /// <returns>The concatenated sequence, separated by
19: /// the specified separator.</returns>
20: public static string Concatenate(this IEnumerable<string> values, string separator)
21: {
22: return values.Concatenate(separator, string.Empty, string.Empty);
23: }
24:
25: /// <summary>
26: /// Concatenates all the strings in the specified sequence, separated by
27: /// the specified separator, prefixed by the value specified in <paramref name="prefix" /> and
28: /// suffixed by the value specified in <paramref name="suffix"/>.
29: /// </summary>
30: /// <param name="values">The values to concatenate.</param>
31: /// <param name="separator">A string that will be inserted between all the values
32: /// in the resulting string.</param>
33: /// <param name="prefix">A string that will be the start of the result string.</param>
34: /// <param name="suffix">A string that will be the end of the result string.</param>
35: /// <returns>The concatenated sequence, separated by
36: /// the specified separator, prefixed by the value specified in <paramref name="prefix" /> and
37: /// suffixed by the value specified in <paramref name="suffix"/>.</returns>
38: public static string Concatenate(this IEnumerable<string> values, string separator, string prefix, string suffix)
39: {
40: Guard.ArgumentNullException(values, "values");
41: Guard.ArgumentNullException(separator, "separator");
42: Guard.ArgumentNullException(prefix, "prefix");
43: Guard.ArgumentNullException(suffix, "suffix");
44:
45: var result = new StringBuilder();
46:
47: result.Append(prefix);
48:
49: foreach (var value in values)
50: {
51: if (result.Length > prefix.Length)
52: {
53: result.Append(separator);
54: }
55:
56: result.Append(value);
57: }
58:
59: result.Append(suffix);
60:
61: return result.ToString();
62: }
… and some NUnit-tests:
1: [TestFixture]
2: public class sequence_of_strings_Concatenate
3: {
4: string[] sequence;
5:
6: [SetUp]
7: public void SetUp()
8: {
9: this.OnSetUp();
10: }
11:
12: protected virtual void OnSetUp()
13: {
14: sequence = new string[] { "a", "b", "c" };
15: }
16:
17: [Test, ExpectedException(typeof(ArgumentNullException))]
18: public void should_throw_exception_when_sequence_is_null()
19: {
20: Legend.Collections.Collection.Concatenate(null);
21: }
22:
23: [Test]
24: public void should_concatenate_values()
25: {
26: var result = sequence.Concatenate();
27: Assert.AreEqual(result, "abc");
28: }
29: }
30:
31: [TestFixture]
32: public class sequence_of_strings_Concatenate_with_specified_separator
33: {
34: string[] sequence;
35:
36: [SetUp]
37: public void SetUp()
38: {
39: this.OnSetUp();
40: }
41:
42: protected virtual void OnSetUp()
43: {
44: sequence = new string[] { "a", "b", "c" };
45: }
47: [Test, ExpectedException(typeof(ArgumentNullException))]
48: public void should_throw_exception_when_sequence_is_null()
49: {
50: Legend.Collections.Collection.Concatenate(null, ",");
51: }
52:
53: [Test, ExpectedException(typeof(ArgumentNullException))]
54: public void should_throw_exception_when_separator_is_null()
55: {
56: sequence.Concatenate(null);
59: [Test]
60: public void should_concatenate_values_separated_by_separator()
61: {
62: var result = sequence.Concatenate(", ");
63: Assert.AreEqual(result, "a, b, c");
64: }
65: }
66:
67: [TestFixture]
68: public class sequence_of_strings_Concatenate_with_specified_separator_prefix_and_suffix
69: {
70: string[] sequence;
71:
72: [SetUp]
73: public void SetUp()
74: {
75: this.OnSetUp();
76: }
77:
78: protected virtual void OnSetUp()
79: {
80: sequence = new string[] { "a", "b", "c" };
81: }
82:
83: [Test, ExpectedException(typeof(ArgumentNullException))]
84: public void should_throw_exception_when_sequence_is_null()
85: {
86: Legend.Collections.Collection.Concatenate(null, ",", string.Empty, string.Empty);
87: }
88:
89: [Test, ExpectedException(typeof(ArgumentNullException))]
90: public void should_throw_exception_when_separator_is_null()
91: {
92: sequence.Concatenate(null, string.Empty, string.Empty);
93: }
94:
95: [Test, ExpectedException(typeof(ArgumentNullException))]
96: public void should_throw_exception_when_prefix_is_null()
97: {
98: sequence.Concatenate(string.Empty, null, string.Empty);
99: }
100:
101: [Test, ExpectedException(typeof(ArgumentNullException))]
102: public void should_throw_exception_when_suffix_is_null()
103: {
104: sequence.Concatenate(string.Empty, string.Empty, null);
105: }
106:
107: [Test]
108: public void should_concatenate_string_with_separator_prefix_and_suffix_appended()
109: {
110: var result = sequence.Concatenate(", ", "(", ")");
111: Assert.AreEqual("(a, b, c)", result);
112: }
113: }
Original Post: String concatenation made easy
The content of the postings is owned by the respective author. CSharpFeeds is not responsible for the contents of the postings. This site is automatically generated and cannot be reviewed for abusive content. If you find abusive content on CSharpFeeds, please contact us. Designated trademarks and brands are the property of their respective owners. All rights reserved.
