Alan adıma gelen bir istemciye bir ileti kutusu Gönder C# Windows Formu

Question

Benim etki alanındaki istemcilere dosya ve klasörleri kopyalamaktan bir windows form projesi var. Etki alanımdaki [x] istemcilere dosya kopyalama veya dizin işlemi kopyalama . Ona "x dizininde yeni bir klasör veya dosya var" yazan bir Mesaj Kutusu göndermek istiyorum. Messenger hizmeti nedeniyle Messenger hizmeti yapamıyorum XP Sp2'de çalışmıyor bu yüzden bunun için başka bir yola ihtiyacım var.Müşteri/sunucu tarafında bir uygulama yapılabilir.İstemde bir dinleyici uygulaması olacak. Bir messagebox.show kodu bize bir mesaj kutusu gösterecektir. vb ... Bunun için kolay bir yol ihtiyacım var.Yardım için lütfen bana yardım edin.Thanx.

Answer 1

İstemcideki FileSystemWatcher'u kullanabilirsiniz. Böylelikle uzak noktalarda veya portlarda dinleme ile uğraşmak zorunda kalmazsınız.

İki makine arasında iletişim kurmak istiyorsanız, remoting veya TcpListener aracılığıyla yapabilirsiniz.

Answer 2

Daha önce benzer bir şey yaptım. Bu kodun çoğunu başka bir yerden aldım ama nereden hatırlayamadım.

İlk Sunucu Kodu:

public class HSTcpServer 
{ 
    private TcpListener m_listener; 
    private IPAddress m_address = IPAddress.Any; 
    private int m_port; 
    private bool m_listening; 
    private object m_syncRoot = new object(); 
    public event EventHandler<TcpMessageReceivedEventArgs> MessageReceived; 

    public HSTcpServer(int port) 
    { 
     m_port = port; 
    } 

    public IPAddress Address 
    { 
     get { return m_address; } 
    } 

    public int Port 
    { 
     get { return m_port; } 
    } 

    public bool Listening 
    { 
     get { return m_listening; } 
    } 

    public void Listen() 
    { 
     try 
     { 
      lock (m_syncRoot) 
      { 
       m_listener = new TcpListener(m_address, m_port); 

       // fire up the server 
       m_listener.Start(); 

       // set listening bit 
       m_listening = true; 
      } 

      // Enter the listening loop. 
      do 
      { 
       Trace.Write("Looking for someone to talk to... "); 

       // Wait for connection 
       TcpClient newClient = m_listener.AcceptTcpClient(); 
       //Trace.WriteLine("Connected to new client"); 

       // queue a request to take care of the client 
       ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessClient), newClient); 
      } 
      while (m_listening); 
     } 
     catch (SocketException se) 
     { 
      Trace.WriteLine("SocketException: " + se.ToString()); 
     } 
     finally 
     { 
      // shut it down 
      StopListening(); 
     } 
    } 

    public void StopListening() 
    { 
     if (m_listening) 
     { 
      lock (m_syncRoot) 
      { 
       // set listening bit 
       m_listening = false; 
       // shut it down 
       m_listener.Stop(); 
      } 
     } 
    } 

    private void sendMessage(string message) 
    { 
     // Copy to a temporary variable to be thread-safe. 
     EventHandler<TcpMessageReceivedEventArgs> messageReceived = MessageReceived; 
     if (messageReceived != null) 
      messageReceived(this, new TcpMessageReceivedEventArgs(message)); 
    } 


    private void ProcessClient(object client) 
    { 
     TcpClient newClient = (TcpClient)client; 
     try 
     { 
      // Buffer for reading data 
      byte[] bytes = new byte[1024]; 
      StringBuilder clientData = new StringBuilder(); 

      // get the stream to talk to the client over 
      using (NetworkStream ns = newClient.GetStream()) 
      { 
       // set initial read timeout to 1 minute to allow for connection 
       ns.ReadTimeout = 60000; 
       // Loop to receive all the data sent by the client. 
       int bytesRead = 0; 
       do 
       { 
        // read the data 
        try 
        { 
         bytesRead = ns.Read(bytes, 0, bytes.Length); 
         if (bytesRead > 0) 
         { 
          // Translate data bytes to an ASCII string and append 
          clientData.Append(Encoding.ASCII.GetString(bytes, 0, bytesRead)); 
          // decrease read timeout to 1 second now that data is 
          // coming in 
          ns.ReadTimeout = 1000; 
         } 
        } 
        catch (IOException ioe) 
        { 
         // read timed out, all data has been retrieved 
         Trace.WriteLine("Read timed out: {0}", ioe.ToString()); 
         bytesRead = 0; 
        } 
       } 
       while (bytesRead > 0); 

       bytes = Encoding.ASCII.GetBytes("clowns"); 

       // Send back a response. 
       ns.Write(bytes, 0, bytes.Length); 
       sendMessage(clientData.ToString()); 
      } 
     } 
     finally 
     { 

      // stop talking to client 
      if (newClient != null) 
       newClient.Close(); 
     } 
    } 
} 

public class TcpMessageReceivedEventArgs : EventArgs 
{ 
    private string m_message; 

    public TcpMessageReceivedEventArgs(string message) 
    { 
     m_message = message; 
    } 

    public string Message 
    { 
     get 
     { 
      return m_message; 
     } 
    } 
} 

Müşteri Kodu:

class HSTcpClient 
{ 
    private TcpClient _client; 
    private IPAddress _address; 
    private int _port; 
    private IPEndPoint _endPoint; 
    private bool _disposed; 

    public HSTcpClient(IPAddress address, int port) 
    { 
     _address = address; 
     _port = port; 
     _endPoint = new IPEndPoint(_address, _port); 
    } 

    public void SendForwardedClientMessage(int senderId, int receiverId, int hsId) 
    { 
     SendMessage(senderId.ToString() + ":" + receiverId.ToString() + ":" + hsId.ToString()); 
    } 

    public void SendUpdatedCGBMessage() 
    { 
     SendMessage("Update your CGB you clowns"); 
    } 

    public void SendMessage(string msg) 
    { 
     try 
     { 
      _client = new TcpClient(); 
      _client.Connect(_endPoint); 

      // Get the bytes to send for the message 
      byte[] bytes = Encoding.ASCII.GetBytes(msg); 
      // Get the stream to talk to the server on 
      using (NetworkStream ns = _client.GetStream()) 
      { 
       // Send message 
       Trace.WriteLine("Sending message to server: " + msg); 
       ns.Write(bytes, 0, bytes.Length); 
       // Get the response 
       // Buffer to store the response bytes 
       bytes = new byte[1024]; 

       // Display the response 
       int bytesRead = ns.Read(bytes, 0, bytes.Length); 
       string serverResponse = Encoding.ASCII.GetString(bytes, 0, bytesRead); 
       Trace.WriteLine("Server said: " + serverResponse); 
      } 
     } 
     catch (SocketException se) 
     { 
      Trace.WriteLine("There was an error talking to the server: " + 
       se.ToString()); 
     } 
     finally 
     { 
      Dispose(); 
     } 
    } 

    #region IDisposable Members 

    public void Dispose() 
    { 
     Dispose(true); 
     System.GC.SuppressFinalize(this); 
    } 

    private void Dispose(bool disposing) 
    { 
     if (!_disposed) 
     { 
      if (disposing) 
      { 
       if (_client != null) 
        _client.Close(); 
      } 
      _disposed = true; 
     } 
    } 

    #endregion 

} 

Ardından formu kodunda bir sunucu değişkeni oluşturun kullanmak için:

private HSTcpServer m_server; 

ve oluşturduğum Bir arka plan çalışan ipliği:

Umarım

HSTcpClient client = new HSTcpClient(<ip address>, <port you picked>); 
      client.SendForwardedClientMessage(<message details>); 

I got:

Sonra

void m_server_MessageReceived(object sender, TcpMessageReceivedEventArgs e) 
    { 
     //<your code here> - e contains message details 
    } 

sunucuya mesaj göndermek için:

private void hsTcpServerThread_DoWork(object sender, DoWorkEventArgs e) 
    { 
     m_server = new HSTcpServer(<pick your port>); 
     m_server.MessageReceived += new EventHandler<TcpMessageReceivedEventArgs>(m_server_MessageReceived); 
     m_server.Listen(); 
    } 

Sonra mesajı alınan olay işlemek:

private System.ComponentModel.BackgroundWorker hsTcpServerThread; 

10 DoWork olay ele oradaki her şey.