Comment puis-je déterminer si une chaîne de format composite est invalide?

Question

par la documentation , String.Format lancera une FormatException si soit ( A) la chaîne de format est invalide ou (B) la chaîne de format contient un index qui ne peut pas être trouvé dans le tableau args.

Je veux être en mesure de déterminer qui (si non plus) de ces conditions échouent sur une chaîne arbitraire et tableau d'arguments.

Y at-il quelque chose qui peut faire ça pour moi? Merci!

Answer 1

Suivi de la réponse de gbogumil, dans le premier cas, vous obtenez:

"Input string was not in a correct format."

et dans le second, vous obtenez:

"Index (zero based) must be greater than or equal to 
zero and less than the size of the argument list."

Si vous avez besoin de sens qui (pour la messagerie utilisateur ou l'enregistrement), vous pouvez ensuite utiliser une prise d'essai comme qor72 suggéré, et vérifier ce que le message d'erreur commence par. En outre, si vous avez besoin de saisir ce que la chaîne de format était, et ce que les args étaient, vous aurez besoin de faire quelque chose comme ceci:

        string myStr = "{0}{1}{2}";
        string[] strArgs = new string[]{"this", "that"};
        string result = null;

        try { result = string.Format(myStr, strArgs); }

        catch (FormatException fex)
        {
            if (fex.Message.StartsWith("Input"))
                Console.WriteLine
                  ("Trouble with format string: \"" + myStr + "\"");
            else
                Console.WriteLine
                  ("Trouble with format args: " + string.Join(";", strArgs));
            string regex = @"\{\d+\}";
            Regex reg = new Regex(regex, RegexOptions.Multiline);
            MatchCollection matches = reg.Matches(myStr);
            Console.WriteLine
                ("Your format has {0} tokens and {1} arguments", 
                 matches.Count, strArgs.Length );

        }

EDIT: Ajout simple regex pour compter les jetons de format. Pourraient être utiles ...

Hope this helps. Bonne chance!

Answer 2

La propriété de message FormatException est réglé sur un message distinct dans chacun de ces cas.

Answer 3

Et vous ne voulez pas faire ...?

works = true;
try {
  String.Parse(Format, ObjectArray);
} catch FormatException {
works = false; }

Answer 4

J'ai récemment utilisé l'expression régulière suivante ci-dessous pour valider les chaînes de format composite dans tous nos fichiers de ressources

    /// <summary>
    /// The regular expression to get argument indexes from a composed format string
    /// </summary>
    /// <remarks> 
    /// example         index   alignment   formatString
    /// {0}             0       
    /// {1:d}           1                   d
    /// {2,12}          2       12
    /// {3,12:#}        3       12          #
    /// {{5}}           
    /// {{{6}}}         6
    /// </remarks>
    private static readonly Regex ComposedFormatArgsRegex =
        new Regex(@"(?<!(?<!\{)\{)\{(?<index>\d+)(,(?<alignment>\d+))?(:(?<formatString>[^\}]+))?\}(?!\}(?!\}))",
            RegexOptions.Compiled | RegexOptions.ExplicitCapture);

Pour plus d'informations sur les chaînes composites formatées, voir http://msdn.microsoft.com/en-us/library/txafckwd(v=vs.110).aspx