2016-04-17 2 views
0

Ich versuche Socket-Programmierung für den Empfang einiger Informationen von Client-Seite (zum Beispiel: Datenträgerverwendung oder etwas ähnliches) zu verwenden.Senden von Daten an den Server und Speichern in SQL Server mit Sockets

Ich verwende async-Methode für mehrere Clients und versuchte, SQL Server zu schreiben, aber ich speicherte ganze Information nicht zu SQL Server. Kommunikationsstrom über Byte-Array zwischen Client und Server, aber wie kann ich dieses Byte-Array während der Kommunikation an SQL Server speichern?

+0

TCP-Sockets haben eine maximale Datagramgröße von etwa 1500 Byte. Größere Nachrichten werden in mehrere Datagramme aufgeteilt. Um also Daten in der Datenbank zu speichern, muss das Byte-Array vom Client Blöcke enthalten, damit Sie die Daten in kleinere Teile zerlegen können. Zum Beispiel, wenn Sie vom Kunden 100 Bankkonten erhielten, würde am Ende jedes Bankkontos ein Unterbrechungszeichen haben. Dann könnte der Server jedes Bankkonto einzeln auf dem SQL Server speichern. Oder Sie senden einfach nur ein Bankkonto, sodass der Kunde die 100 Bankkonten nicht in einzelne Konten aufteilen muss. – jdweng

+0

Okan, bitte Code Beispiel hinzufügen. Es ist momentan nicht klar, wie du das machst und was du eigentlich willst. – cassandrad

Antwort

0

Sorry für die späte Antwort Jungs,

Hier ist der Code. Es gibt 2 Projekte. Einer von ihnen ist Server und der andere ist Client. Es gibt 2 Klassen im Serverprojekt.

Klassen;

class Listener 
{ 
    private Socket _socket; 

    public bool Listening { get; private set; } 
    public int Port { get; private set; } 

    public Listener(int port) 
    { 
     Port = port; 
     _socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp); 
    } 

    public void Start() 
    { 
     if (Listening) 
     { 
      return; 
     } 

     _socket.Bind(new IPEndPoint(0,Port)); 
     _socket.Listen(0); 
     _socket.BeginAccept(callback, null); 
     Listening = true; 
    } 

    public void Stop() 
    { 
     if (!Listening) 
     { 
      return; 
     } 

     _socket.Close(); 
     _socket.Dispose(); 
     _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
    } 

    void callback(IAsyncResult ar) 
    { 
     try 
     { 
      Socket socket = this._socket.EndAccept(ar); 

      if (SocketAccepted!=null) 
      { 
       SocketAccepted(socket); 
      } 
      this._socket.BeginAccept(callback, null); 
     } 
     catch (Exception ex) 
     { 
      MessageBox.Show(ex.Message); 
     } 
    } 

    public delegate void SocketAcceptedHandler(Socket e); 

    public event SocketAcceptedHandler SocketAccepted; 
} 


class Client 
{ 
    public string ID { get; private set; } 
    public IPEndPoint EndPoint { get; private set; } 

    private Socket sck; 

    public Client(Socket accepted) 
    { 
     sck = accepted; 
     ID = Guid.NewGuid().ToString(); 
     EndPoint = (IPEndPoint)sck.RemoteEndPoint; 
     sck.BeginReceive(new byte[] {0}, 0, 0, 0, callback, null); 
    } 

    void callback(IAsyncResult ar) 
    { 
     try 
     { 
      sck.EndReceive(ar); 

      byte[] buf=new byte[8192]; 
      int rec = sck.Receive(buf, buf.Length, 0); 

      if (rec<buf.Length) 
      { 
       Array.Resize<byte>(ref buf, rec); 
      } 
      if (Received!=null) 
      { 
       Received(this, buf); 
      } 

      sck.BeginReceive(new byte[] { 0 }, 0, 0, 0, callback, null); 

     } 
     catch (Exception ex) 
     { 
      //MessageBox.Show(ex.Message); 
      sck.Close(); 

      if (Disconnected!=null) 
      { 
       Disconnected(this); 
      } 
     } 

    } 

    public void Close() 
    { 
     sck.Close(); 
     sck.Dispose(); 
    } 
    public delegate void ClientReceivedHandler(Client sender, byte[] data); 
    public delegate void ClientDiscconnectedHandler(Client sender); 

    public event ClientReceivedHandler Received; 
    public event ClientDiscconnectedHandler Disconnected; 
} 

Server Projekt Haupt Form:

Server Application

public partial class Main : Form 
{ 
    private static Listener _listener; 

    public Main() 
    { 
     InitializeComponent(); 
     _listener = new Listener(8); 
     _listener.SocketAccepted += new Listener.SocketAcceptedHandler(_listenerSocketAccepted); 
     _listener.Start(); 

    } 

    private void _listenerSocketAccepted(Socket e) 
    { 
     Client client = new Client(e); 
     client.Received += new Client.ClientReceivedHandler(client_Received); 
     client.Disconnected += new Client.ClientDiscconnectedHandler(client_Disconnected); 


     Invoke((MethodInvoker)delegate 
     { 
      ListViewItem i=new ListViewItem(); 
      i.Text = client.EndPoint.ToString(); 
      i.SubItems.Add(client.ID); 
      i.SubItems.Add("XXX"); 
      i.SubItems.Add("XXX"); 
      i.Tag = client; 
      listViewClients.Items.Add(i); 

      //textBox1.Text = "New Connection : " + e.RemoteEndPoint + " Time : " + DateTime.Now; 
     }); 
    } 

    private void client_Disconnected(Client sender) 
    { 
     Invoke((MethodInvoker)delegate 
     { 
      for (int i = 0; i < listViewClients.Items.Count; i++) 
      { 
       Client client=listViewClients.Items[i].Tag as Client; 

       if (client.ID==sender.ID) 
       { 
        listViewClients.Items.RemoveAt(i); 
        break; 
       } 
      } 
     }); 
    } 

    private void client_Received(Client sender, byte[] data) 
    { 
     Invoke((MethodInvoker)delegate 
     { 
      for (int i = 0; i < listViewClients.Items.Count; i++) 
      { 
       Client client = listViewClients.Items[i].Tag as Client; 

       if (client.ID == sender.ID) 
       { 
        listViewClients.Items[i].SubItems[2].Text = Encoding.Default.GetString(data); 
        listViewClients.Items[i].SubItems[3].Text = DateTime.Now.ToString(); 
        break; 
       } 
      } 
     }); 
    } 

    private void Main_Load(object sender, EventArgs e) 
    { 

    } 
} 

Client Side Haupt Form:

Client Application

public partial class Main : Form 
{ 
    Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
    public Main() 
    { 
     InitializeComponent(); 
    } 

    private void btnConnect_Click(object sender, EventArgs e) 
    { 
     sck.Connect("127.0.0.1", 8); 
     MessageBox.Show("Connected"); 
    } 

    private void btnSend_Click(object sender, EventArgs e) 
    { 
     int s = sck.Send(Encoding.Default.GetBytes(txtMsg.Text)); 

     if (s>0) 
     { 
      MessageBox.Show("Message Sent.."); 
     } 
    } 

    private void btnClose_Click(object sender, EventArgs e) 
    { 
     sck.Close(); 
     sck.Dispose(); 
     Close(); 
    } 

    private void Main_Load(object sender, EventArgs e) 
    { 
     //lis 
    } 
} 

Ich habe 2 Fragen.

1- Wie kann ich Daten in sql vom Client eingeben?

2- Der Listeneintrag flackert und verschwindet nicht, wenn ich meine Client-App mit btnClose schließe.

+0

Normalerweise öffnen Sie einen Pool von Verbindungen zur Datenbank. Wenn eine Nachricht eingeht, können Sie entweder den Byte-Stream in einzelne Datenfelder konvertieren, um Parameter an Ihren SQL-Server zu übergeben, oder Sie erstellen ein Objekt daraus. Mit C# können Sie entweder Entity-Framework verwenden, das Ihre Objekte verwendet, oder Sie können ADO.NET verwenden und Params an SQL übergeben. Für ADO.NET können Sie einen Verbindungspool für gleichzeitige Anforderungen erstellen, für das Entitätsframework ist das Pooling integriert. – Mike

Verwandte Themen