parameter - parametro opcional c#

c#string.Format parámetros opcionales

Question

Quiero usar string.Format con optional parameters :

public static void Main(string[] args)
{
    //Your code goes here
    //  Console.WriteLine(string.Format("{0} {1}", "a", "b"));
    Console.WriteLine(string.Format("{0} {1}", "a"));
}

por ejemplo, el parámetro {1} es opcional y tiene un valor predeterminado

¿Puedes ayudarme a hacer esto?

Gracias

Answer 1

Depende de lo que quiere decir con "parámetro opcional".

Si desea reemplazar automáticamente null con un valor predeterminado, la manera más fácil de hacerlo es usar el operador coalescente nulo dentro de los argumentos:

String.Format("{0} {1}", 
              "a",
              someNullableVariableContainingB ?? "default value");

Si desea reutilizar la misma cadena de formato para múltiples invocaciones String.Format, por ejemplo

var myFormatString = "{0} {1}";
var string1 = String.Format(myFormatString, "a", "b");
var string2 = String.Format(myFormatString, "a");

entonces no tiene suerte: String.Format lanzará una excepción si se proporcionan muy pocos argumentos, y no hay forma de especificar un "parámetro opcional" dentro de la cadena de formato. Deberá usar algo que no sea String.Format, por ejemplo, un método personalizado que reemplace los argumentos faltantes con los valores predeterminados deseados.

Answer 2

Puede crear un método de extensión:

public static string MyFormat(this string s, int i, params string[] args){
    var t = new List<string>(args);
    for(var c = t.Count; c < i; ++c)
        t.Add(String.Empty); // or other default

    return String.Format(s, t.ToArray());
}

y llama:

"{0}:{1} - {2},{3},{4}".MyFormat(5, "ping", "fnord");

Sin embargo, le obliga a especificar un argumento en orden, por lo que no puede omitir {3} si desea establecer {4}. Sin embargo, podría agregar:

for(var x = 0; x < args.Count; ++x){
    if(args[x] == null) args[x] = String.Empty;

y llama:

"{0}:{1} - {2},{3},{4}".MyFormat(5, "ping", null, "pong");

para establecer {0} y {2}, pero por defecto {1}, {3} y {4} en String.Empty;

Podrías elegir automágicamente la i, pero es mucho más fácil así.

Answer 3

Este método de extensión no está limitado a un número fijo de parámetros. Es decir, funcionará con cadenas como "{0}" , pero también "{0} {1}" , "{0} {1} {2}" y así sucesivamente. La desventaja menor es que primero das argumento opcional y luego el no opcional. Debería ser al revés, pero lamentablemente la naturaleza de la palabra clave params prohíbe. La principal desventaja es que ignora el número en las llaves (aunque la solución puede ser modificada para incluir eso también).

    public static string FormatOpt(this string s, string optional, params string[] param)
    {
        StringBuilder result = new StringBuilder();
        int index = 0;
        bool opened = false;
        Stack<string> stack = new Stack<string>(param.Reverse());

        foreach(var c in s)
        {
            if (c == ''{'')
            {
                opened = true;
                index = result.Length;
            }
            else if (opened && c == ''}'')
            {
                opened = false;
                var p = stack.Count > 0 ? stack.Pop() : optional;
                var lenToRem = result.Length - index;
                result.Remove(index, lenToRem);
                result.Append(p);
                continue;
            }
            else if (opened && !Char.IsDigit(c))
            {
                opened = false;
            }

            result.Append(c);
        }

        return result.ToString();
    }

Y hay resultados esperados:

string res1 = "result: {0}, {1}, {2}, {3}".FormatOpt("optional", "first param", "second param");
// result: first param, second param, optional, optional

string res2 = "result: {0}, {1}, {2}, {3}".FormatOpt("optional", "first param");                 
// result: first param, optional, optional, optional

string res3 = "result: {0}, {1}, {2}, {3}".FormatOpt("optional");                                
// result: optional, optional, optional, optional

Answer 4

  private static Regex curlyBracketRegex = new Regex("//{(.+?)//}");

  private static string OptionalFormat(string formatString, params object[] args)
  {
        var numberOfArguments = curlyBracketRegex.Matches(formatString).Count;

        var missingArgumentCount = numberOfArguments - args.Length;
        if (missingArgumentCount <= 0) //more argument or just enough
            return string.Format(formatString, args);

        args = args.Concat(Enumerable.Range(0, missingArgumentCount).Select(_ => string.Empty)).ToArray();
        return string.Format(formatString, args);
  }

Este método anterior funciona con cadenas de formato simples. La expresión regular detecta los corchetes. Si el recuento de coincidencias es mayor que el número de args pasados, se creará una nueva matriz combinando la matriz original con cadenas vacías.

Ejemplo: OptionalFormat ("{0} # {1}", "apple") // apple #