.NET 3.x Clients-Server Socket - C#

Узнай цену своей работы

Формулировка задачи:

Доброго времени суток. Сижу пишу дипломную работу по роботе с Socket, но проблема в том то я не когда с ними не работал, у меня на данный момент реализовано полною работу со стороны клиента к серверу, то есть передача сообщений и приём их на сервере. Но сейчас у меня возникли кое-какие вопросы: 1) Мне надо реализовать передачу данных от сервера до клиента вот весь мой код:
Листинг программы 
  1. using System;
  2. using System.IO;
  3. using System.Net;
  4. using System.Net.Sockets;
  5.  
  6. namespace MachineEmulatorServer
  7. {
  8.     internal enum Commands
  9.     {
  10.         Command = 0,
  11.         DbDataRecord = 1
  12.     }
  13.  
  14.     struct ReceiveBuffer
  15.     {
  16.         private const int bufferSize = 1024;
  17.         public byte[] buffer;
  18.         public int toReceive;
  19.         public readonly MemoryStream bufStream;
  20.  
  21.         public ReceiveBuffer(int toRec)
  22.         {
  23.             buffer = new byte[bufferSize];
  24.             toReceive = toRec;
  25.             bufStream = new MemoryStream(toRec);
  26.         }
  27.  
  28.         public void Dispose()
  29.         {
  30.             buffer = null;
  31.             toReceive = 0;
  32.             Close();
  33.             if (bufStream != null)
  34.                 bufStream.Dispose();
  35.         }
  36.  
  37.         private void Close()
  38.         {
  39.             if (bufStream != null && bufStream.CanWrite)
  40.                 bufStream.Close();
  41.         }
  42.     }
  43.  
  44.     class Client
  45.     {
  46.         private byte[] lenBuffer;
  47.         private ReceiveBuffer buffer;
  48.         private Socket socket;
  49.  
  50.         public IPEndPoint EndPoint
  51.         {
  52.             get
  53.             {
  54.                 if (socket != null && socket.Connected)
  55.                     return (IPEndPoint)socket.RemoteEndPoint;
  56.                 return new IPEndPoint(IPAddress.None, 0);
  57.             }
  58.         }
  59.  
  60.         public delegate void DisconectedEventHandler(Client sender);
  61.  
  62.         public delegate void DataReceivedHandler(Client sender, ReceiveBuffer e);
  63.  
  64.         public delegate void DataSendHandler(Client sender, int send);
  65.  
  66.         public event DisconectedEventHandler Discotected;
  67.         public event DataReceivedHandler DataReceived;
  68.         public event DataSendHandler OnSend;
  69.  
  70.         public Client(Socket s)
  71.         {
  72.             socket = s;
  73.             lenBuffer = new byte[4];
  74.         }
  75.  
  76.         public void Send(byte[] data, int index, int length)
  77.         {
  78.             socket.BeginSend(BitConverter.GetBytes(length), 0, 4, SocketFlags.None, SendCallBack, null);
  79.             socket.BeginSend(data, index, length, SocketFlags.None, SendCallBack, null);
  80.         }
  81.  
  82.         private void SendCallBack(IAsyncResult ar)
  83.         {
  84.             try
  85.             {
  86.                 var send = socket.EndSend(ar);
  87.  
  88.                 if (OnSend != null)
  89.                 {
  90.                     OnSend(this, send);
  91.                 }
  92.             }
  93.             catch (Exception ex)
  94.             {
  95.                 Console.WriteLine("Send error\n {0}", ex.Message);
  96.             }
  97.         }
  98.  
  99.         public void Close()
  100.         {
  101.             if (socket != null)
  102.             {
  103.                 socket.Disconnect(false);
  104.                 socket.Close();
  105.             }
  106.  
  107.             buffer.Dispose();
  108.             socket = null;
  109.             lenBuffer = null;
  110.             Discotected = null;
  111.             DataReceived = null;
  112.         }
  113.  
  114.         public void ReceiveAsync()
  115.         {
  116.             socket.BeginReceive(lenBuffer, 0, lenBuffer.Length, SocketFlags.None, ReceiveCallBack, null);
  117.         }
  118.  
  119.         private void ReceiveCallBack(IAsyncResult ar)
  120.         {
  121.             try
  122.             {
  123.                 var rec = socket.EndReceive(ar);
  124.  
  125.                 if (rec == 0)
  126.                 {
  127.                     if (Discotected != null)
  128.                     {
  129.                         Discotected(this);
  130.                         return;
  131.                     }
  132.                     if (rec != 4)
  133.                     {
  134.                         throw new Exception();
  135.                     }
  136.                 }
  137.             }
  138.             catch (SocketException se)
  139.             {
  140.                 switch (se.SocketErrorCode)
  141.                 {
  142.                     case SocketError.ConnectionAborted:
  143.                     case SocketError.ConnectionReset:
  144.                         if (Discotected != null)
  145.                         {
  146.                             Discotected(this);
  147.                             return;
  148.                         }
  149.                         break;
  150.                 }
  151.             }
  152.             catch (ObjectDisposedException)
  153.             {
  154.                 return;
  155.             }
  156.             catch (NullReferenceException)
  157.             {
  158.                 return;
  159.             }
  160.             catch (Exception ex)
  161.             {
  162.                 Console.Write(ex.Message);
  163.                 return;
  164.             }
  165.  
  166.             buffer = new ReceiveBuffer(BitConverter.ToInt32(lenBuffer, 0));
  167.  
  168.             socket.BeginReceive(buffer.buffer, 0, buffer.buffer.Length, SocketFlags.None, ReceivePacketCallBack, null);
  169.         }
  170.  
  171.         void ReceivePacketCallBack(IAsyncResult ar)
  172.         {
  173.             var rec = socket.EndReceive(ar);
  174.  
  175.             if (rec <= 0)
  176.                 return;
  177.  
  178.             buffer.bufStream.Write(buffer.buffer, 0, rec);
  179.  
  180.             buffer.toReceive -= rec;
  181.  
  182.             if (buffer.toReceive > 0)
  183.             {
  184.                 Array.Clear(buffer.buffer, 0, buffer.buffer.Length);
  185.  
  186.                 socket.BeginReceive(buffer.buffer, 0, buffer.buffer.Length, SocketFlags.None, ReceivePacketCallBack,
  187.                                     null);
  188.                 return;
  189.             }
  190.  
  191.             if (DataReceived != null)
  192.             {
  193.                 buffer.bufStream.Position = 0;
  194.                 DataReceived(this, buffer);
  195.             }
  196.  
  197.             buffer.Dispose();
  198.  
  199.             ReceiveAsync();
  200.         }
  201.     }
  202. }
Листинг программы 
  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4.  
  5. namespace MachineEmulatorServer
  6. {
  7.     class Listener
  8.     {
  9.         public delegate void SocketAcceptedHandler(Socket e);
  10.  
  11.         public event SocketAcceptedHandler Accepted;
  12.  
  13.         private Socket listener;
  14.  
  15.         public bool Running { get; private set; }
  16.  
  17.         public void Start(int port)
  18.         {
  19.             if (Running)
  20.                 return;
  21.             listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  22.             listener.Bind(new IPEndPoint(0, port));
  23.             listener.Listen(0);
  24.  
  25.             listener.BeginAccept(AcceptedCallBack, null);
  26.             Running = true;
  27.         }
  28.  
  29.         public void Stop()
  30.         {
  31.             if (!Running)
  32.                 return;
  33.             listener.Close();
  34.             Running = false;
  35.         }
  36.  
  37.         private void AcceptedCallBack(IAsyncResult ar)
  38.         {
  39.             try
  40.             {
  41.                 var s = listener.EndAccept(ar);
  42.  
  43.                 if (Accepted != null)
  44.                 {
  45.                     Accepted(s);
  46.                 }
  47.             }
  48.             catch (Exception e)
  49.             {
  50.             }
  51.  
  52.             if (!Running)
  53.                 return;
  54.             try
  55.             {
  56.                 listener.BeginAccept(AcceptedCallBack, null);
  57.             }
  58.             catch (Exception)
  59.             {
  60.             }
  61.         }
  62.     }
  63. }
Листинг программы 
  1. using System.Collections.Generic;
  2. using System.IO;
  3. using System.Windows.Forms;
  4.  
  5. namespace MachineEmulatorServer
  6. {
  7.     public partial class Form1 : Form
  8.     {
  9.         private Listener listener;
  10.         private readonly List<Client> clients;
  11.  
  12.         public Form1()
  13.         {
  14.             InitializeComponent();
  15.             FormClosing += Form1_FormClosing;
  16.             clients = new List<Client>();
  17.         }
  18.  
  19.         private void Form1_FormClosing(object sender, FormClosingEventArgs e)
  20.         {
  21.             while (clients.Count != 0)
  22.             {
  23.                 clients[0].Close();
  24.                 clients.Remove(clients[0]);
  25.             }
  26.  
  27.             if (listener != null && listener.Running)
  28.                 listener.Stop();
  29.         }
  30.  
  31.         private void Form1_Load(object sender, System.EventArgs e)
  32.         {
  33.             listener = new Listener();
  34.             listener.Accepted += listener_Accepted;
  35.             listener.Start(5053);
  36.         }
  37.  
  38.         private void listener_Accepted(System.Net.Sockets.Socket e)
  39.         {
  40.             var newClient = new Client(e);
  41.             newClient.DataReceived += client_DataReceived;
  42.             newClient.Discotected += client_Discotected;
  43.             newClient.OnSend += newClient_OnSend;
  44.             newClient.ReceiveAsync();
  45.             SendText("You connected", newClient);
  46.             if (clients == null)
  47.                 return;
  48.             clients.Add(newClient);
  49.  
  50.             Invoke((MethodInvoker) delegate
  51.                 {
  52.                     TextLogger.Text += "Connected:" + newClient.EndPoint + "\n";
  53.                 });
  54.         }
  55.  
  56.         private static void SendText(string text, Client client)
  57.         {
  58.             var bw = new BinaryWriter(new MemoryStream());
  59.             bw.Write((int)Commands.Command);
  60.             bw.Write(text);
  61.             bw.Close();
  62.             var data = ((MemoryStream)bw.BaseStream).ToArray();
  63.             bw.BaseStream.Dispose();
  64.             client.Send(data, 0, data.Length);
  65.         }
  66.  
  67.         void newClient_OnSend(Client sender, int send)
  68.         {
  69.             TextLogger.Text += "Send to: " + sender.EndPoint + "\n";
  70.         }
  71.  
  72.         private void client_Discotected(Client sender)
  73.         {
  74.             for (var i = 0; i < clients.Count; i++)
  75.             {
  76.                 if (!Equals(clients[i].EndPoint, sender.EndPoint))
  77.                     continue;
  78.                 Invoke((MethodInvoker) delegate
  79.                     {
  80.                         TextLogger.Text += "Disconnected: " + clients[i].EndPoint + "\n";
  81.                     });
  82.                 clients[i].Close();
  83.                 clients.Remove(clients[i]);
  84.                 break;
  85.             }
  86.         }
  87.  
  88.         private void client_DataReceived(Client sender, ReceiveBuffer e)
  89.         {
  90.             var r = new BinaryReader(e.bufStream);
  91.  
  92.             var header = (Commands) r.ReadInt32();
  93.  
  94.             switch (header)
  95.             {
  96.                 case Commands.Command:
  97.                     {
  98.                         var s = r.ReadString();
  99.                         Invoke((MethodInvoker) (() => TextLogger.Text += s + "\n"));
  100.                     }
  101.                     break;
  102.                 case Commands.DbDataRecord:
  103.                     {
  104.                         var imageBytesLen = r.ReadInt32();
  105.  
  106.                         r.ReadBytes(imageBytesLen);
  107.                         r.ReadString();
  108.                         Invoke((MethodInvoker) delegate
  109.                             {
  110.                                 //pbImage.Image = Image.FromStream(new MemoryStream(iBytes));
  111.                             });
  112.                     }
  113.                     break;
  114.             }
  115.         }
  116.     }
  117. }
Листинг программы 
  1. using System;
  2. using System.IO;
  3. using System.Net.Sockets;
  4.  
  5. namespace MachineEmulatorUsers
  6. {
  7.     internal enum Commands
  8.     {
  9.         Command = 0,
  10.         DbDataRecord = 1
  11.     }
  12.  
  13.     struct ReceiveBuffer
  14.     {
  15.         private const int bufferSize = 1024;
  16.         public byte[] buffer;
  17.         public int toReceive;
  18.         public readonly MemoryStream bufStream;
  19.  
  20.         public ReceiveBuffer(int toRec)
  21.         {
  22.             buffer = new byte[bufferSize];
  23.             toReceive = toRec;
  24.             bufStream = new MemoryStream(toRec);
  25.         }
  26.  
  27.         public void Dispose()
  28.         {
  29.             buffer = null;
  30.             toReceive = 0;
  31.             Close();
  32.             if (bufStream != null)
  33.                 bufStream.Dispose();
  34.         }
  35.  
  36.         private void Close()
  37.         {
  38.             if (bufStream != null && bufStream.CanWrite)
  39.                 bufStream.Close();
  40.         }
  41.     }
  42.  
  43.     internal class Client
  44.     {
  45.         private byte[] lenBuffer;
  46.         private ReceiveBuffer buffer;
  47.         private Socket socket;
  48.  
  49.         public delegate void OnConnectEventHandler(Client sender, bool connected);
  50.  
  51.         public delegate void OnSendEventHandler(Client sender, int send);
  52.  
  53.         public delegate void DataReceivedHandler(Client sender, ReceiveBuffer e);
  54.  
  55.         public delegate void OnDisconnectEventHandler(Client sender);
  56.  
  57.         public event OnConnectEventHandler OnConnect;
  58.         public event OnSendEventHandler OnSend;
  59.         public event OnDisconnectEventHandler OnDisconnect;
  60.         public event DataReceivedHandler DataReceived;
  61.  
  62.         private bool Connected
  63.         {
  64.             get { return socket != null && socket.Connected; }
  65.         }
  66.  
  67.         public Client()
  68.         {
  69.             socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  70.         }
  71.  
  72.         public void Connect(string ipAddress, int port)
  73.         {
  74.             if (socket == null)
  75.                 socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  76.             socket.BeginConnect(ipAddress, port, ConnectCallBack, null);
  77.         }
  78.  
  79.         private void ConnectCallBack(IAsyncResult ar)
  80.         {
  81.             try
  82.             {
  83.                 socket.EndConnect(ar);
  84.                 if (OnConnect != null)
  85.                 {
  86.                     OnConnect(this, Connected);
  87.                 }
  88.             }
  89.             catch (Exception)
  90.             {
  91.             }
  92.         }
  93.  
  94.         public void Send(byte[] data, int index, int length)
  95.         {
  96.             if (!Connected)
  97.                 return;
  98.             socket.BeginSend(BitConverter.GetBytes(length), 0, 4, SocketFlags.None, SendCallBack, null);
  99.             socket.BeginSend(data, index, length, SocketFlags.None, SendCallBack, null);
  100.         }
  101.  
  102.         private void SendCallBack(IAsyncResult ar)
  103.         {
  104.             try
  105.             {
  106.                 var send = socket.EndSend(ar);
  107.  
  108.                 if (OnSend != null)
  109.                 {
  110.                     OnSend(this, send);
  111.                 }
  112.             }
  113.             catch (Exception ex)
  114.             {
  115.                 Console.WriteLine("Send error\n {0}", ex.Message);
  116.             }
  117.         }
  118.  
  119.         public void Disconnect()
  120.         {
  121.             try
  122.             {
  123.                 if (!socket.Connected) return;
  124.                 socket.Close();
  125.                 socket = null;
  126.                 if (OnDisconnect != null)
  127.                 {
  128.                     OnDisconnect(this);
  129.                 }
  130.             }
  131.             catch (Exception)
  132.             {
  133.             }
  134.         }
  135.  
  136.         public void ReceiveAsync()
  137.         {
  138.             socket.BeginReceive(lenBuffer, 0, lenBuffer.Length, SocketFlags.None, ReceiveCallBack, null);
  139.         }
  140.  
  141.         private void ReceiveCallBack(IAsyncResult ar)
  142.         {
  143.             try
  144.             {
  145.                 var rec = socket.EndReceive(ar);
  146.  
  147.                 if (rec == 0)
  148.                 {
  149.                     if (rec != 4)
  150.                     {
  151.                         throw new Exception();
  152.                     }
  153.                 }
  154.             }
  155.             catch (SocketException se)
  156.             {
  157.                 switch (se.SocketErrorCode)
  158.                 {
  159.                     case SocketError.ConnectionAborted:
  160.                     case SocketError.ConnectionReset:
  161.                         Disconnect();
  162.                         break;
  163.                 }
  164.             }
  165.             catch (ObjectDisposedException)
  166.             {
  167.                 return;
  168.             }
  169.             catch (NullReferenceException)
  170.             {
  171.                 return;
  172.             }
  173.             catch (Exception ex)
  174.             {
  175.                 Console.Write(ex.Message);
  176.                 return;
  177.             }
  178.  
  179.             buffer = new ReceiveBuffer(BitConverter.ToInt32(lenBuffer, 0));
  180.  
  181.             socket.BeginReceive(buffer.buffer, 0, buffer.buffer.Length, SocketFlags.None, ReceivePacketCallBack, null);
  182.         }
  183.  
  184.         void ReceivePacketCallBack(IAsyncResult ar)
  185.         {
  186.             var rec = socket.EndReceive(ar);
  187.  
  188.             if (rec <= 0)
  189.                 return;
  190.  
  191.             buffer.bufStream.Write(buffer.buffer, 0, rec);
  192.  
  193.             buffer.toReceive -= rec;
  194.  
  195.             if (buffer.toReceive > 0)
  196.             {
  197.                 Array.Clear(buffer.buffer, 0, buffer.buffer.Length);
  198.  
  199.                 socket.BeginReceive(buffer.buffer, 0, buffer.buffer.Length, SocketFlags.None, ReceivePacketCallBack,
  200.                                     null);
  201.                 return;
  202.             }
  203.  
  204.             if (DataReceived != null)
  205.             {
  206.                 buffer.bufStream.Position = 0;
  207.                 DataReceived(this, buffer);
  208.             }
  209.  
  210.             buffer.Dispose();
  211.  
  212.             ReceiveAsync();
  213.         }
  214.     }
  215. }
Листинг программы 
  1. using System;
  2. using System.ComponentModel;
  3. using System.Data.Common;
  4. using System.Drawing;
  5. using System.IO;
  6. using System.Threading;
  7. using System.Windows.Forms;
  8.  
  9. namespace MachineEmulatorUsers
  10. {
  11.     public partial class Form1 : Form
  12.     {
  13.         private readonly Client client;
  14.         private bool connect;
  15.         private DbDataRecord dataRecords;
  16.         private BackgroundWorker background;
  17.         private string errorMessage;
  18.  
  19.         public Form1()
  20.         {
  21.             InitializeComponent();
  22.             client = new Client();
  23.             client.OnConnect += client_onConnect;
  24.             client.OnDisconnect += client_onDisconnect;
  25.             client.OnSend += client_onSend;
  26.             FormClosing += Form1_FormClosing;
  27.         }
  28.  
  29.         private void Form1_Load(object sender, EventArgs e)
  30.         {
  31.             client.Connect("127.0.0.1", 5053);
  32.             Thread.Sleep(1500);
  33.             background = new BackgroundWorker
  34.             {
  35.                 WorkerReportsProgress = true,
  36.                 WorkerSupportsCancellation = true
  37.             };
  38.             background.DoWork += bw_DoWork;
  39.             background.ProgressChanged += bw_ProgressChanged;
  40.             background.RunWorkerCompleted += bw_RunWorkerCompleted;
  41.             if (connect)
  42.             {
  43.                 LoadGroupBox.Visible = true;
  44.                 client.DataReceived+=Server_DataReceived;
  45.                 client.ReceiveAsync();
  46.                 return;
  47.             }
  48.             ErrorLabel.Visible = true;
  49.             errorMessage = "Кліент не знайшов з'єднання з Сервером...\nКлієн буде завершено через ";
  50.             background.RunWorkerAsync();
  51.         }
  52.  
  53.         void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
  54.         {
  55.             Close();
  56.         }
  57.  
  58.         void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
  59.         {
  60.             ErrorLabel.Text = errorMessage + e.ProgressPercentage;
  61.         }
  62.  
  63.         private static void bw_DoWork(object sender, DoWorkEventArgs e)
  64.         {
  65.             var worker = sender as BackgroundWorker;
  66.  
  67.             for (var i = 10; i > 0; i--)
  68.             {
  69.                 if (worker != null && worker.CancellationPending)
  70.                 {
  71.                     e.Cancel = true;
  72.                     break;
  73.                 }
  74.                 Thread.Sleep(500);
  75.                 if (worker != null)
  76.                     worker.ReportProgress(i);
  77.             }
  78.         }
  79.  
  80.         void Form1_FormClosing(object sender, FormClosingEventArgs e)
  81.         {
  82.             if (client != null)
  83.                 client.Disconnect();
  84.         }
  85.  
  86.         void client_onSend(Client sender, int send)
  87.         {
  88.             Invoke((MethodInvoker) delegate
  89.                 {
  90.                     Text = string.Format("Data sent: {0}", send);
  91.                 });
  92.         }
  93.  
  94.         private void client_onConnect(Client sender, bool connected)
  95.         {
  96.             connect = connected;
  97.         }
  98.  
  99.         private void client_onDisconnect(Client sender)
  100.         {
  101.             connect = false;
  102.         }
  103.  
  104.         private void InsertText(object sender, EventArgs e)
  105.         {
  106.             var s = sender as PictureBox;
  107.             if (s != null)
  108.                 textBox1.Text += ((PictureBox) sender).Tag;
  109.         }
  110.  
  111.         private void StartButtonClick(object sender, EventArgs e)
  112.         {
  113.             LoadContent();
  114.             LoadGroupBox.Visible = false;
  115.             KeyBoard.Visible = true;
  116.             button1.Visible = true;
  117.             textBox1.Visible = true;
  118.         }
  119.  
  120.         private void button1_Click(object sender, EventArgs e)
  121.         {
  122.             SendText(textBox1.Text);
  123.         }
  124.  
  125.         void SendText(string text)
  126.         {
  127.             var bw = new BinaryWriter(new MemoryStream());
  128.             bw.Write((int)Commands.Command);
  129.             bw.Write(text);
  130.             bw.Close();
  131.             var data = ((MemoryStream) bw.BaseStream).ToArray();
  132.             bw.BaseStream.Dispose();
  133.             client.Send(data, 0, data.Length);
  134.         }
  135.  
  136.         private void Server_DataReceived(Client sender, ReceiveBuffer e)
  137.         {
  138.             var r = new BinaryReader(e.bufStream);
  139.  
  140.             var header = (Commands) r.ReadInt32();
  141.  
  142.             switch (header)
  143.             {
  144.                 case Commands.Command:
  145.                     {
  146.                         var s = r.ReadString();
  147.                         Invoke((MethodInvoker) (() => ExecuteCommand(s)));
  148.                     }
  149.                     break;
  150.                 case Commands.DbDataRecord:
  151.                     {
  152.                         var s = r.ReadString();
  153.                         Invoke((MethodInvoker)(() => MessageBox.Show(s)));
  154.                     }
  155.                     break;
  156.             }
  157.         }
  158.  
  159.         private void ExecuteCommand(String com)
  160.         {
  161.             if (com != "Disconnected")
  162.                 return;
  163.             errorMessage = "Клієнт був відключений сервером...\nКлієн буде завершено через ";
  164.             background.RunWorkerAsync();
  165.         }
  166.     }
  167. }
Вроде-бы все отлично работает, но когда я начинаю писать DataReceived на стороне клиента и Send на стороне сервера, то в клиенте вылетает ошибка со стороны клиента в Client.cs:
Листинг программы 
  1. public void ReceiveAsync()
  2.         {
  3.             socket.BeginReceive(lenBuffer, 0, lenBuffer.Length, SocketFlags.None, ReceiveCallBack, null);
  4.             //Exception: NullReferenceException - в экземпляре объекта не указана ссылка на объект.
  5.         }
2 ) Как по сете можно передать записи из базы данных, что-то типа DbDataRecord. Заранее спасибо.
Тема все еще актуальна.

Решение задачи: «.NET 3.x Clients-Server Socket»

textual
Листинг программы 
  1. private void BackgroundReconnectDoWork(object sender, DoWorkEventArgs e)
  2.         {
  3.             var worker = sender as BackgroundWorker;
  4.             var flag = false;
  5.             while (flag != true)
  6.             {
  7.                 Invoke((MethodInvoker) (delegate
  8.                     {
  9.                         client = new Client();
  10.                         client.Connect(adress, port);
  11.                         Thread.Sleep(375);
  12.                         flag = connect;
  13.                     }));
  14.                 for (var i = 9; i >= 0; i--)
  15.                 {
  16.                     if (worker != null && worker.CancellationPending)
  17.                     {
  18.                         e.Cancel = true;
  19.                         break;
  20.                     }
  21.                     Thread.Sleep(500);
  22.                     if (worker != null)
  23.                         worker.ReportProgress(i);
  24.                 }
  25.             }
  26.         }

ИИ поможет Вам:

  • решить любую задачу по программированию
  • объяснить код
  • расставить комментарии в коде
  • и т.д
Попробуйте бесплатно

Оцени полезность:

9   голосов , оценка 3.667 из 5

Нужна аналогичная работа?

Оформи быстрый заказ и узнай стоимость

Бесплатно
Оформите заказ и авторы начнут откликаться уже через 10 минут
Похожие ответы