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

Zitat von Ghostwalker:

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 *)

Und wie ruf ich das dann auf?
Muss ich da noch was beachten?

Gruß Matthias

Wenn ich das nach einem flüchtigen Blick richtig verstanden habe, erzeugst Du eine TCopyFile-Instanz, weist Sourcefile und Destination zu und rufst dann Copy (ohne Thread) oder CopyAsync (mit Thread) auf.

Genau wie DeddyH sagt

Man kann das ganze auch noch ausbauen, in dem man z.B. statt einzelner Dateien, mehrere nimmt (in deinem Fall also erst mal ein paar sammeln und dann kopieren).