Zitat:

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

Ich meine ja auch nur, wenn man vorhat es später auszubauen

Hallo,

werde mir die lange und die 2zeilerfassung anschauen, danke für die Diskussion, ich muss noch Zeit finden das zu testen und meld mich evtl. wieder. (muss den ganzen Nachmittag noch von einer Besprechung zur anderen )

Danke erstmal an die Manschaft.

Gruß Matthias

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