Analyser chaîne à l'aide de modèle de format?

Si je peux formater une chaîne à l'aide de 

string.Format("my {0} template {1} here", 1, 2)

puis-je inverser le processus - je fournir le modèle et remplis à la chaîne .rendements nets arg0, arg1, etc.?

  • Qui sonne comme un cas d'utilisation d'une expression régulière, je pense ...
  • Je suis curieux de savoir si je peux éviter de regex. Il semble que les deux objets partagent un modèle et tout simplement utiliser qui peuplent et de remplir une chaîne de caractères. Serait tout à fait élégant.
InformationsquelleAutor SFun28 | 2011-03-17
  1. 30

    Il n'y a pas de manière élégante pour inverser la chaîne formatée. Mais vous pouvez essayer si vous voulez une simple fonction.

    private List<string> reverseStringFormat(string template, string str)
{
     //Handels regex special characters.
    template = Regex.Replace(template, @"[\\\^$\.\|\?\*\+\(\)]", m => "\\" 
     + m.Value);

    string pattern = "^" + Regex.Replace(template, @"\{[0-9]+\}", "(.*?)") + "$";

    Regex r = new Regex(pattern);
    Match m = r.Match(str);

    List<string> ret = new List<string>();

    for (int i = 1; i < m.Groups.Count; i++)
    {
        ret.Add(m.Groups[i].Value);
    }

    return ret;
}
    • Merci! Espérais quelque chose de construire-dans .net mais il semble qu'il n'y en a pas. C'est une bonne solution.
    • Solution sympa. Assurez-vous que le modèle est valide, vous devez remplacer toutes les regex caractères avant de créer le modèle: template = Regex.Replace(template, @"[\\\^\$\.\|\?\*\+\(\)]", m => "\\" + m.Value).
    • Bon appel. Aussi, il convient de noter que ce ne sera pas reproduire le résultat correct dans le cas décrit ci-dessous par Alexei.
    • ajouter des crochets pour des caractères d'échappement: template = Regex.Replace(template, @"[\\\^\$\.\|\?\*\+\(\)\[\]]", m => "\\" + m.Value);
    InformationsquelleAutor Mike Park
  2. 7

    Chaîne.Le Format n'est pas réversible dans le cas général.

    Si vous avez exactement une {0}, il est actaully possible d'écrire du code générique qu'au moins l'extrait de représentation de chaîne de la valeur. Vous avez certainement ne peut pas s'inverser pour produire des objets d'origine.

    Échantillons:

    1. Plusieurs arguments: string.Format("my{0}{1}", "aa", "aaa"); produit "myaaaaa", tring pour inverser string.ReverseFormat("my{0}{1}", "myaaaaa") ont à décider de la façon de diviser "aaaaa" partie 2, sans aucune information.

    2. Incapacité à inverser pour le type de données string.Format("{0:yyyy}", DateTime.Now); résultats en 2011, plus d'informations sur la valeur elle-même perdu.

    InformationsquelleAutor Alexei Levenkov
  3. 2

    Utiliser des expressions régulières pour analyser les matches de groupe.

    Regex.Match("my (.*) template (.*) here", theFilledInString);

    Je n'ai pas de VS ouvert, donc je ne peux pas vérifier si j'ai le nom de la méthode à droite, mais vous savez ce que je veux dire. En utilisant paranthesis, le renvoi du résultat du match sera groupes[0] et des groupes[1] contenant vos extraits de matchs.

    • Est-il un moyen pour éviter les regex? N' .net avoir un mécanisme pour analyser la chaîne à l'aide de modèles où les arguments sont dans {} format?
    • Je n'ai pas vu une telle chose. Je suppose que vous pouvez auto-remplacer "{0}" avec "(.*)" lors de la manipulation de ces modèles. Regardez climbage la réponse ci-dessus.
    InformationsquelleAutor Laith
  4. 2

    Une façon de le faire serait d'expressions régulières. Pour votre exemple, vous pourriez faire:

    Regex regex = new Regex("^my (.*?) template (.*?) here$");
Match match = regex.Match("my 53 template 22 here");
string arg0 = match.Groups[1].Value;    //= "53"
string arg1 = match.Groups[2].Value;    //= "22"

    Il ne serait pas difficile d'écrire une méthode d'extension pour faire exactement ce que vous voulez de cette technique.

    Juste pour le plaisir, voici ma première naïve tentative. Je n'ai pas testé, mais ça doit être proche. 

    public static object[] ExtractFormatParameters(this string sourceString, string formatString)
{
    Regex placeHolderRegex = new Regex(@"\{(\d+)\}");
    Regex formatRegex = new Regex(placeHolderRegex.Replace(formatString, m => "(<" + m.Groups[1].Value + ">.*?)");
    Match match = formatRegex.Match(sourceString);
    if (match.Success)
    {
        var output = new object[match.Groups.Count-1];
        for (int i = 0; i < output.Length; i++)
            output[i] = match.Groups[i+1].Value;
        return output;
    }
    return new object[];
}

    Cela vous permettra de faire

    object[] args = sourceString.ExtractFormatParameters("my {0} template {1} here");

    La méthode est TRÈS naïf et a beaucoup de problèmes, mais il va trouver tout les espaces réservés à l'expression de format, et de trouver le texte correspondant dans la chaîne source. Il vous donnera les valeurs correspondant aux espaces réservés de gauche à droite, sans référence à ordinale, ou n'importe quel format spécifié dans l'espace réservé. Cette fonctionnalité peut être ajoutée.

    Un autre problème est que toute spéciale de la regex de caractères dans la chaîne de format sera la cause de la méthode de tomber. Certains de traitement plus de formatRegex devrait être fait pour s'échapper tous les caractères spéciaux qui font partie de formatString.

    • Pouvez-vous confirmer qu'il n'y a pas moyen d'utiliser le modèle de chaîne de que-est (sans écriture personnalisée de la méthode d'extension)? voir les commentaires ci-dessus.
    • Pas que je suis au courant, mais cela ne veut pas dire grand-chose. Mais je peux voir l'écriture d'une méthode qui permettrait de prendre le format et un tableau d'objets de la taille, d'analyser le format et le rendre dans une regex, faire le match et ensuite remplir le tableau d'objet avec les valeurs obtenues.
    • yup...comme @climbage la solution ci-dessus.
    InformationsquelleAutor Andrew Cooper