Nach .cvs Dateiauslesen string in Record schreiben

[Osse]

Hallo,

ich möchte eine .csv Datei auslesen. Die Daten sind folgendermassen aufgebaut : '2;45;5;56;'.
Kann die Datei auch auslesen. Anschließend möchte ich den String in einen Recrod schreiben. Habe nur Integerwerte.

Mein Problem: ich kann immer nur eine Zahl auslesen.

Ok, ein Bsp: 45

hab schon die 4 ausgelesen. Jetzt die um einen nach links shiften und die 5 hinten anhängen.

Hier der entsprechende Auszug aus meinem Programm:

Delphi-Quellcode:

procedure TForm1.ffnen1Click(Sender: TObject);
var
   datei : textFile;
   Einlesestring : string;
   zaehler : Integer;
   Stringzaehler : Integer;
   Recordeintrag : Integer;
   EinleseRCVMsg : TCANRcvMsg;
   Zwischenspeicher : cardinal;
begin
  if OpenDialog1.Execute then
    begin
   Assignfile(Datei, OpenDialog1.FileName);
   Reset(Datei);      // Datei zurücksetzen
   zaehler := 0;              // Daten auslesen bis zum Ende
   while not EOF(Datei) do    // und in einen Record schreiben, der später
   begin         // weiterverarbeitet wird
     readln(Datei,Einlesestring);
     inc(zaehler);
     Recordeintrag := 0;
     for Stringzaehler := 1 to Length(Einlesestring)-1 do
       begin
      if (Einlesestring[Stringzaehler] = ';') then
              begin
          inc(Recordeintrag);
          case Recordeintrag of
               1:  EinleseRCVMsg.msgbuff.ID                  := Zwischenspeicher;
               2:  EinleseRCVMsg.msgbuff.MSGTYPE             := Zwischenspeicher;
         3:  EinleseRCVMsg.msgbuff.LEN                 := Zwischenspeicher;
         4:  EinleseRCVMsg.msgbuff.DATA[0]             := Zwischenspeicher;
         5:  EinleseRCVMsg.msgbuff.DATA[1]            := Zwischenspeicher;
         6:  EinleseRCVMsg.msgbuff.DATA[2]             := Zwischenspeicher;
         7:  EinleseRCVMsg.msgbuff.DATA[3]             := Zwischenspeicher;
           end;
         end
      else
       // abfrage und danach nach links shiften 
                   Zwischenspeicher := StrToInt(Einlesestring[Stringzaehler]);
                    
      end;
        end;
        end;
end;

gibt es noch ne einfachere Methode???

Sollte natürlich wie immer sehr schnell gehen. Was besseres ist mir bis jetzt noch nicht eingefallen.

Hatte jemand schon mal so ein Problem und hat dies Einfacher gelöst??

[Steve]

Hi,

es gäbe da z.B. die Routine explode, die Dir weiterhelfen könnte. Ansonsten auch selbstgemacht mit Pos, PosEx, Copy usw.

Gruß
Stephan

[franktron]

Such mal im Forum nach CSV und du first sehr schnell fündig

[marabu]

Hallo Osse,

hier ein wenig Code für dich zum Lesen - vielleicht bringt es dich ein wenig auf den Weg. Die Action cmdFileOpen musst du deinem Button oder MenuItem zuweisen.

Delphi-Quellcode:

type
  PCANRcvMsg = ^TCANRcvMsg;
  TCANRcvMsg = record
    ID: word;
    MsgType: cardinal;
    Len: 0..15;
    Data: array [0..3] of byte;
  end;

var
  MessageList: TList;

procedure TMainForm.ReadMessages(fileName: string; msgList: TList);
var
  line: string;
  lineCount: integer;
  sl: TStringList;
  st: TStringList;
  i: integer;
  msg: PCANRcvMsg;
begin
  AssignFile(input, fileName);
  Reset(input); // Öffnen für LESEN
  lineCount := 0;
  st := TStringList.Create;
  st.Delimiter := ';';
  while not Eof do begin
    ReadLn(line);
    Inc(lineCount);
    st.DelimitedText := line;
    New(msg);
    with msg^ do
      for i := 0 to sl.Count - 1 do begin
        ID := StrToInt(sl[0]);
        MsgType := StrToInt(sl[1]);
        Len := StrToInt(sl[2]);
        Data[0] := StrToInt(sl[3]);
        Data[1] := StrToInt(sl[4]);
        Data[2] := StrToInt(sl[5]);
        Data[3] := StrToInt(sl[6]);
      end;
    msgList.Add(msg);
  end;
  st.Free;
end;

procedure TMainForm.cmdFileOpenExecute(Sender: TObject);
begin
  with OpenDialog do
    if Execute then begin
      MessageList := TList.Create;
      ReadMessages(FileName, MessageList);
    end;
end;

Grüße vom marabu

[Osse]

Danke an alle.

Hab das jetzt mit Zeigern gelöst.

Bin ich zunächst nicht drauf gekommen

Falls jemand das gleiche Problem hat:

Delphi-Quellcode:

//******************************************************************************
// Auslesen der .csv Datei und schreiben in ein Record vom Typ RCVMsg. Zunächst
// wird der Kopf der Datei abgeschnitten und anschließend werden die Daten
// ausgelesen. Dabei wird die eingelesen Reihe aus der Dateí in einen sting
// zwischengespeichert. Anschließend wird dann dieser String zerlegt und in den
// Record geschrieben. Dies geschieht mit Hilfe von Pointern, die die jeweiligen
// Bezugspunkte angeben.
//
// Eingabeparameter :    - Dateiname   : Name und Pfad der zu öffnenden Datei
//
// Rückgabewert :            ------
//******************************************************************************
procedure TForm1.DateiAuslesen(Dateiname : string);
var
   datei : textFile;
  Einlesestring : string;                                      //Der eingelesene String wird
  Zwischenspeicher : string;                                   //Hier wird der Ausgabestring gespeichert
   zaehler : Integer;                                           //Hilfsvariable
   Stringzaehler : Integer;                                     //zählt die einzelnen Felder des eingelesenen Strings hoch
   Recordeintrag : Integer;                                     //Zähler für die einzelnen Recordeinträge
   EinleseRCVMsg : TCANRcvMsg;                                  //Zwischenspeicher für die ausgelesenen Nachrichten
  Abstandszaehler  : cardinal;                                 //wenn kein Trennzeichen gefunden wurde, dann Daten Ausgeben
  ZeigerAnfangEinlesestring, ZeigerEndeEinlesestring : PChar;  //Zeiger auf Anfang und ende, beim Auslesen der Daten
begin
   Assignfile(Datei, Dateiname);
   Reset(Datei);                           // Datei zurücksetzen
   for zaehler := 0 to 7 do      // Anfang auslesen und abschneiden
      readln(Datei,Einlesestring);
   while not EOF(Datei) do
      begin  // Datei auslesen
         readln(Datei,Einlesestring);    // eine Zeile auslesen
         Recordeintrag := 0;             // Record initalisieren, da immer ein Eintrag höher gezählt wird
      Abstandszaehler := 0;
      ZeigerAnfangEinlesestring := Pchar(Einlesestring);       //Zeiger auf den beginn des Strings setzen
      for Stringzaehler := 1 to Length(Einlesestring)+1 do     //einmal den gesamten eingelesenen string durchlaufen
            begin  // String auslesen                              //Ausgabe entwerder wenn Trennzeichen gefunden oder String am Ende
               if (Einlesestring[Stringzaehler] = ';') or (Stringzaehler = (Length(Einlesestring)+1)) then
                  begin
                     inc(Recordeintrag);                              //in den nächsten Recordeintrag schreiben
              ZeigerEndeEinlesestring := ZeigerAnfangEinlesestring + Abstandszaehler; // Ende des auszulesenden Strings berechnen
              // String schreiben, in den berechneten grenzen
              SetString(Zwischenspeicher, ZeigerAnfangEinlesestring, ZeigerEndeEinlesestring - ZeigerAnfangEinlesestring);
              // Ergebnis in Record schreiben
                     case Recordeintrag of
                        1:  EinleseRCVMsg.msgbuff.ID              := StrToInt(Zwischenspeicher);
                2:  EinleseRCVMsg.msgbuff.MSGTYPE             := StrToInt(Zwischenspeicher);
                        3:  EinleseRCVMsg.msgbuff.LEN                 := StrToInt(Zwischenspeicher);
                        4:  EinleseRCVMsg.msgbuff.DATA[0]             := StrToInt(Zwischenspeicher);
                        5:  EinleseRCVMsg.msgbuff.DATA[1]               := StrToInt(Zwischenspeicher);
                        6:  EinleseRCVMsg.msgbuff.DATA[2]             := StrToInt(Zwischenspeicher);
                        7:  EinleseRCVMsg.msgbuff.DATA[3]             := StrToInt(Zwischenspeicher);
                        8:  EinleseRCVMsg.msgbuff.DATA[4]             := StrToInt(Zwischenspeicher);
                        9:  EinleseRCVMsg.msgbuff.DATA[5]             := StrToInt(Zwischenspeicher);
                        10: EinleseRCVMsg.msgbuff.DATA[6]             := StrToInt(Zwischenspeicher);
                       11: EinleseRCVMsg.msgbuff.DATA[7]             := StrToInt(Zwischenspeicher);
                        12: EinleseRCVMsg.hNet                        := StrToInt(Zwischenspeicher);
                        13: EinleseRCVMsg.rcvtime.millis                := StrToInt(Zwischenspeicher);
                        14: EinleseRCVMsg.rcvtime.millis_overflow := StrToInt(Zwischenspeicher);
                        15: EinleseRCVMsg.rcvtime.micros          := StrToInt(Zwischenspeicher);
                     end;  // case
              ZeigerAnfangEinlesestring := ZeigerEndeEinlesestring+1; // neuen Anfangspunkt bestimmen
              Abstandszaehler := 0;                                   // hilfszäher zurücksetzen, der den Absatnd zwischen
                                                                      // Anfang und Ende angibt
            end
          else                                                  // wenn kein Trennzeichen gefunden wurde, dann ist eine Zeichen-
                   begin                                               // kette vorhanden. Es wird der abstand erhöht
                     inc(Abstandszaehler);
                   end;
            end;   // String auslesen
        RcvMsgList.UpdateMsg(   EinleseRCVMsg.msgbuff,
                                             EinleseRCVMsg.hNet,
                                             EinleseRCVMsg.rcvtime.millis);
      end;   // Datei auslesen
end;