Regex extraire des initiales de Nom

Voici ma solution. Mon but n'était pas de fournir la solution la plus simple, mais qui peut prendre une variété de (parfois bizarre) nom de formats, et de générer la meilleure estimation, à un nom et prénom initiale (ou, dans le cas de mononymous personnes), une seule initiale.

J'ai aussi essayé de l'écrire dans une manière qui est relativement international-friendly, avec unicode regexes, bien que je n'ai pas d'expérience dans la génération des initiales pour de nombreux types de noms étrangers (Chinois par exemple), mais il faudrait au moins générer quelque chose d'utilisable pour représenter la personne, en vertu de deux personnages. Par exemple, alimenter un nom en coréen comme "행운의 복숭아" donnera 행복 comme vous avez pu penser (même si c'est peut-être pas la bonne façon de le faire dans la culture coréenne).

///<summary>
///Given a person's first and last name, we'll make our best guess to extract up to two initials, hopefully
///representing their first and last name, skipping any middle initials, Jr/Sr/III suffixes, etc. The letters 
///will be returned together in ALL CAPS, e.g. "TW". 
///
///The way it parses names for many common styles:
///
///Mason Zhwiti                -> MZ
///mason lowercase zhwiti      -> MZ
///Mason G Zhwiti              -> MZ
///Mason G. Zhwiti             -> MZ
///John Queue Public           -> JP
///John Q. Public, Jr.         -> JP
///John Q Public Jr.           -> JP
///Thurston Howell III         -> TH
///Thurston Howell, III        -> TH
///Malcolm X                   -> MX
///A Ron                       -> AR
///A A Ron                     -> AR
///Madonna                     -> M
///Chris O'Donnell             -> CO
///Malcolm McDowell            -> MM
///Robert "Rocky" Balboa, Sr.  -> RB
///1Bobby 2Tables              -> BT
///Éric Ígor                   -> ÉÍ
///행운의 복숭아                 -> 행복
///
///</summary>
///<param name="name">The full name of a person.</param>
///<returns>One to two uppercase initials, without punctuation.</returns>
public static string ExtractInitialsFromName(string name)
{
    //first remove all: punctuation, separator chars, control chars, and numbers (unicode style regexes)
    string initials = Regex.Replace(name, @"[\p{P}\p{S}\p{C}\p{N}]+", "");

    //Replacing all possible whitespace/separator characters (unicode style), with a single, regular ascii space.
    initials = Regex.Replace(initials, @"\p{Z}+", " ");

    //Remove all Sr, Jr, I, II, III, IV, V, VI, VII, VIII, IX at the end of names
    initials = Regex.Replace(initials.Trim(), @"\s+(?:[JS]R|I{1,3}|I[VX]|VI{0,3})$", "", RegexOptions.IgnoreCase);

    //Extract up to 2 initials from the remaining cleaned name.
    initials = Regex.Replace(initials, @"^(\p{L})[^\s]*(?:\s+(?:\p{L}+\s+(?=\p{L}))?(?:(\p{L})\p{L}*)?)?$", "$1$2").Trim();

    if (initials.Length > 2)
    {
        //Worst case scenario, everything failed, just grab the first two letters of what we have left.
        initials = initials.Substring(0, 2);
    }

    return initials.ToUpperInvariant();
}

OriginalL'auteur Mason G. Zhwiti

C'est mon approche:

public static string GetInitials(string names)
    {
        //Extract the first character out of each block of non-whitespace
        //exept name suffixes, e.g. Jr., III.
        //The number of initials is not limited.
        Regex extractInitials = new Regex(@"(?i)(?:^|\s|-)+([^\s-])[^\s-]*(?:(?:\s+)(?:the\s+)?(?:jr|sr|II|2nd|III|3rd|IV|4th)\.?$)?");
        return extractInitials.Replace(names, "$1").ToUpper();
    }

Traité les affaires:

//Mason Zhwiti                               -> MZ
//mason zhwiti                               -> MZ
//Mason G Zhwiti                             -> MGZ
//Mason G. Zhwiti                            -> MGZ
//John Queue Public                          -> JQP
//John-Queue Public                          -> JQP
//John Q. Public, Jr.                        -> JQP
//John Q Public Jr.                          -> JQP
//John Q Public Jr                           -> JQP
//John Q Public Jraroslav                    -> JQPJ
//Thurston Howell III                        -> TH
//Thurston Howell, III                       -> TH
//Thurston Howell the III                    -> TH
//Malcolm X                                  -> MX
//A Ron                                      -> AR
//A A Ron                                    -> AAR
//Madonna                                    -> M
//Chris O'Donnell                            -> CO
//Chris O' Donnell                           -> COD
//Malcolm McDowell                           -> MM
//Éric Ígor                                  -> ÉÍ
//행운의 복숭아                               -> 행복

Pas traité les affaires:

//James Henry George Michael III the second  -> JHGMIts
//Robert "Rocky" Balboa, Sr.                 -> R"B
//1Bobby 2Tables                             -> 12 (is it a real name?)

OriginalL'auteur Olli

essayer celui-ci

(^| )([^ ])([^ ])*','')

ou cette un

 public static string ToInitials(this string str)
    {
      return Regex.Replace(str, @"^(?'b'\w)\w*,\s*(?'a'\w)\w*$|^(?'a'\w)\w*\s*(?'b'\w)\w*$", "${a}${b}", RegexOptions.Singleline)
    }

http://www.kewney.com/posts/software-development/using-regular-expressions-to-get-initials-from-a-string-in-c-sharp

OriginalL'auteur COLD TOLD

Comment à ce sujet:

        string name = "John Clark MacDonald";
        var parts = name.Split(' ');
        string initials = "";

        foreach (var part in parts)
        {
            initials += Regex.Match(part, "[A-Z]");
            Console.WriteLine(part + " --> " + Regex.Match(part,"[A-Z]"));
        }
        Console.WriteLine("Final initials: " + initials);
        Console.ReadKey();

Cela permet en option prénoms, et travaille pour plusieurs capitalisations, comme indiqué ci-dessus.

OriginalL'auteur kevlar1818