TCP Chat Fragen...

  • VB.NET
  • .NET 4.0

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von φConst.

    TCP Chat Fragen...

    Guten Morgen Zusammen :D

    Ich habe einen TCP Chat mit server Erstellt...

    nun Möchte ich das Der chat in der Richbox bleibt...

    ich nutze dafür:

    VB.NET-Quellcode

    1. Imports System.Net
    2. Imports System.Net.Sockets
    3. Imports System.Text
    4. Imports System.IO
    5. Public Class Auftragsliste
    6. Dim _client As TCPClient
    7. Public Property Lenght As Object
    8. Private Sub Auftragsliste_Load(sender As Object, e As EventArgs) Handles MyBase.Load, RichTextBox1.HScroll
    9. 'TCP LOAD EREIGNISS!
    10. Try
    11. Dim ip As String = "127.0.0.1"
    12. Dim port As Integer = 3432
    13. _client = New TcpClient(ip, port)
    14. CheckForIllegalCrossThreadCalls = False
    15. Threading.ThreadPool.QueueUserWorkItem(AddressOf ReceiveMassages)
    16. Me.AcceptButton = Button2
    17. Catch ex As Exception
    18. MsgBox(ex.Message)
    19. End Try
    20. TextBox1.Visible = True
    21. Button2.Visible = True
    22. My.Settings.Setting = RichTextBox1.Text
    23. 'Chat Speichern
    24. RichTextBox1.Text = My.Settings.Setting 'Änderung Speichern
    25. End Sub
    26. Private Sub ReceiveMassages(state As Object)
    27. Try
    28. While True
    29. Dim ns As NetworkStream = _client.GetStream()
    30. Dim toRecive(100000) As Byte
    31. ns.Read(toRecive, 0, toRecive.Length)
    32. Dim txt As String = Encoding.ASCII.GetString(toRecive)
    33. If RichTextBox1.TextLength > 0 Then
    34. RichTextBox1.Text &= vbNewLine & txt
    35. Else
    36. RichTextBox1.Text = txt
    37. End If
    38. End While
    39. Catch ex As Exception
    40. MsgBox(ex.Message)
    41. End Try
    42. End Sub
    43. Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
    44. Try
    45. Dim ns As NetworkStream = _client.GetStream()
    46. ns.Write(Encoding.ASCII.GetBytes(TextBox1.Text), 0, TextBox1.Text.Length)
    47. RichTextBox1.Text = My.Settings.Setting 'Änderung Speichern
    48. Catch ex As Exception
    49. MsgBox(ex.Message)
    50. End Try
    51. End Sub
    52. Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
    53. My.Settings.Setting = RichTextBox1.Text
    54. End Sub
    55. Private Sub RichTextBox1_TextChanged(sender As Object, e As EventArgs) Handles RichTextBox1.TextChanged
    56. RichTextBox1.Text = My.Settings.Setting 'Änderung Speichern
    57. End Sub


    Das ist der Client!

    Mein Problem:
    1. Er tut die gesendete nachricht nicht an die Richbox anzeigen lassen
    2. Wenn ich A An B Ein Text Sende Kommt es zwar an aber sobald ich eine neue sende Löscht er sie...
    Er soll sie nach dem beenden abspeichern Dafür nutze ich:

    VB.NET-Quellcode

    1. My.Settings.Setting

    Tut er aber nicht...
    3. Er soll Scrollen und nicht den text löschen...


    Danke im vorraus

    *Topic verschoben*
    ModStudio19 : 24%

    ModStudio :thumbup:


    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Marcus Gräfe“ ()

    Mochtest du wirklich, daß jedesmal, wenn RichTextBox1 horizontal gescrollt wird, _client neu instanziiert wird ? :huh:
    Speichern heißt auf englisch "save". ;)

    Und schmeiß endlich den "Microsoft.VisualBasic-Namespace" raus !

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Pasta“ ()

    Guten Abend,

    wie Fakiz bereits erwähnt hat,
    lösche

    C#-Quellcode

    1. CheckForIllegalCrossThreadCalls = false
    und benutze Invoke.

    Wieso verwendest du ein NetworkStream, und noch viel wichtiger, wieso instanziierst du diesen Stream jedes Mal?


    C#-Quellcode

    1. public partial class Auftragsliste : Form
    2. {
    3. public Auftragsliste()
    4. {
    5. InitializeComponent();
    6. }
    7. private TcpClient tcpClient;
    8. private StreamReader streamReader;
    9. private StreamWriter streamWriter;
    10. private void Auftragsliste_Load(object sender, EventArgs e)
    11. {
    12. tcpClient = new TcpClient("host", 3432);
    13. streamReader = new StreamReader(tcpClient.GetStream());
    14. streamWriter = new StreamWriter(tcpClient.GetStream());
    15. new Thread(new ThreadStart(() =>
    16. {
    17. while (tcpClient.Connected)
    18. {
    19. string _message = streamReader.ReadLine();
    20. this.InvokeI(() =>
    21. {
    22. listBox1.Items.Add(_message);
    23. string[] _data = new string[listBox1.Items.Count];
    24. listBox1.Items.CopyTo(_data, 0);
    25. File.AppendAllLines("log.txt", _data);
    26. });
    27. }
    28. })).Start();
    29. }
    30. private void button1_Click(object sender, EventArgs e)
    31. {
    32. streamWriter.WriteLine("text");
    33. streamWriter.Flush();
    34. }
    35. }
    36. public static class Extension
    37. {
    38. public static void InvokeI(this Form _frm, Action _delegate)
    39. {
    40. _frm.Invoke(_delegate);
    41. }
    42. }


    Benutze converter.telerik.com/ .
    DotNETWork (Generische Tcp-Klasse, verschlüsselt!)
    CelestialMechanicSimulator (Simulation Planetensystem)
    MonogameMinecraftClone (Minecraft-Klon)
    Erstmal danke für die antwort um die zeiot :D

    habe nun etwas umgeschrieben...
    SERVER:

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private server As TCPController
    3. Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    4. server = New TCPController
    5. TextBox1.Text = "==Server Gestartet==" & vbCrLf
    6. AddHandler server.MessageReceived, AddressOf OnlineReceived
    7. 'Ok... ALL HASBEEN DONE
    8. 'LETS TRY IT
    9. End Sub
    10. Private Delegate Sub UpdateTextDelegate(TB As TextBox, txt As String)
    11. 'ITS WILL UPDATE THE TEXTBOX
    12. Private Sub UpdateTextBox(TB As TextBox, txt As String)
    13. If TB.InvokeRequired Then
    14. 'using delegate for this
    15. TB.Invoke(New UpdateTextDelegate(AddressOf UpdateTextBox), New Object() {TB, txt})
    16. Else
    17. If txt IsNot Nothing Then TB.AppendText(txt & vbCrLf)
    18. End If
    19. End Sub
    20. Private Sub OnlineReceived(sender As TCPController, Data As String)
    21. UpdateTextBox(TextBox1, Data)
    22. End Sub
    23. Private Sub Form1_FormClosing(sender As Object, e As FormClosingEventArgs) Handles MyBase.FormClosing
    24. server.isListening = False
    25. 'its for close the server is listening
    26. End Sub
    27. ' I THING WI MUST CLOSE THE LISTENING IF WE CLOSED THE FORM / SERVER WITH EVENT FORM CLOSING
    28. End Class



    Client:

    VB.NET-Quellcode

    1. Imports System.Net
    2. Imports System.Net.Sockets
    3. Imports System.Text
    4. Imports System.IO
    5. Public Class Auftragsliste
    6. Private client As TcpCONFIG
    7. Private Sub Auftragsliste_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    8. client = New TcpCONFIG("127.0.0.1", 8080) 'ITS FOR YOU SERVER IP ADRESS AND PORT NUMMER
    9. If client.client.Connected Then Label1.Text = "Verbunden!!!"
    10. End Sub
    11. Private Sub SendMessage()
    12. If client.client.Connected = True Then client.send(TextBox1.Text)
    13. End Sub
    14. Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
    15. SendMessage()
    16. TextBox1.Clear()
    17. TextBox1.Focus()
    18. End Sub
    19. Private Sub Auftragsliste_FormClosing(sender As Object, e As FormClosingEventArgs) Handles MyBase.FormClosing
    20. If client.client.Connected = True Then
    21. client.clientData.Close()
    22. client.client.Close()
    23. End If
    24. End Sub
    25. End Class


    Funktioniert auch... ich muss nur noch machen das der chat gespeichert wird...
    Das ne Richbox das geschriebene anzeigt...
    Das er speichert Wenn man auf save drückt...
    und Das er es wieder anzeigt wenn man connected...

    Ps: ist es möglich das Client 1 schreibt und CLient 2 danach connected und das davor geschriebene sieht?!

    wenn ja wie?!
    ModStudio19 : 24%

    ModStudio :thumbup:


    Ps: ist es möglich das Client 1 schreibt und CLient 2 danach connected und das davor geschriebene sieht?!


    Ja,
    du erstellst eine Klasse Client, in der ein StreamWriter und ein StreamReader definiert sind, und je zwei Methoden die Senden und Empfangen.

    Der Server, der in einem anderen Thread als dem GUI-Thread lauscht, akzeptiert die eingehende Verbindung des Clients, fügt den Client in eine List<Client> und generiert einen neuen
    Thread der dem eingegangen Client lauscht:

    SOLANGE WAHR

    EINGEHENDR TCPCLIENT = SERVER.ACCEPTTCPCLIENT
    CLIENT = NEW CLIENT(TCPCLIENT)
    => NEW STREAMREADER; STREAMWRITER

    LIST<CLIENT>.ADD(CLIENT)

    GENERIERE NEUEN THREAD
    => SOLANGE TCPCLIENT VERBUNDEN
    EMPFANGE
    => WENN EMPFANGEN GEHE LISTE DURCH UND SENDE JEDEM DIE EINGEGANGENE NACHRICHT

    ENDE


    Zur Richtextbox: Was hindert dich daran eine ListBox zu verwenden?

    C#-Quellcode

    1. listBox1.Items.Add(_message);
    2. string[] _data = new string[listBox1.Items.Count];
    3. listBox1.Items.CopyTo(_data, 0);
    4. File.AppendAllLines("log.txt", _data);


    Statt Settings, benutze doch einfach eine log.txt.. wenn du es im %appdata% Ordner speichern willst , benutze Environment.GetFolderPath(SpecialFolder.CommonApplicationData)
    DotNETWork (Generische Tcp-Klasse, verschlüsselt!)
    CelestialMechanicSimulator (Simulation Planetensystem)
    MonogameMinecraftClone (Minecraft-Klon)
    Wissen über die ListBox hindert mich :D

    VB.NET-Quellcode

    1. _message.Items.Add(_message)
    2. Dim _data As String() = New String(_message.Items.Count - 1) {}
    3. _message.Items.CopyTo(_data, 0)
    4. File.AppendAllLines("log.txt", _data)

    Irgendwas is da falsch :/ ?!
    ModStudio19 : 24%

    ModStudio :thumbup:


    VB.NET-Quellcode

    1. ​ ListBox1.Items.Add("")
    2. Dim _data(ListBox1.Items .Count) As String
    3. ListBox1.Items.CopyTo(_data, 0)
    4. File.AppendAllLines("log.txt", _data)


    Du musst erst eine ListBox generieren (Toolbox) und System.IO importieren.
    DotNETWork (Generische Tcp-Klasse, verschlüsselt!)
    CelestialMechanicSimulator (Simulation Planetensystem)
    MonogameMinecraftClone (Minecraft-Klon)
    Was ist denn nun _message ein String oder eine ListBox?

    @φConst Warum so umständlich?

    VB.NET-Quellcode

    1. ListBox1.Items.Add("")
    2. Dim _data(ListBox1.Items .Count) As String
    3. ListBox1.Items.CopyTo(_data, 0)
    4. File.AppendAllLines("log.txt", _data)


    alternativ

    VB.NET-Quellcode

    1. File.AppendAllText("log.txt", ListBox1.Items(ListBox1.Items .Count-1).ToString())



    Ps: Laden des Chatverlaufes

    VB.NET-Quellcode

    1. ListBox1.Items.Clear()
    2. ListBox1.Items.AddRange(System.IO.File.ReadAllLines("log.txt"))


    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Fakiz“ ()

    Visual Basic-Quellcode

    1. ListBox1.Items(ListBox1.Items .Count-1).ToString()
    .. na klar *lachen* .. danke.
    Ich dachte der TE will den ganzen Chatverlauf speichern, wenn er auf ein Button klickt.

    @TE

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.IO;
    7. using System.Net;
    8. using System.Net.Sockets;
    9. using System.Threading;
    10. namespace VBParadiseEasyTCPChat
    11. {
    12. public class Server
    13. {
    14. public IPEndPoint IPePRemote { get; set; }
    15. public bool KeepAlive { get; set; }
    16. public string WelcomeMessage = "Hello client $User";
    17. private TcpListener tcpListener;
    18. private Thread listenerThread;
    19. private List<Client> clientList = new List<Client>();
    20. private List<string> chatLog = new List<string>();
    21. public Server(string _ip, int _port)
    22. {
    23. // Den Listener an ein Socket anbinden.
    24. IPePRemote = new IPEndPoint(IPAddress.Parse(_ip), _port);
    25. tcpListener = new TcpListener(IPePRemote);
    26. // Den Listener in einem neuen Thread starten
    27. listenerThread = new Thread(() =>
    28. {
    29. tcpListener.Start();
    30. while (KeepAlive)
    31. {
    32. // Thread so lange anhalten bis eine eingehende Verbindung besteht.
    33. var _tcpClient = tcpListener.AcceptTcpClient();
    34. // Neue Client-Klasse instanziieren und eingehenden TcpClient als Parameter dem Konstruktor übergeben.
    35. Client _c = new Client(_tcpClient);
    36. //Optional: Eine Willkommensnachricht die auf den Username des Clients wartet.
    37. _c.Send(WelcomeMessage.Replace("$User", _c.Receive().Split('=')[1]));
    38. // Den Chat-Log dem neuen Client senden und mit "old" markieren.
    39. for (int i = 0; i < chatLog.Count; i++)
    40. {
    41. _c.Send("[old]: " + chatLog[i]);
    42. }
    43. // Neuen Client in die Client-List hinzufügen.
    44. clientList.Add(_c);
    45. // Einen neuen parametrisierten Thread starten und den neuen Client übergebn.
    46. new Thread(new ParameterizedThreadStart((object _c0) =>
    47. {
    48. // Boxing -Unboxing.
    49. Client _client = (Client)_c0;
    50. // Solange Client verbunden ist
    51. while (_client.tcpClient.Connected)
    52. {
    53. // ...versuche Nachricht zu lesen und sie der Methode sendToAll übergeben.
    54. try
    55. {
    56. string _incoming = _client.Receive();
    57. sendToAll(_incoming);
    58. }
    59. catch
    60. {
    61. //...sonst informiere die anderen Benutzer über das Verlassen eines Clients ( Receive() wirft ein Error wenn der Stream geschlossen wird )
    62. clientList.Remove(_client);
    63. sendToAll("User has left!");
    64. }
    65. }
    66. })).Start(_c);
    67. }
    68. });
    69. }
    70. public void Start()
    71. {
    72. KeepAlive = true;
    73. listenerThread.Start();
    74. }
    75. private void sendToAll(string _message)
    76. {
    77. // Sendet die eingegangene Nachricht an alle Clients in der Client-List
    78. for (int i = 0; i < clientList.Count; i++)
    79. {
    80. clientList[i].Send(_message);
    81. }
    82. chatLog.Add(_message);
    83. }
    84. }
    85. // Klasse zur Verwaltung der Clients
    86. public class Client
    87. {
    88. private StreamWriter sWriter;
    89. private StreamReader sReader;
    90. public TcpClient tcpClient;
    91. public Client(TcpClient _c)
    92. {
    93. tcpClient = _c;
    94. sWriter = new StreamWriter(tcpClient.GetStream());
    95. sReader = new StreamReader(tcpClient.GetStream());
    96. }
    97. public void Send(string _message)
    98. {
    99. sWriter.WriteLine(_message);
    100. sWriter.Flush();
    101. }
    102. public string Receive()
    103. {
    104. return sReader.ReadLine();
    105. }
    106. }
    107. }


    Das wäre der Server .. und der Client,

    C#-Quellcode

    1. tcpClient = new TcpClient("192.168.0.215", 8000);
    2. streamReader = new StreamReader(tcpClient.GetStream());
    3. streamWriter = new StreamWriter(tcpClient.GetStream());
    4. new Thread(new ThreadStart(() =>
    5. {
    6. streamWriter.WriteLine("user=" + Environment.UserName);
    7. streamWriter.Flush();
    8. while (tcpClient.Connected)
    9. {
    10. string _message = streamReader.ReadLine();
    11. this.InvokeI(() =>
    12. {
    13. _chatlb.Items.Add(_message);
    14. });
    15. }
    16. })).Start();


    Das soll als Anregung fungieren.
    Dateien
    DotNETWork (Generische Tcp-Klasse, verschlüsselt!)
    CelestialMechanicSimulator (Simulation Planetensystem)
    MonogameMinecraftClone (Minecraft-Klon)

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „φConst“ ()