Hallo zusammen,


ich hab an einer Maschine Dateien die abgelegt werden, Nun möchte ich erkennen wann bestimmte Dateien abgelegt werden (ist ja schonmal kein Problem) und diese dann wegschreiben, da die Maschine nach einiger Zeit die Dateien wieder löscht.

Das kopieren wollte ich in einem eigenem Thread starten, damit meine Hauptanwendung die am Leitrechner läuft nicht von dieser kopierarbeit unterbrochen wird.

Bisher hab ich noch nichts mit Multithreading gemacht. Gibt es speziell für den Anwendungsfall (gute) Tutorials. Die Codefetzen die ich mit Google oder Suche gefunden habe helfen mir leider nicht weiter. Und was muss ich beachten wenn ich einen Thread starte.


Gruß Matthias

Sofern die system.Threading Unit in Delphi (ab XE7) existiert, kann man das so machen:

zusammenfalten · markieren

Delphi-Quellcode:

uses
  System.Threading, System.IOUtils;

procedure TForm3.Button1Click(Sender: TObject);
var
  LCopyTask : ITask;
  LFromfile : string;
  LToFile : string;
begin

  LFromFile := 'C:\Datei.txt';
  LToFile := 'D:\DateiCopy.txt';

  LCopyTask := TTask.Run(procedure ()
     begin
        TFile.Copy(LFromFile, LToFile);
     end);
end;

Zitat von Bambini:

Sofern die system.Threading Unit in Delphi (ab XE7) existiert, kann man das so machen:

Laut Profil hat er aber XE2. Es sei denn die Angabe stimmt nicht mehr.

Zitat von Aviator:

Zitat von Bambini:

Sofern die system.Threading Unit in Delphi (ab XE7) existiert, kann man das so machen:

Laut Profil hat er aber XE2. Es sei denn die Angabe stimmt nicht mehr.

... war bei mir auch nicht aktuell.
Ohne Threading Unit kann man es so machen:

markieren

Delphi-Quellcode:

  TThread.CreateAnonymousThread(procedure ()
     begin
        TFile.Copy(LFromFile, LToFile);
     end).Start;

Oder für ältere Delphi-Versionen:

markieren

Code:

interface
  uses windows,classes,sysutils;

TYPE
  TCopyFile = Class;

  TCopyFileThread = Class(TThread)
  PRIVATE
    fparent : TCopyFile;
  PUBLIC
    Constructor Create(parent:TCopyFile);
    procedure Execute;
  End;

  TCopyFile = Class(TObject)
    PRIVATE
      FLock: TRTLCriticalSection;
      fThread : TCopyFileThread;
      fsrc : widestring;
      fdst : widestring;

    PROTECTED
        function TryLock:boolean;
        procedure Lock;
        procedure Unlock;

    PUBLIC
       Constructor Create;
       Destructor Destroy;override;

       procedure Copy;
       procedure CopyAsync;

       property Sourcefile : widestring read fsrc write fsrc;
       property Destination: widestring read fdst write fdst;
  End;
implementation

{ TCopyFile }

procedure TCopyFile.Copy;
begin
  if (FileExists(fsrc)) then
    CopyFileEx(pchar(fsrc),pchar(fdst),false);
end;

procedure TCopyFile.CopyAsync;
begin
  if TryLock then
  begin
    Try
      if (assigned(fthread)) then
        fthread.free;
      fthread := TCopyFileThread.Create(self);
    Finally
      unlock;
    End;
  end;
end;

constructor TCopyFile.Create;
begin
  inherited Create;
  InitializeCriticalSection(FLock);
  fsrc := '';
  fdst := '';
end;

destructor TCopyFile.Destroy;
begin
  if (assigned(fThread)) then
  begin
    if (not fthread.Terminated) then
      fthread.WaitFor;
    FreeAndNil(fThread);
  end;
  DeleteCriticalSection(FLock);
  inherited;
end;

procedure TCopyFile.Lock;
begin
  EnterCriticalSection(FLock);
end;

function TCopyFile.TryLock: boolean;
begin
  Result := TryEnterCriticalSection(FLock);
end;

procedure TCopyFile.Unlock;
begin
  LeaveCriticalSection(FLock);
end;

{ TCopyFileThread }

constructor TCopyFileThread.Create(parent: TCopyFile);
begin
  inherited Create(true);
  fparent := parent;
end;

procedure TCopyFileThread.Execute;
begin
  fparent.Lock;
  try
    fparent.copy;
  finally
    fparent.Unlock;
  end;
end;

(* hoffe das haut hin...habs nicht ausprobiert *)

Hallo,


danke Jungs ich wird das mal ausprobieren.

Mein Profil ist aktuell, ich dümpel immer noch mit XE2 rum

Ich würde immer die ausführliche Methode verwenden.
Denn mit der ausführlichen Methode kann man in Zukunft noch viel besser arbeiten als mit nur einem 2-Zeiler.

Zitat von Jim Carrey:

Ich würde immer die ausführliche Methode verwenden.
Denn mit der ausführlichen Methode kann man in Zukunft noch viel besser arbeiten als mit nur einem 2-Zeiler.

Warum das Rad immer wieder neu erfinden?

Weil wenn man später eine neue Funktionalität einbauen möchte (Pausefunktion oder irgendetwas Bessers), es dann viel leichter ist.
Mit dem 2-Zeiler hat man bei der ersten Entwicklung Ruhe, danach aber nur noch Stress.

Wenn wenige Zeilen alles zufriedenstellend erledigen ist es nicht sinnvoll, viel Code zu Schreiben, der das gleiche umständlich (oder vielleicht sogar auf problematische Weise) erledigt...