We Keep Coding

Problem with sending and receiving in streams C# in textbox Windows Forms app

I managed to create a client server that communicate through forms.
I am able to display fist waiting and accepted messages.
My problem is when I'm writing to the stream and reading it on the other side the forms.
Here is where the sending and receiving happens on both programs:
Server-side code:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net.Sockets;
using System.IO;
using System.Threading;
using System.Net;
using System.Diagnostics;
namespace serverApp
{
public partial class Form1 : Form
{
private static int connections = 0;
public Form1() { }
private void Form1_Load(object sender, EventArgs e)
{
}
private void CreateServer()
{
Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint localEP = new IPEndPoint(IPAddress.Any, 9050);
server.Bind(localEP);
server.Listen(10);
serverTxtbox.AppendText("waiting for a client");
BackgroundWorker worker1 = new BackgroundWorker();
worker1.RunWorkerAsync(handlingFunction(server));
}
public object handlingFunction(Socket server)
{
while (true)
{
try
{
Socket client = server.Accept();
NetworkStream ns = new NetworkStream(client);
StreamReader reader = new StreamReader(ns);
StreamWriter writer = new StreamWriter(ns);
connections++;
serverTxtbox.AppendText("New client accepted: active connections
${connections}");
writer.WriteLine("Welcome to my server");
writer.Flush();
string input;
while (true)
{
input = reader.ReadLine();
if (input.Length == 0 || input.ToLower() == "exit")
break;
serverTxtbox.AppendText(input);
writer.WriteLine(input);
writer.Flush();
} //end of while
ns.Close();
//client.Close();
//connections--;
Console.WriteLine("Client disconnected: {0} active connections",
connections);
}
catch (Exception)
{
connections--;
Console.WriteLine("Client disconnected: {0} active connections", connections);
} //end of catch block
} // end of HandleConnection function
private void serverTxtbox_TextChanged(object sender, EventArgs e)
{
serverTxtbox.Clear();
}
private void button1_Click(object sender, EventArgs e)
{
//start button
try
{
CreateServer();
}
catch (Exception)
{
serverTxtbox.AppendText("Connection failed ..");
}
//client.Close();
//server.Shutdown();
}
}
}
Client-side code:
using System;
using System.ComponentModel;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Windows.Forms;
namespace app
{
public partial class Form1 : Form
{
Socket client;
NetworkStream stream;
StreamReader reader;
StreamWriter writer;
public Form1()
{
InitializeComponent();
}
private void sendBtn_Click(object sender, EventArgs e)
{
// writing to the server
handlfun();
}
private void Form1_Load(object sender, EventArgs e)
{
}
private object ConnectionToServer(Socket client, IPEndPoint remoteEP)
{
//client.Connect(remoteEP);
try
{
client.Connect(remoteEP);
clientTextbox.Text = "Enter Message for Server <Enter to Stop >: ";
}
catch (SocketException e)
{
clientTextbox.AppendText("Unable to connect to server. ");
// clientTextbox.AppendText("e");
}
return client;
// Client.Shutdown(SocketShutdown.Both);
// Client.Close();
}
private void connectbtn_Click(object sender, EventArgs e)
{
client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9050);
BackgroundWorker worker1 = new BackgroundWorker();
worker1.RunWorkerAsync(ConnectionToServer(client, remoteEP));
}
public void handlfun()
{
stream = new NetworkStream(client);
reader = new StreamReader(stream);
writer = new StreamWriter(stream);
String input = clientTextbox.Text;
writer.WriteLine(input);
//clientTextbox.Text = input;
// String input = reader.ReadLine();
writer.Flush();
String line = null;
while (true)
{
clientTextbox.Text = "Enter Message for Server <Enter to Stop >: ";
line = clientTextbox.Text;
writer.WriteLine(line);
writer.Flush();
if (line.Length != 0)
{
line = "Echo: " + reader.ReadLine();
clientTextbox.Text = line;
}
}
}
}
}

NetworkCommsDotNet , how can I reverse TCP client and server functions in this code?

EDIT
With all great functionality that NetworkCommsDotNet offers, it looks like this library is not actively supported anymore. I am changing direction to accept Eser's response as answer. I tested the provided code and it worked. Thanks for your help.
Below is my code of simple TCP client-server, based on NetworkCommsDotNet library. The client periodically sends changing positions of an "object" to the server, and the server displays them. This works fine, however, what I want to achieve is exactly the opposite: I want the client to only connect to the server, and once the server detects a connection, then it starts periodically sending some X and Y coordinates back to the client. I could not have this done with NetworkCommsDotNet, any help is appreciated.
Client:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using NetworkCommsDotNet;
using NetworkCommsDotNet.Connections.TCP;
namespace ObjectPositionClient
{
class Program
{
static void Main(string[] args)
{
try {
var conn = TCPConnection.GetConnection(new ConnectionInfo("127.0.0.1", 50747));
System.Timers.Timer tmer;
tmer = new System.Timers.Timer(3000);
tmer.Elapsed += (sender, e) => TimerElapsed(sender, e, conn);
tmer.Enabled = true;
Console.WriteLine("Press any key to exit client.");
Console.ReadKey(true);
NetworkComms.Shutdown();
}
catch (Exception e)
{
Console.WriteLine(e.InnerException + "\n" + e.Message);
}
}
static public void TimerElapsed(object sender, System.Timers.ElapsedEventArgs e, TCPConnection conn)
{
Random rnd = new Random();
int X = rnd.Next(1, 101);
int Y = rnd.Next(1, 51);
conn.SendObject("Message", "X=" + X + "; Y=" + Y);
}
}
}
Server:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using NetworkCommsDotNet;
using NetworkCommsDotNet.Connections;
namespace ObjectPositionServer
{
class Program
{
static void Main(string[] args)
{
try
{
var con = Connection.StartListening(ConnectionType.TCP, new System.Net.IPEndPoint(System.Net.IPAddress.Any, 50747));
NetworkComms.AppendGlobalIncomingPacketHandler<string>("Message", PrintIncomingMessage);
Console.WriteLine("Server ready. Press any key to shutdown.");
Console.ReadKey(true);
NetworkComms.Shutdown();
}
catch (Exception e)
{
Console.WriteLine(e.InnerException + "\n" + e.Message);
}
}
private static void PrintIncomingMessage(PacketHeader header, Connection
connection, string message)
{
Console.WriteLine(message + "\n");
}
}
}

Here is a TCP based, basic, client/server sample. Whenever a client connects to server, server sends 10 strings to client and then close the connection. I think this is similar to your case.
using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
public class TCPTest
{
public static void StartAll()
{
Task.Run(() => StartServer());
Task.Run(() => StartClient());
}
static void StartServer()
{
TcpListener listener = new TcpListener(IPAddress.Any, 12345);
listener.Start();
Console.WriteLine("Server Started");
while (true)
{
var client = listener.AcceptTcpClient();
Console.WriteLine("A new client is connected");
ThreadPool.QueueUserWorkItem(ServerTask,client);
}
}
static void ServerTask(object o)
{
using (var tcpClient = (TcpClient)o)
{
var stream = tcpClient.GetStream();
var writer = new StreamWriter(stream);
for (int i = 0; i < 10; i++)
{
writer.WriteLine($"packet #{i + 1}");
writer.Flush();
Thread.Sleep(1000);
}
Console.WriteLine("Server session ended..");
}
}
static void StartClient()
{
TcpClient client = new TcpClient();
client.Connect("localhost", 12345);
var stream = client.GetStream();
var reader = new StreamReader(stream);
string line = "";
while((line = reader.ReadLine()) != null)
{
Console.WriteLine("Client received: "+ line);
}
Console.WriteLine("Client detected end of the session");
}
}
Use TCPTest.StartAll(); to start the test.
You can even telnet to this server. telnet localhost 12345
EDIT
Since you have commented, you want to transfer objects between client and server, I modified to code to show how it can be done (using Json.Net). This time, server sends 10 User objects to client.
I will post it as a new code, in case someone wants to see the minor differences.
using Newtonsoft.Json;
using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
public class TCPTest
{
//Sample class to transfer between server and client
public class User
{
public string Name { get; set; }
public int Id { get; set; }
public DateTime BirthDate { set; get; }
}
public static void StartAll()
{
Task.Run(() => StartServer());
Task.Run(() => StartClient());
}
static void StartServer()
{
TcpListener listener = new TcpListener(IPAddress.Any, 12345);
listener.Start();
Console.WriteLine("Server Started");
while (true)
{
var client = listener.AcceptTcpClient();
Console.WriteLine("A new client is connected");
ThreadPool.QueueUserWorkItem(ServerTask, client);
}
}
static void ServerTask(object o)
{
using (var tcpClient = (TcpClient)o)
{
var stream = tcpClient.GetStream();
var writer = new StreamWriter(stream);
for (int i = 0; i < 10; i++)
{
var user = new User() { Name = $"Joe{i}", Id = i , BirthDate = DateTime.Now.AddDays(-10000)};
var json = JsonConvert.SerializeObject(user);
writer.WriteLine(json);
writer.Flush();
Thread.Sleep(1000);
}
Console.WriteLine("Server session ended..");
}
}
static void StartClient()
{
TcpClient client = new TcpClient();
client.Connect("localhost", 12345);
var stream = client.GetStream();
var reader = new StreamReader(stream);
string json = "";
while ((json = reader.ReadLine()) != null)
{
var user = JsonConvert.DeserializeObject<User>(json);
Console.WriteLine($"Client received: Name={user.Name} Id={user.Id} BirthDate={user.BirthDate}");
}
Console.WriteLine("Client detected end of the session");
}
}

Issues with getting a raspberry pi to communicate to PC with windows IOT

I have been having a horrible problem with trying to get this socket on the raspberry pi to correctly communicate to the PC socket. It is a TCP client-to-server setup. Both are running .net C# applications to do the communication. The main issue is not the connection, but when I send info from the raspberry pi to the computer, the computer only gets the info when I shutdown the raspberry... I believe it has to do with caching, but how would I fix this? Just a fair warning I am not well verse with sockets.
the Raspberry Pi Client Code:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using Windows.UI.ViewManagement;
using System.Net.Sockets;
using Windows.Web.Http;
using Windows.Devices.Gpio;
using Windows.Networking;
using Windows.Networking.Sockets;
using Windows.Storage.Streams;
using System.Threading;
using System.Runtime.InteropServices;
namespace raspberrypipad
{
class TCPclient_Client
{
private string _ip;
private int _port;
private Socket _socket;
private DataWriter _writer;
private DataReader _reader;
public delegate void Error(string message);
public event Error OnError;
public delegate void DataRecived(string data);
public event DataRecived OnDataRecived;
public string Ip
{
get { return _ip; }
set { _ip = value; }
}
public int Port
{
get { return _port; }
set { _port = value; }
}
private static ManualResetEvent _clientDone = new ManualResetEvent(false);
const int TIMEOUT_MILLISECONDS = 1000;
public async void Connect(string devicename, string pin_number, string get_portNumber, string current_ip)
{
try
{
if (Port == 0)
{
_port = 4444;
}
string result = string.Empty;
DnsEndPoint hostEntry = new DnsEndPoint(Ip, Port);
var hostName = new HostName(Ip);
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
SocketAsyncEventArgs socketEventArg = new SocketAsyncEventArgs();
socketEventArg.RemoteEndPoint = hostEntry;
// Inline event handler for the Completed event.
// Note: This event handler was implemented inline in order to make this method self-contained.
socketEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(delegate (object s, SocketAsyncEventArgs e)
{
// Retrieve the result of this request
result = e.SocketError.ToString();
// Signal that the request is complete, unblocking the UI thread
_clientDone.Set();
});
_clientDone.Reset();
// Make an asynchronous Connect request over the socket
_socket.ConnectAsync(socketEventArg);
_socket.AcceptAsync(socketEventArg);
// Block the UI thread for a maximum of TIMEOUT_MILLISECONDS milliseconds.
// If no response comes back within this time then proceed
_clientDone.WaitOne(TIMEOUT_MILLISECONDS);
_socket.NoDelay = true;
}
catch (Exception ex)
{
//ignore
}
}
public string Send(string data)
{
string response = "Operation Timeout";
// We are re-using the _socket object initialized in the Connect method
if (_socket != null)
{
// Create SocketAsyncEventArgs context object
SocketAsyncEventArgs socketEventArg = new SocketAsyncEventArgs();
// Set properties on context object
socketEventArg.RemoteEndPoint = _socket.RemoteEndPoint;
socketEventArg.UserToken = null;
// Inline event handler for the Completed event.
// Note: This event handler was implemented inline in order
// to make this method self-contained.
socketEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(delegate (object s, SocketAsyncEventArgs e)
{
response = e.SocketError.ToString();
e.Dispose();
// Unblock the UI thread
_clientDone.Set();
});
// Add the data to be sent into the buffer
byte[] payload = Encoding.UTF8.GetBytes(data);
socketEventArg.SetBuffer(payload, 0, payload.Length);
// Sets the state of the event to nonsignaled, causing threads to block
_clientDone.Reset();
// Make an asynchronous Send request over the socket
_socket.SendBufferSize = payload.Length;
_socket.SendToAsync(socketEventArg);
// _socket.Shutdown(SocketShutdown.Send);
// Block the UI thread for a maximum of TIMEOUT_MILLISECONDS milliseconds.
// If no response comes back within this time then proceed
_clientDone.WaitOne(TIMEOUT_MILLISECONDS);
}
else
{
response = "Socket is not initialized";
}
return response;
}
public void close()
{
_socket.Dispose();
}
}
}
The server code for the computer is a little confusing, I know it works because other programs could send data to it in other languages... here is the code:
public TcpServerCode(int port)
{
_server = new TcpListener(IPAddress.Any, port);
_server.Start();
_isRunning = true;
if (!Directory.Exists(Environment.CurrentDirectory + "\\serverCOM"))
Directory.CreateDirectory(Environment.CurrentDirectory + "\\serverCOM");
var th = new Thread(LoopClients);
th.Start();
}
public void LoopClients()
{
while (_isRunning)
try
{
// wait for client connection
var newClient = _server.AcceptTcpClient();
// client found.
// create a thread to handle communication
var t = new Thread(HandleClient);
var ch = new clientHolder();
ch.generateRandomName();
ch._tcp = newClient;
clientHolderList.Add(ch);
t.Start(ch);
}
catch (Exception i)
{
Log.handleException(i);
}
}
public void HandleClient(object obj)
{
// retrieve client from parameter passed to thread
var client = (clientHolder) obj;
// sets two streams
//StreamWriter sWriter = new StreamWriter(client._tcp.GetStream(), Encoding.ASCII);
var ns = client._tcp.GetStream();
client._tcp.GetStream().ReadTimeout = 100;
var sReader = new StreamReader(client._tcp.GetStream(), Encoding.ASCII);
// you could use the NetworkStream to read and write,
// but there is no forcing flush, even when requested
var bClientConnected = true;
string sData = null;
Task getter = null;
Task sender = null;
while (bClientConnected)
if (getter != null)
{
if (getter.IsCompleted)
getter = _get(sReader, client.clientName);
}
else
{
getter = _get(sReader, client.clientName);
}
}
private static async Task _get(StreamReader reader, string clientName)
{
string sData = null;
sData = await reader.ReadLineAsync();
reader.DiscardBufferedData();
Console.WriteLine(sData);
// shows content on the console.
if (sData != null)
try
{
if (File.Exists(Environment.CurrentDirectory + "\\serverCOM\\" + clientName + "_get.txt"))
File.Delete(Environment.CurrentDirectory + "\\serverCOM\\" + clientName + "_get.txt");
File.WriteAllText(Environment.CurrentDirectory + "\\serverCOM\\" + clientName + "_get.txt", sData);
}
catch (Exception i)
{
Log.handleException(i);
}
}
I am assuming it is something simple to change on one of the programs, thank you in advance!

How to make server client autodiscover over a lan

I have two project "Server" and "Client" that communicate over a LAN,
this my server code
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace ServerClientProject
{
public partial class FormServer : Form
{
private static Int32 port;
private static string filePath;
TcpListener server = new TcpListener(IPAddress.Any, port);
public FormServer()
{
InitializeComponent();
}
private void FormServer_Load(object sender, EventArgs e)
{
File.WriteAllText("path.misc","");
File.WriteAllText("nama.misc","");
filePath = readPath();
label1.Text = filePath;
label2.Text = readNama();
label3.Text = IPAddressCheck();
label4.Text = UNCPathing.GetUNCPath(readPath());
label5.Text = GetFQDN();
bw.WorkerSupportsCancellation = true;
bw.WorkerReportsProgress = true;
bw.DoWork += new DoWorkEventHandler(bw_DoWork);
bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
if (bw.IsBusy != true)
{
bw.RunWorkerAsync();
}
}
private static string IPAddressCheck()
{
IPHostEntry IPAddr;
IPAddr = Dns.GetHostEntry(GetFQDN());
IPAddress ipString = null;
foreach (IPAddress ip in IPAddr.AddressList)
{
if (IPAddress.TryParse(ip.ToString(), out ipString) && ip.AddressFamily == AddressFamily.InterNetwork)
{
break;
}
}
return ipString.ToString();
}
public static string GetFQDN()
{
string domainName = IPGlobalProperties.GetIPGlobalProperties().DomainName;
string hostName = Dns.GetHostName();
if (!hostName.EndsWith(domainName)) // if hostname does not already include domain name
{
hostName += "." + domainName; // add the domain name part
}
return hostName; // return the fully qualified name
}
private void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
lstProgress.Items.Add(e.UserState);
}
private void bw_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
if ((worker.CancellationPending == true))
{
e.Cancel = true;
}
else
{
try
{
// Set the TcpListener on port 1333.
port = 1337;
//IPAddress localAddr = IPAddress.Parse("127.0.0.1");
TcpListener server = new TcpListener(IPAddress.Any, port);
//label2.Text = IPAddressToString(ip);
// Start listening for client requests.
server.Start();
// Buffer for reading data
Byte[] bytes = new Byte[256];
String data = null;
// Enter the listening loop.
while (true)
{
bw.ReportProgress(0, "Waiting for a connection... ");
// Perform a blocking call to accept requests.
// You could also user server.AcceptSocket() here.
TcpClient client = server.AcceptTcpClient();
bw.ReportProgress(0, "Connected!");
data = null;
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
int i;
// Loop to receive all the data sent by the client.
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
// Translate data bytes to a ASCII string.
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
bw.ReportProgress(0, String.Format("Received: {0}", data));
if (data == "file")
{
// Process the data sent by the client.
data = String.Format("Request: {0}", data);
byte[] mssg = System.Text.Encoding.ASCII.GetBytes(label4.Text);
// Send back a response.
stream.Write(mssg, 0, mssg.Length);
bw.ReportProgress(0, String.Format("Sent: {0}", data));
bw.ReportProgress(0, String.Format("File path : {0}", label4.Text));
}
else if (data == "nama")
{
byte[] mssg = System.Text.Encoding.ASCII.GetBytes(readNama());
stream.Write(mssg, 0, mssg.Length);
}
else if (data == "ip")
{
byte[] mssg = System.Text.Encoding.ASCII.GetBytes(GetFQDN());
stream.Write(mssg, 0, mssg.Length);
}
}
// Shutdown and end connection
client.Close();
}
}
catch (SocketException se)
{
bw.ReportProgress(0, String.Format("SocketException: {0}", se));
}
}
}
private void FormServer_FormClosing(object sender, FormClosingEventArgs e)
{
}
private void button1_Click(object sender, EventArgs e)
{
openFileDialog1.ShowDialog();
savePath(openFileDialog1.FileName.ToString());
saveNama(openFileDialog1.SafeFileName.ToString());
//folderBrowserDialog1.ShowDialog();
//savePath(folderBrowserDialog1.SelectedPath.ToString());
label1.Text = readPath();
label2.Text = readNama();
label4.Text = UNCPathing.GetUNCPath(readPath());
}
private void savePath(string fPath)
{
string sPath = "Path.misc";
File.WriteAllText(sPath, fPath);
}
private string readPath()
{
string readText = File.ReadAllText("Path.misc");
return readText;
}
private void saveNama(string nama)
{
string sNama = "Nama.misc";
File.WriteAllText(sNama, nama);
}
private string readNama()
{
string readText = File.ReadAllText("Nama.misc");
return readText;
}
}
}
and this my client
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.OleDb;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Client
{
public partial class FormClient : Form
{
public FormClient()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
label1.Text = IPAddressCheck();
label2.Text = GetFQDN();
label3.Text = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
}
public void msg(string mesg)
{
lstProgress.Items.Add(">> " + mesg);
}
public static string GetFQDN()
{
string domainName = IPGlobalProperties.GetIPGlobalProperties().DomainName;
string hostName = Dns.GetHostName();
if (!hostName.EndsWith(domainName)) // if hostname does not already include domain name
{
hostName += "." + domainName; // add the domain name part
}
return hostName; // return the fully qualified name
}
private static string IPAddressCheck()
{
IPHostEntry IPAddr;
IPAddr = Dns.GetHostEntry(GetFQDN());
IPAddress ipString = null;
foreach (IPAddress ip in IPAddr.AddressList)
{
if (IPAddress.TryParse(ip.ToString(), out ipString) && ip.AddressFamily == AddressFamily.InterNetwork)
{
break;
}
}
return ipString.ToString();
}
private void button1_Click(object sender, EventArgs e)
{
string message = textBox1.Text;
try
{
// Create a TcpClient.
// Note, for this client to work you need to have a TcpServer
// connected to the same address as specified by the server, port
// combination.
Int32 port = 1337;
string IPAddr = textBox2.Text;
TcpClient client = new TcpClient(IPAddr, port); //Unsure of IP to use.
// Translate the passed message into ASCII and store it as a Byte array.
Byte[] data = System.Text.Encoding.ASCII.GetBytes(message);
// Get a client stream for reading and writing.
// Stream stream = client.GetStream();
NetworkStream stream = client.GetStream();
// Send the message to the connected TcpServer.
stream.Write(data, 0, data.Length);
//lstProgress.Items.Add(String.Format("Sent: {0}", message));
// Receive the TcpServer.response.
// Buffer to store the response bytes.
data = new Byte[256];
// String to store the response ASCII representation.
String responseData = String.Empty;
// Read the first batch of the TcpServer response bytes.
Int32 bytes = stream.Read(data, 0, data.Length);
responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
if (message == "file")
{
lstProgress.Items.Add(String.Format("{0}", responseData));
fPath.getPath = (String.Format("{0}", responseData));
label4.Text = UNCPathing.GetUNCPath(fPath.getPath);
}
else if(message == "nama")
{
lstProgress.Items.Add(String.Format("{0}", responseData));
fPath.getNama = (String.Format("{0}", responseData));
}
// Close everything.
stream.Close();
client.Close();
}
catch (ArgumentNullException an)
{
lstProgress.Items.Add(String.Format("ArgumentNullException: {0}", an));
}
catch (SocketException se)
{
lstProgress.Items.Add(String.Format("SocketException: {0}", se));
}
}
private void button2_Click(object sender, EventArgs e)
{
//using (NetworkShareAccesser.Access(GetFQDN(), IPAddressCheck(), "arif.hidayatullah28#gmail.com", "971364825135win8"))
//{
// File.Copy("\\\\"+label1.Text+"\\TestFolder\\"+fPath.getNama+"", #"D:\movie\"+ fPath.getNama+"", true);
//}
}
private void button3_Click(object sender, EventArgs e)
{
string connString = #"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=\\ARIF-PC\aaaaaaaaaa\MsAccess.accdb; Jet OLEDB:Database Password=dbase;";
string cmdText = "SELECT kode, deskripsi, stok, Harga FROM [Barang] ORDER BY kode DESC";
OleDbConnection conn = new OleDbConnection(connString);
OleDbCommand cmd = new OleDbCommand(cmdText, conn);
try
{
conn.Open();
cmd.CommandType = CommandType.Text;
OleDbDataAdapter da = new OleDbDataAdapter(cmd);
DataTable barang = new DataTable();
da.Fill(barang);
dataGridView1.DataSource = barang;
}
finally
{
conn.Close();
}
}
}
}
but as you can see, I have to know the server ip address, is there a way to make the server and client autodiscover??
I've try this, worked with one PC but with a LAN it failed.
This that I've tried
Sorry form my bad English

On the client send a UDP broadcast 192.168.1.255 (this assumes you are operating on a class C network 192.168.1/24). The server then listens for the broadcast from any clients and then sends back a directed UDP packet to the client. The client is listening for this and decodes the packet which contains the address of the server.
This link C# How to do Network discovery using UDP Broadcast and some Google Fu will produce many examples of how to implement this.

Socket Programming - A connection attempt failed Exception

Am new to socket programming and am creating a chat application.As like other applications whenever i press enter in a chat window it should send the chat to a particular user.Am maintaining a DB for all users along with their IPAddresses.So whenever i select a user for sending chat it should send to the corresponding IPAddress.As of now am trying to send chat to my own machine(so i hard coded the IPAddress of my machine).But am getting an exception when i try to send my code to my IPAddress.Can anyone please help me out.
My code for socket programming is this
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.IO;
using System.Net.Sockets;
namespace Ping
{
class SocketProgramming
{
//Socket m_socWorker;
public AsyncCallback pfnWorkerCallBack;
public Socket m_socListener;
public Socket m_socWorker;
public void sendChat(IPAddress toMessengerIP)
{
try
{
//create a new client socket ...
m_socWorker = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
String szIPSelected = toMessengerIP.ToString();
String szPort = "7777";
int alPort = System.Convert.ToInt16(szPort, 10);
System.Net.IPAddress remoteIPAddress = System.Net.IPAddress.Parse(szIPSelected);
System.Net.IPEndPoint remoteEndPoint = new System.Net.IPEndPoint(remoteIPAddress, alPort);
// receive();
m_socWorker.Connect(remoteEndPoint);
//Send data
Object objData =(object)"hi dhivi";
byte[] byData = System.Text.Encoding.ASCII.GetBytes(objData.ToString());
m_socWorker.Send(byData);
}
catch (System.Net.Sockets.SocketException se)
{
//MessageBox.Show(se.Message);
Console.Out.Write(se.Message);
}
}
public void receive()
{
try
{
//create the listening socket...
m_socListener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, 7777);
//bind to local IP Address...
m_socListener.Bind(ipLocal);
//start listening...
m_socListener.Listen(4);
// create the call back for any client connections...
m_socListener.BeginAccept(new AsyncCallback(OnClientConnect), null);
//cmdListen.Enabled = false;
}
catch (SocketException se)
{
Console.Out.Write(se.Message);
}
}
public void OnClientConnect(IAsyncResult asyn)
{
try
{
m_socWorker = m_socListener.EndAccept(asyn);
WaitForData(m_socWorker);
}
catch (ObjectDisposedException)
{
System.Diagnostics.Debugger.Log(0, "1", "\n OnClientConnection: Socket has been closed\n");
}
catch (SocketException se)
{
Console.Out.Write(se.Message);
}
}
public class CSocketPacket
{
public System.Net.Sockets.Socket thisSocket;
public byte[] dataBuffer = new byte[1];
}
public void WaitForData(System.Net.Sockets.Socket soc)
{
try
{
//if (pfnWorkerCallBack == null)
//{
// pfnWorkerCallBack = new AsyncCallback(OnDataReceived);
//}
CSocketPacket theSocPkt = new CSocketPacket();
theSocPkt.thisSocket = soc;
// now start to listen for any data...
soc.BeginReceive(theSocPkt.dataBuffer, 0, theSocPkt.dataBuffer.Length, SocketFlags.None, pfnWorkerCallBack, theSocPkt);
}
catch (SocketException se)
{
Console.Out.Write(se.Message);
}
}
}
}
And whenever the users clicks the enter button it should call the sendChat() method.
private void txt_Userinput_KeyDown_1(object sender, KeyEventArgs e)
{
Window parentWindow = Window.GetWindow(this);
TabItem tb = (TabItem)this.Parent;
string user = tb.Header.ToString();
if (e.Key == Key.Return)
{
richtxtbox_chatwindow.AppendText(Environment.NewLine + user + " : " + txt_Userinput.Text);
DBCoding dbObject = new DBCoding();
SocketProgramming socketObj = new SocketProgramming();
socketObj.sendChat(IPAddress.Parse("192.168.15.41"));
}
else { return; }
}
To get ipaddress of the user
public IPAddress getIP()
{
String direction = "";
WebRequest request = WebRequest.Create("http://checkip.dyndns.org/");
using (WebResponse response = request.GetResponse())
using (StreamReader stream = new StreamReader(response.GetResponseStream()))
{
direction = stream.ReadToEnd();
}
//Search for the ip in the html
int first = direction.IndexOf("Address: ") + 9;
int last = direction.LastIndexOf("</body>");
direction = direction.Substring(first, last - first);
IPAddress ip = IPAddress.Parse(direction);
return ip;
}

You never seem to be calling your receive method. If your application never starts listening, no one will ever be able to connect. If you've tried that, and is getting an exception, post that and we'll go from there.