Abholen müssen, Zeilenende-Zeichen mit StreamReader.ReadLine()

Ich würde empfehlen, dass Sie Ihre Architektur zu arbeiten, die mehr wie ein parser in einem compiler.

Den Sie erstellen möchten, ein lexer, gibt eine Sequenz von Token und dann ein parser liest die Abfolge der Token und macht Sachen mit Ihnen.

In Ihrem Fall die Token wäre:

1. Spalte Daten
2. Komma
3. Ende der Zeile

Würden Sie behandeln '\n' ('\x0a') von selbst als eine eingebettete neue-Zeile -, und daher als Teil einer Spalte Daten-token. Ein '\r\n' wäre eine End-of-Line-token.

Dies hat die Vorteile:

1. Nur 1 Durchlauf über die Daten
2. Nur die Speicherung von maximal 1 Zeilen Wert von Daten
3. Die Wiederverwendung von so viel Arbeitsspeicher wie möglich (für die string-generator und die Liste)
4. Es ist leicht zu ändern, sollten sich Ihre Anforderungen ändern

Hier ist ein Beispiel, was der Lexer würde wie folgt Aussehen:

Haftungsausschluss: ich habe nicht selbst kompiliert, geschweige denn getestet, dieser code, so dass Sie brauchen werden, um es zu säubern und sicherzustellen, dass es funktioniert.

enum TokenType
{
    ColumnData,
    Comma,
    LineTerminator
}

class Token
{
    public TokenType Type { get; private set;}
    public string Data { get; private set;}

    public Token(TokenType type)
    {
        Type = type;
    }

    public Token(TokenType type, string data)
    {
        Type = type;
        Data = data;
    }
}

private  IEnumerable<Token> GetTokens(TextReader s)
{
   var builder = new StringBuilder();

   while (s.Peek() >= 0)
   {
       var c = (char)s.Read();
       switch (c)
       {
           case ',':
           {
               if (builder.Length > 0)
               {
                   yield return new Token(TokenType.ColumnData, ExtractText(builder));
               }
               yield return new Token(TokenType.Comma);
               break;
           }
           case '\r':
           {
                var next = s.Peek();
                if (next == '\n')
                {
                    s.Read();
                }

                if (builder.Length > 0)
                {
                    yield return new Token(TokenType.ColumnData, ExtractText(builder));
                }
                yield return new Token(TokenType.LineTerminator);
                break;
           }
           default:
               builder.Append(c);
               break;
       }

   }

   s.Read();

   if (builder.Length > 0)
   {
       yield return new Token(TokenType.ColumnData, ExtractText(builder));
   }
}

private string ExtractText(StringBuilder b)
{
    var ret = b.ToString();
    b.Remove(0, b.Length);
    return ret;
}

Ihre "parser" code würde dann wie folgt Aussehen:

public void ConvertXLS(TextReader s)
{
    var columnData = new List<string>();
    bool lastWasColumnData = false;
    bool seenAnyData = false;

    foreach (var token in GetTokens(s))
    {
        switch (token.Type)
        {
            case TokenType.ColumnData:
            {
                 seenAnyData = true;
                 if (lastWasColumnData)
                 {
                     //TODO: do some error reporting
                 }
                 else
                 {
                     lastWasColumnData = true;
                     columnData.Add(token.Data);
                 }
                 break;
            }
            case TokenType.Comma:
            {
                if (!lastWasColumnData)
                {
                    columnData.Add(null);
                }
                lastWasColumnData = false;
                break;
            }
            case TokenType.LineTerminator:
            {
                if (seenAnyData)
                {
                    OutputLine(lastWasColumnData);
                }
                seenAnyData = false;
                lastWasColumnData = false;
                columnData.Clear();
            }
        }
    }

    if (seenAnyData)
    {
        OutputLine(columnData);
    }
}

Im wesentlichen, einen hard-return in Excel (shift+enter oder alt+enter, ich kann mich nicht erinnern) setzt einen Zeilenumbruch, das ist äquivalent zu \x0A in der Standard-Codierung verwende ich das schreiben meiner CSV. Wenn ich Schreibe das CSV-Format, ich benutze StreamWriter.WriteLine(), die Ausgänge der Linie plus ein newline (was ich glaube, ist \r\n).

Die CSV ist gut und kommt genau wie Excel speichern, das problem ist, wenn ich Lesen Sie es in den leeren Datensatz Entferner, bin ich mit ReadLine (), die zu behandeln, wird ein Datensatz mit einem eingebetteten newline als ein CRLF.

Hier ist ein Beispiel für die Datei nach dem konvertieren der CSV...

Reference,Name of Individual or Entity,Type,Name Type,Date of Birth,Place of Birth,Citizenship,Address,Additional Information,Listing Information,Control Date,Committees
1050,"Aziz Salih al-Numan
",Individual,Primary Name,1941 or 1945,An Nasiriyah,Iraqi,,Ba’th Party Regional Command Chairman; Former Governor of Karbala and An Najaf Former Minister of Agriculture and Agrarian Reform (1986-1987),Resolution 1483 (2003),6/27/2003,1518 (Iraq)
1050a,???? ???? ???????,Individual,Original script,1941 or 1945,An Nasiriyah,Iraqi,,Ba’th Party Regional Command Chairman; Former Governor of Karbala and An Najaf Former Minister of Agriculture and Agrarian Reform (1986-1987),Resolution 1483 (2003),6/27/2003,1518 (Iraq)

Wie Sie sehen können, der erste Datensatz hat eine eingebettete neue-Zeile nach al-Numan. Wenn ich mit ReadLine(), bekomme ich die Meldung '1050,"Aziz Salih al-Numan' und wenn ich Schreibe, dass aus, WriteLine() endet diese Zeile mit einem CRLF. Ich verliere das original-line terminator. Wenn ich mit ReadLine() erneut, bekomme ich die Zeile beginnend mit '1050a'.

Konnte ich die gesamte Datei zu Lesen und diese zu ersetzen, aber dann müsste ich ersetzen, Sie wieder hinterher. Im Grunde, was ich tun möchten ist, bekommen die line terminator zu bestimmen, ob seine \x0a oder ein CRLF, und dann, wenn seine \x0A, werde ich verwenden, Write() und insert, der terminator.

Danke, dass Sie so viel mit Ihrem code und einige andere, kam ich mit der folgenden Lösung! Ich habe einen link unten, um einige code, den ich schrieb, dass die Logik von dieser Seite. Ich dachte, ich würde geben, Ehren, denen Ehre war fällig! Danke!

Unten ist eine Erklärung über das, was ich gebraucht habe:
Versuchen Sie Dieses, ich schrieb dies, weil ich einige sehr große '|' Trennzeichen getrennte Dateien, die \r\n im inneren von einigen der Spalten und ich brauchte, um \r\n als Zeilenende-Trennzeichen. Ich war versucht, zu importieren einige Dateien mit Hilfe von SSIS-Pakete, aber aufgrund von fehlerhaften Daten in den Dateien, die ich nicht in der Lage war zu. Die Datei war über 5 GB, so war es zu groß, zu öffnen und manuell zu beheben. Ich fand die Antwort durch die Suche durch viele Foren, um zu verstehen, wie die streams funktionieren und endete kommen mit einer Lösung, die liest jedes Zeichen in einer Datei und spuckt die Linie basiert auf den Definitionen, die ich Hinzugefügt. dies ist für die Verwendung in einer Kommandozeilen-Anwendung, komplett mit helfen :). Ich hoffe das hilft einigen anderen Menschen aus, habe ich noch keine Lösung gefunden, ganz wie es anderswo, obwohl die Ideen waren inspiriert durch dieses forum und andere.

https://stackoverflow.com/a/12640862/1582188