Chat mit PM

[xZise]

Deine "Vereinfachung" ist doch keine Vereinfachung. Wenn du sagst das die Befehle kein Leerzeichen haben, dann machst du einfach:

Delphi-Quellcode:

var
  command : string;
begin
  command := Copy(input, 1, Pos(' ', input) - 1);

Dann hast du schon mal den Befehl und den Nick bekommst du ähnlich einfach:

Delphi-Quellcode:

var
  command : string;
  reciever : string;
  message : string

  delimToCommand : Integer;
  delimToReciever : Integer;
begin
  delimToCommand := Pos(' ', input); // Dort ist das erste Leerzeichen
  delimToReciever := PosEx(' ', input, delimToCommand + 1); // Da das zweite
  command := Copy(input, 1, delimToCommand - 1);
  reciever := Copy(input, delimToCommand + 1, delimToReciever - delimToCommand - 1);
  message := Copy(input, delimToReciever, Length(input) - delimToReciever);

Man könnte auch Explode verwenden, aber das könnte zu übereifrig werden, wenn weitere Leerzeichen kommen.

Übrigens habe ich deshalb auch vorgeschlagen mehrere Zeilen zu nehmen. Dann hättest du einfach machen können:

Delphi-Quellcode:

var
  msg : TStrings;

  command : string;
  reciever : string;
  message : string
begin
  msg := TStringList.Create;
  try
    msg.Text := input;
    command := msg[0];
    msg.Delete(0);
    reciever := msg[0];
    msg.Delete(0);
    message := msg.Text;
  finally
    msg.Free;
  end;

Vielleicht geht das auch schöner ohne die Zeilen zu löschen.

MfG
Fabian

[Sir Rufo]

Wenn du mal erklären könntest, warum du die Sockets in einer eigenen Liste speichern möchtest.

Denn mir erschließt sich das nicht.

Der ServerSocket hat alle benutzten Sockets in einer Liste vorrätig. Da ist eine eigene Liste irgendwie doppelt gemoppelt.

[Sir Rufo]

Zitat:

Zitat von xZise (Beitrag 1054370)

Übrigens habe ich deshalb auch vorgeschlagen mehrere Zeilen zu nehmen. Dann hättest du einfach machen können:

Delphi-Quellcode:

var
  msg : TStrings;

  command : string;
  reciever : string;
  message : string
begin
  msg := TStringList.Create;
  try
    msg.Text := input;
    command := msg[0];
    msg.Delete(0);
    reciever := msg[0];
    msg.Delete(0);
    message := msg.Text;
  finally
    msg.Free;
  end;

Vielleicht geht das auch schöner ohne die Zeilen zu löschen.

MfG
Fabian

Wieso macht ihr euch das Leben immer so schwer?
Das ist z.B. die Nachricht

Code:

CMD=MSG
SEN=Walter
REC=Peter
MSG=Alles frisch im Schritt

Diese wird wie folgt erstellt:

Delphi-Quellcode:

function BuildMessage( const Sen, Rec, Msg : string ) : string;
begin
  with TStringList.Create do
    try
      Values[ 'CMD' ] := 'MSG';
      Values[ 'SEN' ] := Sen;
      Values[ 'REC' ] := Rec;
      Values[ 'MSG' ] := Msg;
      Result := Text;
    finally
      Free;
    end;
end;

Auslesen des CMDs geht so

Delphi-Quellcode:

function ReadMessageCmd( const RecvTxt : string ) : string;
begin
  with TStringList.Create do
    try
      Text := RecvTxt;
      Result := Values[ 'CMD' ];
    finally
      Free;
    end;
end;

Und auslesen der Nachricht geht dann so

Delphi-Quellcode:

procedure ReadMessage( const RecvTxt : string; var Sen, Rec, Msg : string );
begin
  with TStringList.Create do
    try
      Text := RecvTxt;
      Sen := Values[ 'SEN' ];
      Rec := Values[ 'REC' ];
      Msg := Values[ 'MSG' ];
    finally
      Free;
    end;
end;

Und nochmal bemerkt, mit JSON geht das ganze super stressfrei - aber kompliziert ist wahrscheinlich schöner :mrgreen:

[hans ditter]

Hi Sir Rufo,
ich kann ja verstehen, dass du das alles kompliziert findest... aber wie ich schonmal sagte, ich bin noch ein totaler newbie auf dem Themengebiet.
Die Liste sollte den UserNick, die IP und einen POINTER auf das entsprechende Socket enthalten, damit man das richtige Socket über den UserNick oder die IP finden kann.
Zu dem Protokoll-Ding: Ich habe sowas noch nie gemacht. Wenn ich mal Diskussionsbeiträge gelesen hab, dann hörte sich das für mich immer so an, als ob man eine Datei schreibt, die dann so allgemeine Befehle enthält, sowas wie

Code:

/msg [RecUser] [sendUser] [message]

oder so ähnlich. Ich hab inzwischen verstanden, dass das nicht so ist, sondern das man spezielle Zeichen einsetzt, um zu erkenne, wo der Befehl anfängt und wo der Text (z.B. ja mit Zeilenumbrüchen).
Zu deiner Idee mit den JSON: Ich find es super von dir, dass du dein Wissen einbringst und mir damit helfen möchtest, aber ich steige da noch nicht ganz durch und konnte bei Google auch keine Tutrials oder Anleitungen finden (vielleicht fehlte mir auch nur das richtige Stichwort).
Wenn das wirklich soviel besser ist, dann würde ich mich über eine nähere Erläuterung oder ein Tut o.ä. freuen.
Um dir meine Verständnisprobleme näher zu bringen (vielleicht sind die ja auch etwas dämlicher Natur ;) :) ):
- was machst du mit

Delphi-Quellcode:

o:=SO;//Struktur vorbereiten

?
- wenn du erst die Struktur mit "SO" vorbereitet hast, wieso verwendest du dann für die Nachricht an sich nur noch

Delphi-Quellcode:

o.S[ 'CMD' ] := 'MSG';//etc.

??
- . . .
Vielleicht könntest du das ganze nochmal näher erläutern, denn ich würd das gerne einsetzten, nur möchte ich verstehen, was ich mache und nicht nur abschreiben, was andere mir vorsetzten.

So, hoffe meine Problemlage ist jetzt ganz deutlich geworden. Würde mich freuen wenn ihr mir (vgl.bar mit einem störrischen / dämlichen Kunden...:D :P) weiter helfen würdet. Hab hier in der DP schon einiges dazugelernt.

LG, hans ditter

[Sir Rufo]

Den Link wo man JSON für Delphi bekommt habe ich hier schon gepostet (s. in den oberen Threads)

Delphi-Quellcode:

o := SO;

erzeugt mir ein leeres JSON-Object, mit dem ich ab jetzt arbeiten kann.
Jetzt möchte ich diesem JSON-Object für die Eigenschaft 'CMD' den String-Wert 'MSG' übergeben.
Das schöne bei JSON-Objekte ist, die Eigenschaft wird automatisch angelegt, wenn diese noch nicht existiert.
also

Delphi-Quellcode:

o.S[ 'CMD' ] := 'MSG';

Wenn ich einen Integer-Wert übergeben möchte schreibe ich einfach

Delphi-Quellcode:

o.I[ 'Wert' ] := 10;

Auslesen geht genauso einfach

Delphi-Quellcode:

if o.S[ 'CMD' ] = 'MSG' then

Unter dem Link findest du auch ein Forum sowie eine kurze Anleitung.

Stell dir das JSON erstmal so vor: Da kann ich sehr einfach was reinschmeissen und wieder auslesen und das gesamte bekomme ich als Text

Delphi-Quellcode:

ShowMessage( o.AsJSON );

geliefert und kann das sonstwohin schieben (z.B. als Nachricht über den Socket).

Das JSON-Objekt ist dabei nur Hilfsmittel, weil du dich um das korrekte Verpacken und Trennen der einzelnen Teile nicht selber kümmern musst. Du brauchst es nur benutzen.

[hans ditter]

Hey, super das du doch geantwortet hast... ich hatte schon befürchtet, ich hab jetzt alle abgeschreckt... :D
Das hört sich doch super an... damit sind meine größten Probleme schonmal geklärt...;) DANKE!!
Aber ich habe da noch immer ein Problem bei der Serverabfrage (wobie diese eher auf dem Verständnis des Vorgangs beruht):

Delphi-Quellcode:

o.I[ 'COUNT' ] := 0;
        // Senden
        for idx := 0 to TServerWinSocket( Sender ).ActiveConnections - 1 do
          // an alle?
          if ( ( o.[ 'TO' ] = '' ) or
            // an diesen Benutzer?
            ( o.S[ 'TO' ] = <Deine Userabfrage> ) ) and
            // nicht an den Client der gerade sendet
            ( Socket <> TServerWinSocket( Sender ).Connections[ idx ] ) then
            begin
              TServerWinSocket( Sender ).Connections[ idx ].SendText( o.AsJSON );
              o.I[ 'COUNT' ] := o.I[ 'COUNT' ] + 1;
            end;
         // Und wieder zurück an den Client
         Socket.SendText( o.AsJSON );
      end;

Was passiert in diesem Abschnitt?
1.) Ich kann dem ganzen soweit folgen, dass ein Integerwert 'Count' angelegt wird und mit null gefüllt ist. Aber wofür brauchst du diesen Integerwert??
2.) Warum fragst du ab, ob an alle oder nur an eine Person und nicht an den sendenden Clienten geschickt werden soll? Denn nach dem then schickst du die Nachricht doch sowieso wieder an alle (mit der for-Schleife).
Der Rest ist mir im Moment noch ziemlich klar... mal schauen, vlt ergeben sich da ja auch noch Probleme.

Dann hätte ich zu dem JSON-Quellcode noch eine Frage. Ich hab leider nur Turbo Delphi... :( ist das richtig, dass dies nichtmal eine Komponente ist, die man installieren kann? Sondern die man nur im uses-Bereich einfügen muss? Ich bin davon mal ausgegangen, aber in welchen Ordner muss ich dann die superobject.pas Datei speichern? Ich dachte mir unter C:/Programme/Borland/BDS/source ... aber wo dann hin? Ich hab da die Ordner dUnit, Indy10, IntraWeb, ToolsAPI und Win32 anzubieten... :pale:

Ich freue mich schon auf deine nächste Antwort,
hans ditter

p.s.: Natürlich auch an alle anderen ein großes Dank, die sich hier beteiligt haben, um mir zu helfen. Vor allem natürlich xZise.

[Sir Rufo]

Ok, das mit dem COUNT ist eigentlich nur Spielerei ... damit wollte ich dem sendenden Client zurückmelden, an wieviele Clients die Nachricht geschickt wurde. Ist also erstmal überflüssig

Delphi-Quellcode:

{...}
        // Senden

        // Wir werden jetzt alle Verbindungen prüfen, ob wir denen was senden müssen
        // dazu finden wir in TServerWinSocket( Sender ).ActiveConnections die Anzahl der aktiven Verbindungen

        for idx := 0 to TServerWinSocket( Sender ).ActiveConnections - 1 do
          begin  // Das begin und end ist nicht notwendig, dient nur der Übersichtlichkeit

            // ist TO leer, dann wird wird die Nachricht an alle geschickt

            if ( ( o.[ 'TO' ] = '' ) or

              // oder steht da was drin, dann geht es nur an diesen Benutzer
              // die Userabfrage muss jetzt den Benutzer zu dem Socket aus
              // TServerWinSocket( Sender ).Connections[ idx ]
              // liefern also irgendwie sowas
              // function GetUserNameFromSocket( Socket : TCustomWinSocket ) : string

              ( o.S[ 'TO' ] = GetUserFromSocket( TServerWinSocket( Sender ).Connections[ idx ] ) ) ) and

              // aber es soll nicht an die Verbindung geschickt werden, die die Nachricht abgeschickt hat

              ( Socket <> TServerWinSocket( Sender ).Connections[ idx ] ) then
              begin

                TServerWinSocket( Sender ).Connections[ idx ].SendText( o.AsJSON );

              end;

          end;  { --- hier endet die for-Schleife --- }

        // Wir schicken dem Absender die Nachricht wieder zurück, damit der weiß, dass wir alles erledigt haben

        // Damit der Client weiß, dass es sich um eine Rückantwort handelt schreiben wir noch etwas in die Nachricht

        o.S[ 'SEND' ] := 'OK';

        // und auf die Reise schicken

        Socket.SendText( o.AsJSON );
     end;

Ja, es wird einfach nur die unit superobject eingebunden. Da braucht (gottseidank) nichts installiert werden.

Wenn du diese Unit nur in deinem Projekt nutzen möchtest, dann kann st du die datei "superobject.pas" einfach in dein Projekt-Ordner kopieren.
Willst du immer wieder auf diese Unit zurückgreifen, dann sollte die Datei in einem Ordner stehen, der laut Bibliothekspfad auch eingebunden wird. Schau einfach in deiner IDE unter "Tools->Optionen->Bibliothek - Win32->Bibliothekspfad->[...]
Mit einem Klick auf den Button mit den drei Punkten (nein, der ist nicht gelb :mrgreen: ) kannst du auch weitere Pfade hinzufügen.

Bei mir sind die unter "%PUBLIC%\Dokumente\superobject" gespeichert und dann habe ich den Pfad zur Bibliothek hinzugefügt.

[hans ditter]

Ok, cool!! Ich hab das aber mit dem User herausfinden noch nicht ganz gerafft.
Mein Delphi kennt beim Server die Funktion

Delphi-Quellcode:

GetUserFromSocket

nicht. Was mache ich falsch bzw. wie komme ich dann an die Verbindung ran?
Auch finde ich im Moment "TServerWinSocket" nicht ... ich habe die ganze Weiterleitung etc. in OnClientRead (ist das korrekt?), da gibt es aber nur

Delphi-Quellcode:

...ClientRead(Sender: TObjet; Socket: T[B]Custom[/B]WinSocket);

.
Und:

Delphi-Quellcode:

 ( Socket <> TServerWinSocket( Sender ).Connections[ idx ] ) then

--> ist Socket nicht gleich TServerWinSocket??

Ich bin noch etwas auf Kriegsfuß mit der internen Verbindungsliste des TServerSocket... hast du vlt schon bemerkt...:oops::roll: Vlt kannst du mir da nochmal etwas auf die Sprünge helfen... DANKE!!

LG, hans ditter

[xZise]

Zitat:

Zitat von hans ditter (Beitrag 1054629)

Ok, cool!! Ich hab das aber mit dem User herausfinden noch nicht ganz gerafft.
Mein Delphi kennt beim Server die Funktion

Delphi-Quellcode:

GetUserFromSocket

nicht.[...]

Die Funktion musst du dir auch noch schreiben. Damit findest du den Nickname zu einer Verbindung heraus. Das heißt irgendwo musst du speichern, wie der Nickname einer bestimmten Verbindung lautet.
Am besten ginge das wohl mit einer Dictionary. Zum Beispiel einer Hashlist.

MfG
Fabian

[hans ditter]

Zitat:

Zitat von xZise (Beitrag 1054632)

Die Funktion musst du dir auch noch schreiben. Damit findest du den Nickname zu einer Verbindung heraus. Das heißt irgendwo musst du speichern, wie der Nickname einer bestimmten Verbindung lautet.
Am besten ginge das wohl mit einer Dictionary. Zum Beispiel einer Hashlist.

Äääääääähm. . . ???? Was?? Ist das sowas, was ich schonmal machen wollte? Mit einer Liste, die IP, UserNick und Pointer auf das Socket speichert? Oder ist das noch wieder was anderes? Wenn ja, könntest du dann mal ein Beispielcode posten?
Danke!

lg, hans ditter