如何在ListViewItem中操作多个Socket？ [英] How operate more than one Socket in ListViewItem?

问题描述

我在服务器和客户端分别有2个套接字（客户端连接到服务器），在服务器上我有一个类，其中包含每个客户端的一些信息，如IP，套接字和ID。



对于接受的每个连接，我添加了连接到此列表的最后一个客户端，这样我就有了一个客户端列表（即一个对象）。此外，每个客户端都添加到一个ListView中，其中ListViewItem的
标记 属性被分配给该客户端的对象。如果您想要向特定客户发送消息，这是以后可以提供帮助的方式之一。



就像你可以看到这个客户列表仅指向1个套接字听一个确定的端口号。现在我已经在每一侧（服务器和客户端）有2个套接字，如果我想从服务器的第二个套接字向客户端的第二个
套接字发送消息，我该如何制作？例如，可以为ListViewItem的Tag属性分配多个对象（只是一个想法）？
$


下面是我的代码（服务器，仅兼容1个Socket和1个对象（客户名单））：
$


表格：

 namespace mainForm 
 {
 
 public partial class frmMain：Form 
 {
 Listener server; 
线程启动; 
 
 public frmMain（）
 {
 InitializeComponent（）; 
 server = new Listener（）; 
} 
 
 private void startToolStripMenuItem_Click（object sender，EventArgs e）
 {
 start = new Thread（listen）; 
 start.Start（）; 
} 
 
 private void listen（）
 {
 server.BeginListen（101）; //选择要监听的端口
 server.Received + = new Listener.ReceivedEventHandler（server_Received）; 
 server.Disconnected + = new Listener.DisconnectedEventHandler（server_Disconnected）; 
} 
 
 private void server_Disconnected（Listener l，Info i）
 {
 Invoke（new _Remove（Remove），i）; 
} 
 
 private void server_Received（Listener l，Info i，收到字符串）
 {
 
 string [] cmd = received.Split（'| "）; 
 int inc; 
 
 for（inc = 0; inc< cmd.Length; inc ++）
 {
 
 switch（cmd [inc] .ToString（））
 {
 case" CMD1"：
 
 Invoke（new _Add（Add），i，cmd [2] +"  - " + cmd [3]）; 
 
休息; 
 
 case" CMD2"：
 
 //此处的其他代码
 
 break; 
 
} 
} 
} 
 
私人代表void _Add（Info i，string computer）; 
 private void Add（Info i，string computer）
 {
 string [] splitIP = i.RemoteAddress.Split（'：'）; 
 
 ListViewItem item = new ListViewItem（）; 
 item.Text = i.ID.ToString（）; 
 item.SubItems.Add（splitIP [0]）; 
 item.SubItems.Add（computer）; 
 item.Tag = i; 
 
 lvConnections.Items.Add（item）; 
 
} 
 
私人代表无效_Remove（Info i）; 
 private void删除（信息i）
 {
 foreach（lvConnections.Items中的ListViewItem项）
 {
 if（（Info）item.Tag == i） 
 {
 item.Remove（）; 
休息; 
} 
} 
} 
 
 private void disconnectToolStripMenuItem_Click（object sender，EventArgs e）
 {
 foreach（lvConnections.SelectedItems中的ListViewItem项目） ）
 {
 Info client =（Info）item.Tag; 
 client.Send（" DISCONNECT" + Environment.NewLine）; 
} 
} 

听众：

使用System; 
使用System.Collections.Generic; 
使用System.Text; 
使用System.Net; 
使用System.Net.Sockets; 
 
 class Listener 
 {
 Socket s; 
 public List< Info>客户; 
 
 public delegate void ReceivedEventHandler（Listener l，Info i，string received）; 
公共事件ReceivedEventHandler收到; 
 public delegate void DisconnectedEventHandler（Listener l，Info i）; 
公共事件DisconnectedEventHandler断开连接; 
 
 bool listening = false; 
 
 public Listener（）
 {
 clients = new List< Info>（）; 
 s = new Socket（AddressFamily.InterNetwork，SocketType.Stream，ProtocolType.Tcp）; 
} 
 
 public bool运行
 {
 get {return listening; } 
} 
 
 public void BeginListen（int port）
 {
 s.Bind（new IPEndPoint（IPAddress.Any，port））; 
 s.Listen（100）; 
 s.BeginAccept（new AsyncCallback（AcceptCallback），s）; 
 listening = true; 
} 
 
 public void StopListen（）
 {
 if（listening == true）
 {
 s.Close（）; 
 listening = false; 
} 
} 
 
 void AcceptCallback（IAsyncResult ar）
 {
 Socket handler =（Socket）ar.AsyncState; 
 Socket sock = handler.EndAccept（ar）; 
信息i =新信息（袜子）; 
 clients.Add（i）; 
 
 sock.BeginReceive（i.buffer，0，i.buffer.Length，SocketFlags.None，new AsyncCallback（ReadCallback），i）; 
 handler.BeginAccept（new AsyncCallback（AcceptCallback），handler）; 
} 
 
 void ReadCallback（IAsyncResult ar）
 {
 Info i =（Info）ar.AsyncState; 
 try 
 {
 int rec = i.sock.EndReceive（ar）; 
 if（rec！= 0）
 {
 string data = Encoding.UTF8.GetString（i.buffer，0，rec）; 
收到（这，我，数据）; 
} 
其他
 {
断开连接（this，i）; 
返回; 
} 
 
 i.sock.BeginReceive（i.buffer，0，i.buffer.Length，SocketFlags.None，new AsyncCallback（ReadCallback），i）; 
} 
 catch（Exception ex）
 {
 Disconnected（this，i）; 
 i.sock.Close（）; 
 clients.Remove（i）; 
} 
} 
} 
 

信息：

使用System; 
使用System.Collections.Generic; 
使用System.Text; 
使用System.Net; 
使用System.Net.Sockets; 
使用System.Threading; 
 
公共类信息
 {
 public Socket sock; 
公共Guid ID; 
公共字符串RemoteAddress; 
 public byte [] buffer = new byte [8192]; 
 
公开信息（插座袜子）
 {
 this.sock = sock; 
 ID = Guid.NewGuid（）; 
 RemoteAddress = sock.RemoteEndPoint.ToString（）; 
} 
 
 public void发送（字符串数据）
 {
 byte [] buffer = Encoding.UTF8.GetBytes（data）; 
 sock.BeginSend（buffer，0，buffer.Length，SocketFlags.None，new AsyncCallback（（ar）=> 
 {
 sock.EndSend（ar）; 
} ）， 缓冲）; 
} 
} 

解决方案

< blockquote>似乎这是一个没有问题的问题lution：D

I have 2 Sockets in server and client respectively (where client connect to server), on server i have one class that contains some informations of each client like IP, Socket and ID.

For each connection accepted i add the last client connected to this List, this way i have a list (that is a object) of clients. And also each client is added in one ListView where is assigned the object referent to this client, on Tag property of ListViewItem. This is one of way that can help later if you want send a message to a specific client.

Like you can see this List of clients is referent only to 1 Socket that listen in a determinated port number. Now already that i have 2 Sockets in each side (server and client), how i can make if i want send a message from second Socket of server to the second Socket on client? for example, is possible assign more than 1 object to Tag property of ListViewItem (only a idea)?

Below is my code (server, compatible only with 1 Socket and 1 object (List of client)):

Form:

namespace mainForm
{

public partial class frmMain : Form
{
Listener server;
Thread start;

public frmMain()
{
	InitializeComponent();
	server = new Listener();
}

private void startToolStripMenuItem_Click(object sender, EventArgs e)
{
	start = new Thread(listen);
	start.Start();
}

private void listen()
{
	server.BeginListen(101); // Select a port to listen
	server.Received += new Listener.ReceivedEventHandler(server_Received);
	server.Disconnected += new Listener.DisconnectedEventHandler(server_Disconnected);
}

private void server_Disconnected(Listener l, Info i)
{
	Invoke(new _Remove(Remove), i);
}

private void server_Received(Listener l, Info i, string received)
{

	string[] cmd = received.Split('|');
	int inc;

	for (inc = 0; inc < cmd.Length; inc++)
	{

		switch (cmd[inc].ToString())
		{
			case "CMD1":
				
				Invoke(new _Add(Add), i, cmd[2] + " - " + cmd[3]);

				break;

			case "CMD2":
				 
				 // Other code here

				break;
				
		}
	}
}

private delegate void _Add(Info i, string computer);
	private void Add(Info i, string computer)
	{
		string[] splitIP = i.RemoteAddress.Split(':');
		
		ListViewItem item = new ListViewItem();
		item.Text = i.ID.ToString();
		item.SubItems.Add(splitIP[0]);
		item.SubItems.Add(computer);
		item.Tag = i;
	   
		lvConnections.Items.Add(item);

	}

private delegate void _Remove(Info i);
	private void Remove(Info i)
	{
		foreach (ListViewItem item in lvConnections.Items)
		{
			if ((Info)item.Tag == i)
			{
				item.Remove();
				break;
			}
		}
	}

private void disconnectToolStripMenuItem_Click(object sender, EventArgs e)
{
	foreach (ListViewItem item in lvConnections.SelectedItems)
	{
		Info client = (Info)item.Tag;
		client.Send("DISCONNECT" + Environment.NewLine);
	}
}

Listener:

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;

class Listener
{
    Socket s;
    public List<Info> clients;

    public delegate void ReceivedEventHandler(Listener l, Info i, string received);
    public event ReceivedEventHandler Received;
    public delegate void DisconnectedEventHandler(Listener l, Info i);
    public event DisconnectedEventHandler Disconnected;

    bool listening = false;

    public Listener()
    {
        clients = new List<Info>();
        s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    }

    public bool Running
    {
        get { return listening; }
    }

    public void BeginListen(int port)
    {
        s.Bind(new IPEndPoint(IPAddress.Any, port));
        s.Listen(100);
        s.BeginAccept(new AsyncCallback(AcceptCallback), s);
        listening = true;
    }

    public void StopListen()
    {
        if (listening == true)
        {
            s.Close();
            listening = false;
        }
    }

    void AcceptCallback(IAsyncResult ar)
    {
        Socket handler = (Socket)ar.AsyncState;
        Socket sock = handler.EndAccept(ar);
        Info i = new Info(sock);
        clients.Add(i);

        sock.BeginReceive(i.buffer, 0, i.buffer.Length, SocketFlags.None, new AsyncCallback(ReadCallback), i);
        handler.BeginAccept(new AsyncCallback(AcceptCallback), handler);
    }

    void ReadCallback(IAsyncResult ar)
    {
        Info i = (Info)ar.AsyncState;
        try
        {
            int rec = i.sock.EndReceive(ar);
            if (rec != 0)
            {
                string data = Encoding.UTF8.GetString(i.buffer, 0, rec);
                Received(this, i, data);
            }
            else
            {
                Disconnected(this, i);
                return;
            }

            i.sock.BeginReceive(i.buffer, 0, i.buffer.Length, SocketFlags.None, new AsyncCallback(ReadCallback), i);
        }
        catch (Exception ex)
        {
            Disconnected(this, i);
            i.sock.Close();
            clients.Remove(i);
        }
    }
}

Info:

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;

public class Info
{
    public Socket sock;
    public Guid ID;
    public string RemoteAddress;
    public byte[] buffer = new byte[8192];
    
    public Info(Socket sock)
    {
        this.sock = sock; 
        ID = Guid.NewGuid(); 
        RemoteAddress = sock.RemoteEndPoint.ToString(); 
    }

    public void Send(string data)
    {
        byte[] buffer = Encoding.UTF8.GetBytes(data);
        sock.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback((ar) =>
        {
            sock.EndSend(ar);
        }), buffer);
    }
}

解决方案

Seems that is a question without solution :D

这篇关于如何在ListViewItem中操作多个Socket？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！