Qué .NET tienen una forma de resolver una cadena nula a String.Empty?

StackOverflow https://stackoverflow.com/questions/1241112

  •  12-09-2019
  •  | 
  •  

Pregunta

Tengo un método de una sola línea que resuelve una cadena nula a String.Empty el que pensé que podría ser útil como un método de extensión -. Pero no puedo encontrar una manera útil de lo que es tan

La única manera de que pudiera ver que es útil es como un método estático de la clase cadena porque es evidente que no se puede atribuir a una instancia como la instancia es nula y esto provoca un error de compilación. [Editar: error Compiler era debido a variable no inicializada, que malinterpretado]

pensé en añadiéndolo a una clase de ayuda pero que aumenta la complejidad innecesaria desde el punto de vista de descubrimiento.

Así que esta pregunta está en dos partes, supongo:

  1. ¿El marco .NET han construido en un modo de resolver una cadena nula a String.Empty que es de conocimiento común que me he perdido en algún lugar a lo largo del camino?
  2. Si no es así - ¿alguien sabe de una manera de agregar este método como una extensión estática de la clase cadena
    3. ?

Saludos de antemano

Editar:

Bueno, supongo que debería haber sido un poco más claro - ya estoy bien consciente de coallescing nula y que estaba usando esto en un lugar donde tengo una docena de cadenas que se inspecciona para el cálculo de una código hash.

Como se puede imaginar, 12 líneas de código siguientes estrechamente entre sí todos los que contiene la sintaxis coallescing nula es una monstruosidad, por lo que se trasladó la operación coallescing nula a un método para facilitar las cosas más fácil en los ojos. Lo cual es perfecto, sin embargo, sería una extensión perfecta para el objeto de cadena: 

int hashcode =
FirstValue.ResolveNull().GetHashCode() ^
SecondValue.ResolveNull().GetHashCode() ^
...

más de una docena de líneas es mucho más fácil de leer que: 

int hashcode =
(FirstValue ?? String.Empty).GetHashCode() ^
(SecondValue ?? String.Empty).GetHashCode() ^
...

Yo estaba corriendo en problemas del compilador cuando no declaró explícitamente mis valores de cadena como nula, pero basé en lo implícito: 

 string s;

Sin embargo, si se define explícitamente: 

string s = null;

Se puede llamar con bastante facilidad: 

s.ResolveNull();

Gracias a todos por su entrada.

¿Fue útil?

Solución

  

La única manera de que pudiera ver que es útil es como un método estático de la clase cadena porque es evidente que no se puede atribuir a una instancia como la instancia es nula y esto causaría un error de ejecución.

C # 3.0 métodos de extensión pueden ser llamados receptores nulos (ya que son estáticas en la práctica), pero se comportan como métodos de instancia. Así que sólo lo hacen un método de extensión.

Otros consejos

No creo que haya nada incorporado para esto. Lo primero que pensé, y lo que hago a menudo, es utilizar el operador se unen: 

string s = null;
string x = s ?? string.Empty;

someExpressionInvolving (s ?? "");

No hay punto de conseguir excitado sobre string.Empty vs "" - hay una diferencia insignificante: 

Console.WriteLine(ReferenceEquals(string.Empty, "")); // true

Método de extensión: 

public static class StringExtensions
{
    public static String EmptyIfNull(this String instance)
    {
        return instance ?? String.Empty;
    }
}

Por supuesto, sólo puede escribir tan fácilmente instance ?? String.Empty en los lugares donde se necesita utilizar String.Empty en lugar de null. 

string test = CouldReturnNull() ?? string.Empty;

Puede utilizar el ?? Operador (operador nulo coalescencia) en C # - que es lo que quiere decir? O he entendido mal?

por ejemplo. 

string n = null;
string y = n ?? String.Empty;

y sería = String.Empty; 

string abc = s ?? string.Empty;

Yo diría que la implementación de esto como un método de extensión se sentiría un poco como lo que en Suecia llamada "para viajar al otro lado del arroyo a buscar agua" . Cuando necesito para asegurar consigo una cadena vacía en lugar de null a menudo simplemente concatenar con string.Empty: 

public void SomeMethod(string param)
{
    string notNull = param + string.Empty;
}

Por supuesto, esto puede llevar a una instancia adicional en el hilo está creando, pero en la mayoría de situaciones del mundo real que han estado en esto no ha sido un problema.

No hay ninguna estructura en función de eso. Pero se puede escribir un pequeño método de extensión (o una menthod estática) para el tipo de cadena con una declaración como:

retorno s ?? string.Emtpy;

Sólo tiene que añadir String.Empty para cualquier cadena variable y se le garantiza que nunca llegan nula 

string a = null;
string b = null + string.Empty;
string c = "a" + string.Empty;

(a == string.Empty).Dump(); // False
(b == string.Empty).Dump(); // True
(c == "a").Dump(); // True

Tiré esto en LINQPad, de ahí el .dump () 's

En cuanto a sus opciones ...

Esta técnica 

string b = null + string.Empty;

genera 

IL_0001:  ldsfld      System.String.Empty
IL_0006:  dup         
IL_0007:  brtrue.s    IL_000F
IL_0009:  pop         
IL_000A:  ldstr       ""
IL_000F:  stloc.0

La otra opción popular: 

string b = null ?? string.empty

genera 

IL_0001:  ldsfld      System.String.Empty
IL_0006:  stloc.0

y esto 

string b = null + "";

genera este 

IL_0001:  ldstr       ""
IL_0006:  stloc.0

Me todavía favorecen 

string b = null + "";

Pero, en realidad, la OMI, sólo debe estar preparado para manejar nula cuando a digerir la cadena

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top