La forma más rápida de eliminar espacios en blanco en una cuerda

Estoy intentando buscar varias direcciones de correo electrónico separadas por “,” dentro de la cadena de la tabla de la base de datos, pero también me devuelve espacios en blanco, y quiero eliminar el espacio en blanco rápidamente.

El siguiente código elimina espacios en blanco, pero también se vuelve lento cada vez que trato de buscar direcciones de correo electrónico de números grandes en una cadena como 30000, y luego trato de eliminar espacios en blanco entre ellas. Toma más de cuatro a cinco minutos eliminar esos espacios.

Regex Spaces = new Regex(@"\s+", RegexOptions.Compiled); txtEmailID.Text = MultipleSpaces.Replace(emailaddress),""); 

¿Alguien podría decirme cómo puedo eliminar el espacio en blanco en un segundo incluso para una gran cantidad de direcciones de correo electrónico?

Construiría un método de extensión personalizado usando StringBuilder , como:

 public static string ExceptChars(this string str, IEnumerable toExclude) { StringBuilder sb = new StringBuilder(str.Length); for (int i = 0; i < str.Length; i++) { char c = str[i]; if (!toExclude.Contains(c)) sb.Append(c); } return sb.ToString(); } 

Uso:

 var str = s.ExceptChars(new[] { ' ', '\t', '\n', '\r' }); 

o para ser aún más rápido:

 var str = s.ExceptChars(new HashSet(new[] { ' ', '\t', '\n', '\r' })); 

Con la versión de hashset, una cadena de 11 millones de caracteres toma menos de 700 ms (y estoy en modo de depuración)

EDITAR:

El código anterior es genérico y permite excluir cualquier char, pero si desea eliminar solo espacios en blanco de la manera más rápida posible, puede usar:

 public static string ExceptBlanks(this string str) { StringBuilder sb = new StringBuilder(str.Length); for (int i = 0; i < str.Length; i++) { char c = str[i]; switch (c) { case '\r': case '\n': case '\t': case ' ': continue; default: sb.Append(c); break; } } return sb.ToString(); } 

EDICION 2:

como se señaló correctamente en los comentarios, la forma correcta de eliminar todos los espacios en blanco es usar el método char.IsWhiteSpace :

 public static string ExceptBlanks(this string str) { StringBuilder sb = new StringBuilder(str.Length); for (int i = 0; i < str.Length; i++) { char c = str[i]; if(!char.IsWhiteSpace(c)) sb.Append(c); } return sb.ToString(); } 

Dada la implementación de string.Replace está escrito en C ++ y parte del tiempo de ejecución de CLR Estoy dispuesto a apostar

email.Replace(" ","").Replace("\t","").Replace("\n","").Replace("\r","");

será la implementación más rápida. Si necesita cada tipo de espacio en blanco , puede proporcionar el valor hexadecimal equivalente a unicode.

Deberías probar String.Trim() . Cortará todos los espacios de principio a fin de una cadena

O puede probar este método desde el tema vinculado: [enlace]

  public static unsafe string StripTabsAndNewlines(string s) { int len = s.Length; char* newChars = stackalloc char[len]; char* currentChar = newChars; for (int i = 0; i < len; ++i) { char c = s[i]; switch (c) { case '\r': case '\n': case '\t': continue; default: *currentChar++ = c; break; } } return new string(newChars, 0, (int)(currentChar - newChars)); } 

Con linq puedes hacerlo simplemente:

 emailaddress = new String(emailaddress .Where(x=>x!=' ' && x!='\r' && x!='\n') .ToArray()); 

No lo comparé con los enfoques de stringbuilder, pero es mucho más rápido que los enfoques basados ​​en cadenas. Porque no crea muchas copias de cadenas (la cadena es inmutable y usarla directamente causa una memoria drástica y problemas de velocidad), por lo que no va a usar memoria muy grande y no va a ralentizar la velocidad (excepto un pase adicional a través del cadena al principio).

 emailaddress.Replace(" ", string.empty); 

Hay muchas formas diferentes, algunas más rápidas que otras:

 public static string StripTabsAndNewlines(this string str) { //string builder (fast) StringBuilder sb = new StringBuilder(str.Length); for (int i = 0; i < str.Length; i++) { if ( ! Char.IsWhiteSpace(s[i])) { sb.Append(); } } return sb.tostring(); //linq (faster ?) return new string(str.ToCharArray().Where(c => !Char.IsWhiteSpace(c)).ToArray()); //regex (slow) return Regex.Replace(str, @"\s+", "") } 

Utilice el método TrimEnd() de la clase String . Puedes encontrar un buen ejemplo aquí.

 string str = "Hi!! this is a bunch of text with spaces"; MessageBox.Show(new String(str.Where(c => c != ' ').ToArray())); 

Debería considerar reemplazar espacios en el conjunto de registros dentro de su procedimiento almacenado o consulta utilizando la función REPLACE( ) si es posible y aún mejor corregir sus registros de base de datos dado que un espacio en una dirección de correo electrónico no es válido.

Como lo mencionaron otros, necesitarías hacer un perfil de los diferentes enfoques. Si está utilizando Regex, debería hacerlo mínimamente como una variable estática de nivel de clase:

 public static Regex MultipleSpaces = new Regex(@"\s+", RegexOptions.Compiled); 

emailAddress.Where(x=>{ return x != ' ';}).ToString( ) probablemente tenga una sobrecarga de funciones, aunque podría ser optimizado para ser alineado por Microsoft. De nuevo, los perfiles le darán la respuesta.

El método más eficiente sería asignar un búfer y copiar carácter por carácter en un nuevo búfer y omitir los espacios a medida que lo hace. C # admite apuntadores para que pueda usar código inseguro, asignar un búfer en bruto y usar la aritmética del puntero para copiar como en C y eso es lo más rápido posible. El REPLACE( ) en SQL lo manejará así.

 string input =Yourinputstring; string[] strings = input.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); foreach (string value in strings) { string newv= value.Trim(); if (newv.Length > 0) newline += value + "\r\n"; } 
 string s = " Your Text "; string new = s.Replace(" ", string.empty); // Output: // "YourText" 

La forma más rápida y general de hacer esto (los terminadores de línea, las tabs también se procesarán). Las poderosas instalaciones de Regex no son realmente necesarias para resolver este problema, pero Regex puede reducir el rendimiento.

 new string (stringToRemoveWhiteSpaces .Where ( c => !char.IsWhiteSpace(c) ) .ToArray() )