Is there a better way to create acronym from upper letters in C#?

Question

What is the best way to create acronym from upper letters in C#?

Example:

Alfa_BetaGameDelta_Epsilon

Expected result:

ABGDE

My solution works, but it's not nice

        var classNameAbbreviationRegex = new Regex("[A-Z]+", RegexOptions.Compiled);
        var matches = classNameAbbreviationRegex.Matches(enumTypeName);
        var letters = new string[matches.Count];

        for (var i = 0; i < matches.Count; i++)
        {
            letters[i] = matches[i].Value;
        }

        var abbreviation = string.Join(string.Empty, letters);

Answer 1

string.Join("", s.Where(char.IsUpper));

Answer 2

string.Join("", s.Where(x => char.IsUpper(x))

Answer 3

string test = "Alfa_BetaGameDelta_Epsilon";
string result = string.Concat(test.Where(char.IsUpper));

Answer 4

You can use the Where method to filter out the upper case characters, and the Char.IsUpper method can be used as a delegate directly without a lambda expression. You can create the resulting string from an array of characters:

string abbreviation = new String(enumTypeName.Where(Char.IsUpper).ToArray());

Answer 5

By using MORE regexes :-)

var ac = string.Join(string.Empty, 
                     Regex.Match("Alfa_BetaGameDelta_Epsilon", 
                                 "(?:([A-Z]+)(?:[^A-Z]*))*")
                          .Groups[1]
                          .Captures
                          .Cast<Capture>()
                          .Select(p => p.Value));

More regexes are always the solution, expecially with LINQ! :-)

The regex puts all the [A-Z] in capture group 1 (because all the other () are non-capturing group (?:)) and "skips" all the non [A-Z] ([^A-Z]) by putting them in a non-capturing group. This is done 0-infinite times by the last *. Then a little LINQ to select the value of each capture .Select(p => p.Value) and the string.Join to join them.

Note that this isn't Unicode friendly... ÀÈÌÒÙ will be ignored. A better regex would use @"(?:(\p{Lu}+)(?:[^\p{Lu}]*))*" where \p{Lu} is the Unicode category UppercaseLetter.

(yes, this is useless... The other methods that use LINQ + IsUpper are better :-) but the whole example was built just to show the problems of Regexes with Unicode)

MUCH EASIER:

var ac = Regex.Replace("Alfa_BetaGameDelta_Epsilon", @"[^\p{Lu}]", string.Empty);

simply remove all the non-uppercase letters :-)

Answer 6

var str = "Alfa_BetaGammaDelta_Epsilon";
var abbreviation = string.Join(string.Empty, str.Where(c => c.IsUpper()));