parameter - C#4.0-Cómo manejar los parámetros de cadena opcionales

optional parameter c#

Question

Este código no es válido:

private void Foo(string optionalString = string.Empty)
{
// do foo.
}

Pero este código es:

private void Foo(string optionalString = "")
{
// do foo.
}

¿Por qué? Debido a que string.Empty es un campo de solo lectura, no una constante, y los valores predeterminados para los parámetros opcionales deben ser una constante de compilación.

Entonces, en mi pregunta ... (bueno, preocupación)

Esto es lo que he tenido que hacer:

private const string emptyString = "";
private void Foo(string optionalString = emptyString)
{
// do foo.
if (!string.IsNullOrEmpty(optionalString))
// etc
}

¿Cómo manejan los parámetros de cadena opcionales?

¿Por qué no pueden hacer que String.Empty una constante de compilación?

Answer 1

Estoy respondiendo esta pregunta.

Why can they not make String.Empty a compile-time constant?

Aquí está el código de desarme a través del Reflector de String.cs en mscorlib.dll

public static readonly Empty;
static String()
{
Empty = "";
WhitespaceChars = new char[] {
''/t'', ''/n'', ''/v'', ''/f'', ''/r'', '' '', ''/x0085'', ''/x00a0'', '' '', '' '', '' '', '' '', '' '', '' '', '' '', '' '',
'' '', '' '', '' '', '' '', ''​'', ''/u2028'', ''/u2029'', ''　'', ''''
};
}

Así que en la plataforma de Windows, string.Empty es exactamente "". Pero, sabes, Martian tiene una definición diferente para Empty y WhitespaceChars en su sistema operativo.

Answer 2

La mejor manera de manejarlos es con:

private void Foo(string optionalString = "")
{
// do foo.
}

Así que no puedes usar String.Empty. Todos reconocen "", pero si encontrara la optionalString = nullString no estaría seguro de qué pensar. Si nada más, nombre la cosa emptyString - ¡no es nulo!

Answer 3

Si está dispuesto a jugar a perder y tratar nulos, "", y que los caracteres de espacio en blanco sean los mismos, entonces puede predeterminar a null . Esto resulta muy útil cuando el nombre de usuario y la contraseña son campos opcionales debido a la posibilidad de una conexión confiable a un db. Podría cambiar esta lógica para restablecer las cadenas a null y, por lo tanto, modificar el aserto y el if . La parte importante es tener una convención consistente.

private void RunSql(string serverName, string databaseName, string userName = null, string password = null)
{
userName = Strip(userName);
password = Strip(password);
// The `MsTest` assert - works in both `Debug` and `Release` modes.
Assert.AreEqual<bool>(
userName == String.Empty,
password == String.Empty,
"User name and password should be either both empty or both non-empty!");
Assert.IsFalse(String.IsNullOrWhiteSpace(serverName));
Assert.IsFalse(String.IsNullOrWhiteSpace(databaseName));
var cmdBuilder = new StringBuilder();
cmdBuilder.AppendFormat("sqlcmd -E -S {0} -d {1} ", serverName, databaseName);
if (userName.Length > 0)
{
cmdBuilder.AppendFormat("-U {0} -P {1} ", userName, password);
}
// Complete the command string.
// Run the executable.
}
// Cannot think of a good name. Emptify? MakeNullIfEmpty?
private string Strip(string source)
{
if (String.IsNullOrWhiteSpace(source))
{
return String.Empty;
}
return source;
}

Answer 4

Ummm ... ¿qué pasa con la cadena opcionalParm = "" de nuevo? ¿Por qué es tan malo? ¿Realmente crees que necesitas una constante simbólica para una cadena vacía en este caso? ¿Qué tal esto entonces?

const int Zero = 0;
void SomeMethod(int optional = Zero) { }

¿Eso te parece una tontería?

Answer 5

si no te gusta el valor "", puedes usar el valor predeterminado (cadena).
Jugué con él y está permitido.

private static void foo(string param = default(string)) {
if (!string.IsNullOrEmpty(param)) // or param != default(string)
Console.WriteLine(param);
}

Answer 6

La advertencia de análisis de código 1026 dice que no se deben usar parámetros opcionales. Es mejor estilo usar métodos de sobrecarga, como este:

private void Foo()
{
Foo(string.Empty);
}
private void Foo(string optionalString)
{
// do foo.
if (!string.IsNullOrEmpty(optionalString))
// etc
}