¿Cómo reemplazo múltiples espacios con un solo espacio en C #?

¿Cómo puedo reemplazar múltiples espacios en una cadena con solo un espacio en C #?

Ejemplo:

1 2 3  4    5

sería:

1 2 3 4 5

string sentence = "This is a sentence with multiple    spaces";
RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);     
sentence = regex.Replace(sentence, " ");

Me gusta usar:

myString = Regex.Replace(myString, @"\s+", " ");

Ya que capturará ejecuciones de cualquier tipo de espacio en blanco (por ejemplo, pestañas, líneas nuevas, etc.) y las reemplazará con un solo espacio.

string xyz = "1   2   3   4   5";
xyz = string.Join( " ", xyz.Split( new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries ));

Creo que la respuesta de Matt es la mejor, pero no creo que sea correcta. Si desea reemplazar las nuevas líneas, debe usar:

myString = Regex.Replace(myString, @"\s+", " ", RegexOptions.Multiline);

Otro enfoque que usa LINQ:

 var list = str.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));
 str = string.Join(" ", list);

Es mucho más simple que todo eso:

while(str.Contains("  ")) str = str.Replace("  ", " ");

Regex puede ser bastante lento incluso con tareas simples. Esto crea un método de extensión que puede usarse fuera de cualquier string.

    public static class StringExtension
    {
        public static String ReduceWhitespace(this String value)
        {
            var newString = new StringBuilder();
            bool previousIsWhitespace = false;
            for (int i = 0; i < value.Length; i++)
            {
                if (Char.IsWhiteSpace(value[i]))
                {
                    if (previousIsWhitespace)
                    {
                        continue;
                    }

                    previousIsWhitespace = true;
                }
                else
                {
                    previousIsWhitespace = false;
                }

                newString.Append(value[i]);
            }

            return newString.ToString();
        }
    }

Sería utilizado como tal:

string testValue = "This contains     too          much  whitespace."
testValue = testValue.ReduceWhitespace();
// testValue = "This contains too much whitespace."

myString = Regex.Replace(myString, " {2,}", " ");

Para aquellos a quienes no les gusta Regex, aquí hay un método que utiliza StringBuilder:

    public static string FilterWhiteSpaces(string input)
    {
        if (input == null)
            return string.Empty;

        StringBuilder stringBuilder = new StringBuilder(input.Length);
        for (int i = 0; i < input.Length; i++)
        {
            char c = input[i];
            if (i == 0 || c != ' ' || (c == ' ' && input[i - 1] != ' '))
                stringBuilder.Append(c);
        }
        return stringBuilder.ToString();
    }

En mis pruebas, este método fue 16 veces más rápido en promedio con un conjunto muy grande de cadenas de tamaño pequeño a mediano, en comparación con un Regex compilado estático. En comparación con un Regex no compilado o no estático, esto debería ser aún más rápido.

Tenga en cuenta que no elimina los espacios iniciales o finales, solo ocurre múltiples veces .

¡Simplemente puede hacer esto en una solución de línea!

string s = "welcome to  london";
s.Replace(" ", "()").Replace(")(", "").Replace("()", " ");

Puede elegir otros corchetes (o incluso otros caracteres) si lo desea.

Esta es una versión más corta, que solo debe usarse si solo lo hace una vez, ya que crea una nueva instancia de la Regexclase cada vez que se llama.

temp = new Regex(" {2,}").Replace(temp, " "); 

Si no está demasiado familiarizado con las expresiones regulares, aquí hay una breve explicación:

Esto {2,}hace que la expresión regular busque el carácter que le precede, y encuentra subcadenas entre 2 e ilimitadas veces.
El .Replace(temp, " ")reemplaza todas las coincidencias en la cadena temporal con un espacio.

Si desea usar esto varias veces, aquí hay una mejor opción, ya que crea la IL de expresión regular en tiempo de compilación:

Regex singleSpacify = new Regex(" {2,}", RegexOptions.Compiled);
temp = singleSpacify.Replace(temp, " ");

no Regex, no Linq ... elimina los espacios iniciales y finales, así como reduce cualquier segmento de espacio múltiple incrustado a un espacio

string myString = "   0 1 2  3   4               5  ";
myString = string.Join(" ", myString.Split(new char[] { ' ' }, 
StringSplitOptions.RemoveEmptyEntries));

resultado: "0 1 2 3 4 5"

Consolidando otras respuestas, según Joel, y con suerte mejorando ligeramente a medida que avanzo:

Puedes hacer esto con Regex.Replace():

string s = Regex.Replace (
    "   1  2    4 5", 
    @"[ ]{2,}", 
    " "
    );

O con String.Split():

static class StringExtensions
{
    public static string Join(this IList<string> value, string separator)
    {
        return string.Join(separator, value.ToArray());
    }
}

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

Acabo de escribir una nueva Joinque me gusta, así que pensé en volver a responder, con ella:

public static string Join<T>(this IEnumerable<T> source, string separator)
{
    return string.Join(separator, source.Select(e => e.ToString()).ToArray());
}

Una de las cosas interesantes de esto es que funciona con colecciones que no son cadenas, al llamar a ToString () en los elementos. El uso sigue siendo el mismo:

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

      // Mysample string
            string str ="hi you           are          a demo";

            //Split the words based on white sapce
            var demo= str .Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));

            //Join the values back and add a single space in between
                    str = string.Join(" ", demo);

//output: string str ="hi you are a demo";

Sé que esto es bastante viejo, pero me encontré con esto al intentar lograr casi lo mismo. Encontré esta solución en RegEx Buddy. Este patrón reemplazará todos los espacios dobles con espacios individuales y también recortará los espacios iniciales y finales.

pattern: (?m:^ +| +$|( ){2,})
replacement: $1

Es un poco difícil de leer ya que estamos tratando con un espacio vacío, así que aquí está nuevamente con los "espacios" reemplazados por un "_".

pattern: (?m:^_+|_+$|(_){2,})  <-- don't use this, just for illustration.

La construcción "(? M:" habilita la opción "multilínea". En general, me gusta incluir todas las opciones que pueda dentro del patrón para que sea más autónomo.

Muchas respuestas están proporcionando el resultado correcto, pero para aquellos que buscan las mejores actuaciones, mejoré la respuesta de Nolanar (que fue la mejor respuesta para el rendimiento) en aproximadamente un 10%.

public static string MergeSpaces(this string str)
{

    if (str == null)
    {
        return null;
    }
    else
    {
        StringBuilder stringBuilder = new StringBuilder(str.Length);

        int i = 0;
        foreach (char c in str)
        {
            if (c != ' ' || i == 0 || str[i - 1] != ' ')
                stringBuilder.Append(c);
            i++;
        }
        return stringBuilder.ToString();
    }

}

Puedo eliminar espacios en blanco con esto

while word.contains("  ")  //double space
   word = word.Replace("  "," "); //replace double space by single space.
word = word.trim(); //to remove single whitespces from start & end.

Usa el patrón regex

    [ ]+    #only space

   var text = Regex.Replace(inputString, @"[ ]+", " ");

prueba este método

private string removeNestedWhitespaces(char[] st)
{
    StringBuilder sb = new StringBuilder();
    int indx = 0, length = st.Length;
    while (indx < length)
    {
        sb.Append(st[indx]);
        indx++;
        while (indx < length && st[indx] == ' ')
            indx++;
        if(sb.Length > 1  && sb[0] != ' ')
            sb.Append(' ');
    }
    return sb.ToString();
}

úsalo así:

string test = removeNestedWhitespaces("1 2 3  4    5".toCharArray());

Aquí hay una ligera modificación en la respuesta original de Nolonar .

Verificando si el personaje no es solo un espacio, sino cualquier espacio en blanco, use esto:

Reemplazará cualquier carácter de espacio en blanco múltiple con un solo espacio.

public static string FilterWhiteSpaces(string input)
{
    if (input == null)
        return string.Empty;

    var stringBuilder = new StringBuilder(input.Length);
    for (int i = 0; i < input.Length; i++)
    {
        char c = input[i];
        if (i == 0 || !char.IsWhiteSpace(c) || (char.IsWhiteSpace(c) && 
            !char.IsWhiteSpace(strValue[i - 1])))
            stringBuilder.Append(c);
    }
    return stringBuilder.ToString();
}

Vieja escuela:

string oldText = "   1 2  3   4    5     ";
string newText = oldText
                    .Replace("  ", " " + (char)22 )
                    .Replace( (char)22 + " ", "" )
                    .Replace( (char)22 + "", "" );

Assert.That( newText, Is.EqualTo( " 1 2 3 4 5 " ) );

Sin usar expresiones regulares:

while (myString.IndexOf("  ", StringComparison.CurrentCulture) != -1)
{
    myString = myString.Replace("  ", " ");
}

Está bien usarlo en cadenas cortas, pero funcionará mal en cadenas largas con muchos espacios.

Mezcla de StringBuilder y Enumerable.Aggregate () como método de extensión para cadenas:

using System;
using System.Linq;
using System.Text;

public static class StringExtension
{
    public static string StripSpaces(this string s)
    {
        return s.Aggregate(new StringBuilder(), (acc, c) =>
        {
            if (c != ' ' || acc.Length > 0 && acc[acc.Length-1] != ' ')
                acc.Append(c);

            return acc;
        }).ToString();
    }

    public static void Main()
    {
        Console.WriteLine("\"" + StringExtension.StripSpaces("1   Hello       World  2   ") + "\"");
    }
}

Entrada:

"1   Hello       World  2   "

Salida:

"1 Hello World 2 "