Como posso determinar se uma sequência de formato composta é inválida?

Question

De acordo com a documentação, String.Format vai jogar um FormatException Se (a) a sequência do formato for inválida ou (b) a sequência do formato contiver um índice que não pode ser encontrado na matriz ARGS.

Quero poder determinar qual (se qualquer) dessas condições falhará em qualquer string arbitrária e matriz de argumentos.

Existe algo que possa fazer isso por mim? Obrigado!

Answer 1

Acompanhe a resposta de GBOGUMIL, no primeiro caso que você obtém:

"Input string was not in a correct format."

E no segundo, você recebe:

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

Se você precisar sentir qual (para mensagens ou log do usuário), poderá usar uma captura de tentativa como o Qor72 sugerido e verifique o que a mensagem de erro começa. Além disso, se você precisar capturar qual era a sequência do formato e o que eram os args, precisará fazer algo assim:

        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 );

        }

EDITAR: Adicionado o regex simples para contar os tokens de formato. Pode ajudar...

Espero que isto ajude. Boa sorte!

Answer 2

A propriedade da mensagem formatexception é definida como uma mensagem distinta em cada um desses casos.

Answer 3

E você não quer fazer ...?

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

Answer 4

Recentemente, usei a seguinte expressão regular abaixo para validar as seqüências de formato composto em todos os nossos arquivos de recursos

    /// <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);

Para obter mais informações sobre seqüências de cordas formatadas compostas, consulte http://msdn.microsoft.com/en-us/library/txafckwd(v=vs.110).aspx