Czy jest lepszy sposób na tworzenie akronimu od wielkich liter w C#?

Question

Jaki jest najlepszy sposób na tworzenie akronimu od wielkich liter w C#?

Przykład:

Alfa_BetaGameDelta_Epsilon

Oczekiwany wynik:

ABGDE

Moje rozwiązanie działa, ale nie jest to miłe

 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

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

Answer 4

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

Answer 5

Można użyć metody Where odfiltrować dużych liter, a metoda Char.IsUpper może być stosowany jako delegat bezpośrednio, bez wyrażenia lambda. Można utworzyć ciąg wynikowy z tablicy znaków:

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

Answer 6

przy użyciu większej 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)); 

Więcej Wyrażenia regularne są zawsze takie rozwiązanie, expecially z LINQ! :-)

regex stawia wszystko [A-Z] w grupie przechwytywania 1 (ponieważ wszystkie inne () są non-przechwytywanie grupę (?:)) oraz „przeskakuje” cały non [A-Z] ([^A-Z]) poprzez umieszczenie ich w grupie non-przechwytywania . Odbywa się to 0-nieskończenie razy przez ostatnie *. Następnie trochę LINQ, aby wybrać wartość każdego przechwytywania .Select(p => p.Value) i string.Join, aby do nich dołączyć.

Zauważ, że nie jest to przyjazny dla Unicode ... ÈÌÒÈÌÒÈÌÒ zostanie zignorowany. Lepsze wyrażenie będzie używać @"(?:(\p{Lu}+)(?:[^\p{Lu}]*))*", gdzie \p{Lu} jest kategorią kodu Unicode UppercaseLetter.

(tak, to jest bezużyteczne ... Inne metody, które wykorzystują LINQ + IsUpper są lepsze :-) ale cała przykład został zbudowany po prostu pokazać problemy regexes z Unicode)

znacznie łatwiejsze:

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

po prostu usunąć wszystkie nie-wielkie litery :-)