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. :wall:

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

[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 :dance:

[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 :wall:

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;