Remplacer les sauts de ligne dans une chaîne C #

Comment puis-je remplacer les sauts de ligne dans une chaîne en C #?

Utilisez remplacer par Environment.NewLine

myString = myString.Replace(System.Environment.NewLine, "replacement text"); //add a line terminating ;

Comme mentionné dans d'autres articles, si la chaîne provient d'un autre environnement (OS), vous devrez remplacer cette implémentation d'environnements particuliers de nouveaux caractères de contrôle de ligne .

Les solutions publiées jusqu'à présent ne remplacent Environment.NewLineou échouent que si la chaîne de remplacement contient des sauts de ligne car elles appellent string.Replaceplusieurs fois.

Voici une solution qui utilise une expression régulière pour effectuer les trois remplacements en un seul passage sur la chaîne. Cela signifie que la chaîne de remplacement peut contenir en toute sécurité des sauts de ligne.

string result = Regex.Replace(input, @"\r\n?|\n", replacementString);

Pour étendre la réponse de The.Anyi.9, vous devez également être conscient des différents types de saut de ligne généralement utilisés . En fonction de l'origine de votre fichier, vous voudrez peut-être vous assurer de saisir toutes les alternatives ...

string replaceWith = "";
string removedBreaks = Line.Replace("\r\n", replaceWith).Replace("\n", replaceWith).Replace("\r", replaceWith);

devrait vous permettre de continuer ...

J'utiliserais Environment.Newline lorsque je voulais insérer une nouvelle ligne pour une chaîne, mais pas pour supprimer toutes les nouvelles lignes d'une chaîne.

Selon votre plate-forme, vous pouvez avoir différents types de sauts de ligne, mais même au sein de la même plate-forme, souvent différents types de sauts de ligne sont utilisés. En particulier lorsqu'il s'agit de formats de fichiers et de protocoles.

string ReplaceNewlines(string blockOfText, string replaceWith)
{
    return blockOfText.Replace("\r\n", replaceWith).Replace("\n", replaceWith).Replace("\r", replaceWith);
}

Si votre code est censé s'exécuter dans différents environnements, j'envisagerais d'utiliser la Environment.NewLineconstante, car elle est spécifiquement newlineutilisée dans l'environnement spécifique.

line = line.Replace(Environment.NewLine, "newLineReplacement");

Cependant, si vous obtenez le texte d'un fichier provenant d'un autre système, ce n'est peut-être pas la bonne réponse, et vous devez remplacer par la constante de nouvelle ligne utilisée sur l'autre système. Ce sera généralement \nou \r\n.

N'oubliez pas que replace ne fait pas le remplacement dans la chaîne, mais renvoie une nouvelle chaîne avec les caractères remplacés. Ce qui suit supprimera les sauts de ligne (ne les remplacera pas). J'utiliserais la méthode @Brian R. Bondy si vous les remplaçiez par quelque chose d'autre, peut-être encapsulé comme une méthode d'extension. N'oubliez pas de vérifier les valeurs nulles avant d'appeler Replace ou les méthodes d'extension fournies.

string line = ...

line = line.Replace( "\r", "").Replace( "\n", "" );

Comme méthodes d'extension:

public static class StringExtensions
{
   public static string RemoveLineBreaks( this string lines )
   {
      return lines.Replace( "\r", "").Replace( "\n", "" );
   }

   public static string ReplaceLineBreaks( this string lines, string replacement )
   {
      return lines.Replace( "\r\n", replacement )
                  .Replace( "\r", replacement )
                  .Replace( "\n", replacement );
   }
}

Pour vous assurer que toutes les possibilités de sauts de ligne (Windows, Mac et Unix) sont remplacées, vous devez utiliser:

string.Replace("\r\n", "\n").Replace('\r', '\n').Replace('\n', 'replacement');

et dans cet ordre, pour ne pas faire de sauts de ligne supplémentaires, lorsque vous trouvez une combinaison de caractères de fin de ligne.

si vous voulez "nettoyer" les nouvelles lignes, le commentaire de flamebaud en utilisant regex @"[\r\n]+"est le meilleur choix.

using System;
using System.Text.RegularExpressions;

class MainClass {
  public static void Main (string[] args) {
    string str = "AAA\r\nBBB\r\n\r\n\r\nCCC\r\r\rDDD\n\n\nEEE";

    Console.WriteLine (str.Replace(System.Environment.NewLine, "-"));
    /* Result:
    AAA
    -BBB
    -
    -
    -CCC


    DDD---EEE
    */
    Console.WriteLine (Regex.Replace(str, @"\r\n?|\n", "-"));
    // Result:
    // AAA-BBB---CCC---DDD---EEE

    Console.WriteLine (Regex.Replace(str, @"[\r\n]+", "-"));
    // Result:
    // AAA-BBB-CCC-DDD-EEE
  }
}

Je devais remplacer le \r\npar un retour chariot et un saut de ligne \tréels et le remplacer par un onglet réel. J'ai donc trouvé ce qui suit:

public string Transform(string data)
{
    string result = data;
    char cr = (char)13;
    char lf = (char)10;
    char tab = (char)9;

    result = result.Replace("\\r", cr.ToString());
    result = result.Replace("\\n", lf.ToString());
    result = result.Replace("\\t", tab.ToString());

    return result;
}

Pourquoi pas les deux?

string ReplacementString = "";

Regex.Replace(strin.Replace(System.Environment.NewLine, ReplacementString), @"(\r\n?|\n)", ReplacementString);

Remarque: remplacez strinpar le nom de votre chaîne d'entrée.

var answer = Regex.Replace(value, "(\n|\r)+", replacementString);

Utilisez la méthode .Replace ()

Line.Replace("\n", "whatever you want to replace with");

La meilleure façon de remplacer les sauts de ligne en toute sécurité est

yourString.Replace("\r\n","\n") //handling windows linebreaks
.Replace("\r","\n")             //handling mac linebreaks

cela devrait produire une chaîne avec seulement \ n (par exemple, saut de ligne) comme sauts de ligne. ce code est également utile pour corriger les sauts de ligne mixtes.

Comme la nouvelle ligne peut être délimitée par \n, \ret \r\n, d'abord, nous remplacerons \ret \r\npar \n, et ensuite seulement diviserons la chaîne de données.

Les lignes suivantes doivent aller à la parseCSVméthode:

function parseCSV(data) {
    //alert(data);
    //replace UNIX new lines
    data = data.replace(/\r\n/g, "\n");
    //replace MAC new lines
    data = data.replace(/\r/g, "\n");
    //split into rows
    var rows = data.split("\n");
}

string s = Regex.Replace(source_string, "\n", "\r\n");

ou

string s = Regex.Replace(source_string, "\r\n", "\n");

en fonction de la direction que vous souhaitez prendre.

J'espère que ça aide.

Une autre option consiste à créer un StringReadersur la chaîne en question. Sur le lecteur, faites .ReadLine()en boucle. Ensuite, vous avez les lignes séparées, peu importe les séparateurs (cohérents ou incohérents) qu'ils avaient. Avec cela, vous pouvez procéder comme vous le souhaitez; une possibilité est d'utiliser un StringBuilderet de l'appeler .AppendLine.

L'avantage est que vous laissez le cadre décider de ce qui constitue un «saut de ligne».

Si vous souhaitez remplacer uniquement les retours à la ligne:

var input = @"sdfhlu \r\n sdkuidfs\r\ndfgdgfd";
var match = @"[\\ ]+";
var replaceWith = " ";
Console.WriteLine("input: " + input);
var x = Regex.Replace(input.Replace(@"\n", replaceWith).Replace(@"\r", replaceWith), match, replaceWith);
Console.WriteLine("output: " + x);

Si vous souhaitez remplacer les retours à la ligne, les tabulations et les espaces blancs:

var input = @"sdfhlusdkuidfs\r\ndfgdgfd";
var match = @"[\\s]+";
var replaceWith = "";
Console.WriteLine("input: " + input);
var x = Regex.Replace(input, match, replaceWith);
Console.WriteLine("output: " + x);