Hi @ all,

mein Ziel ist es nicht einen dienst zu scheiben, der meinen Speicher ins Chaos stürzt...
Auch keinen, der für mich aufräumt...

Aber ich habe einen die Dienst, der mir Netzwerkanfragen zu lokalen Anfragen "übersetzt".
Bei jeder Anfrage über Tcpip mach ich mir ein Command-Obj.
In dem sind solche sachen wie der Socket gespeichert, von dem gefragt wurde. (Wenn ich nicht ganz falsch liege macht delphi da ne 32 Bit referenz auf das Obj draus...)

Des Weiteren sind da noch ein paar andere kleinigkeiten drin.. ein string und ne id...

Und eine einzelde Funtktion, die aufgerufen wird, wenn das obj seine antwort bekommt..

also:

zusammenfalten · markieren

Delphi-Quellcode:

[pseudo Delphi]
procedure AnfrageKommt();
begin
  Obj wird erzeugt
  Die Funk den Obj wird als callback registriert...
end;

// Die "vergesse" ich das obj... es ist aber noch im speicher und ich kenne dessen funk...

procedure callback()
begin
  das obj bbekommt seine antwort
  macht das was es machen soll
  und ruft dann FreeAndNil(Self); auf
end;
[/pseudo Delphi]

Aber bei jedem Aufruf wächst mein Programm 4kb im Speicher (sysinternals Taskman) ... Wieso?
Kann das mit der Art und Weise zusammen hängen, wie Delphi den Speicher verwaltet?
Oder ist das mal wieder eins der "don'ts" die ich da mache ^^

thx für's drüber Nachdenken
cya
Corelgott

Es wäre besser, wenn du uns deinen richtigen Code gibst und nicht ein Pseudo Code

kk

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ScktComp;

type
  TResultCallback = procedure(cmd : String; answer : String) of Object;

type
  TServerCmdObj = class(TObject)
  private
    _sock : TCustomWinSocket;
    _cmd : String;
  public
    procedure recieve(cmd : String; answer : String);
    property Socket : TCustomWinSocket read _sock write _sock;
    property Command : String read _cmd write _cmd;
end;

{...}

procedure TForm1.ServerSocket1ClientRead(Sender: TObject;
  Socket: TCustomWinSocket);
var
  cmdObj : TServerCmdObj;
begin
  cmdObj := TServerCmdObj.Create(); // create an cmdObj
  cmdObj.Socket := Socket; // bind the socket
  cmdObj.Command := Socket.ReceiveText(); // set the cmd
  commit(cmdObj.Command, cmdObj.recieve); // tell to be handled
end;

procedure tForm1.commit(cmd : String; proc : TResultCallback);
var
  res : String; // the glorious string to be the result
begin
  res := magicFunction(cmd); // somthing will happen to to it

  if (proc <> nil) then // if we got a vaild callback
    proc(cmd, res); // well call it!
end;

procedure TServerCmdObj.recieve(cmd, answer: String); // is called if the result is calced
begin
  self._sock.SendText(answer); // if the command has been processed
  FreeAndNil(Self); // commit suicide
end;

end.

besser? ^^

aber schon mal thx für's nachdenken ^^

cya
Corelgott

Bei jedem ClientRead erzeugst du ein TServerCmdOb. Und jetzt denk mal drüber nach.

Oo

Ach nee luckie.. das ist auch so gedacht...
aber bei jeden obj wird ja auch:

markieren

Delphi-Quellcode:

procedure TServerCmdObj.recieve(cmd, answer: String); // is called if the result is calced
begin
  self._sock.SendText(answer); // if the command has been processed
  (************** ZAUNPFAHL schwenk ********************)
  FreeAndNil(Self); // commit suicide
  (************** ZAUNPFAHL schwenk ********************)
end;

gemacht?
Dadurch kommt ja auch jedes obj weg ^^
oder nicht?

thx für's nachdenken
cya
Corelgott

[**push**]
Hatte da nochmal wer Lust drüber nach zu denken?

thx
Corelgott