[C# .Net] Invio/ricezione file

[Oceans11]

Sto cominciando ad avventurarmi nella foltissima giungla di msdn, volevo provare trasmettere e ricevere un file in rete, tramite un applicazione ibrida (che mi fa sia da client che da server).

Il codice:public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
serverThread.RunWorkerAsync();
}

private void bBrowse_Click(object sender, EventArgs e)
{
openFileDialog1.ShowDialog();
tFile.Text = openFileDialog1.FileName;
}

private void bCancel_Click(object sender, EventArgs e)
{
clientThread.CancelAsync();
tIp.Text = "";
tFile.Text = "";
progressBar1.Value = 0;
}

private void bSend_Click(object sender, EventArgs e)
{
clientThread.RunWorkerAsync();
}

private void clientThread_DoWork(object sender, DoWorkEventArgs e)
{
sendFile();
if (clientThread.CancellationPending)
{
e.Cancel = true;
}
}

private void sendFile()
{
Socket senderSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
senderSocket.Bind(new IPEndPoint(IPAddress.Parse(tIp.Text), 9999));
FileStream fs = new FileStream(tFile.Text, FileMode.Open, FileAccess.Read);
long length = fs.Length;
BinaryReader br = new BinaryReader(fs);
byte[] buff = new byte[4096];
int size = 0;
int count = 0;
while (!clientThread.CancellationPending && (size = br.Read(buff, 0, buff.Length)) != 0)
{
senderSocket.Send(buff);
count += size;
int percentComplete =
(int)(((float)count * 100) / (float)length);
clientThread.ReportProgress(percentComplete);
}
br.Close();
senderSocket.Close();
}

private void clientThread_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
tIp.Text = "" + e.ProgressPercentage;
progressBar1.Value = e.ProgressPercentage;
}

private void clientThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
operationResult(sender, e);
}

private void serverThread_DoWork(object sender, DoWorkEventArgs e)
{
IPEndPoint ipEnd = new IPEndPoint(IPAddress.Any, 9999);
Socket receiver = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
receiver.Bind(ipEnd);
receiver.Listen(0);
receiveFile(receiver.Accept());
receiver.Close();
}

private static void receiveFile(Socket client)
{
String filename = "file";
BinaryWriter bw = new BinaryWriter(new FileStream(filename, FileMode.Create,
FileAccess.Write));
byte[] buff = new byte[1024];
int count = -1;
while ((count = client.Receive(buff)) > 0)
{
bw.Write(buff, 0, count);
}
bw.Close();

}

private void serverThread_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
operationResult(sender, e);
}

private void operationResult(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Cancelled)
{
MessageBox.Show("Operation was cancelled");
}
else if (e.Error != null)
{
string msg = String.Format("An error occurred: {0}", e.Error.Message);
MessageBox.Show(msg);
}
else
{
if (sender.Equals(clientThread))
{
MessageBox.Show("Uploading complete");
}
else
{
MessageBox.Show("Downloading complete");
}
}
}
}

L'errore: Di norma è consentito un solo utilizzo di ogni indirizzo di socket)

Quindi se ho capito il problema è che sto tentando di inviare a "me stesso" il file, quindi l'indirizzo del socket in entrata ed in uscita combaciano. Giusto?
Se sì, come posso testare l'applicazione in locale?

Sono ben accetti anche consigli su come ho scritto il programma, le classi che ho usato, etc; sto iniziando con il c# ora quindi ogni commento mi è utile!

[gugoXX]

Ho un vecchio esempio che avevo gia' fatto, e che usa le classi
TcpClient e TcpListener, che ti consiglio.

Una soluzione, con 2 progetti Console (cosi' non ci si incasina con i Thread).
Possono essere lanciati entrambi in debug, usando l'opzione MultiStart di Visual Studio


class Program
{
static void Main(string[] args)
{
TcpListener tclist = new TcpListener(12345);
tclist.Start();

TcpClient tcp = tclist.AcceptTcpClient();
NetworkStream ns = tcp.GetStream();

byte[] buf = new byte[10];
ns.Read(buf, 0, 10);
ns.Close();
}
}

class Program
{
static void Main(string[] args)
{
TcpClient tcp = new TcpClient();
tcp.Connect("localhost", 12345);
NetworkStream ns = tcp.GetStream();

byte[] buf= new byte[10];
for (int t = 0; t < 10; t++) buf[t] = (byte)t;

ns.Write(buf,0,10);
ns.Close();
}
}

[Oceans11]

Grazie per la risposta.

Mi sembra davvero semplice usare le classi che mi hai suggerito.
Domanda: queste classi encapsulano l'uso delle socket, giusto?
Hai dei riferimenti (anche a msdn) per capirci un pò di più? Giuro che lì dentro non so da che parte cominciare, forse è proprio questa la cosa che mi servirebbe maggiormente sapere. :rolleyes:

[gugoXX]

Grazie per la risposta.

Mi sembra davvero semplice usare le classi che mi hai suggerito.
Domanda: queste classi encapsulano l'uso delle socket, giusto?
Hai dei riferimenti (anche a msdn) per capirci un pò di più? Giuro che lì dentro non so da che parte cominciare, forse è proprio questa la cosa che mi servirebbe maggiormente sapere. :rolleyes:

Certo, internamente fanno uso dei socket.
Per sapere qualcosa di piu', indipendentemente dal C# o da Microsoft, potresti iniziare a studiare i livelli ISO-OSI e quello semplificato largamente usato oggi, Wikipedia inglese e' fatta abbastanza bene.
In realta' ciascuno di questi livelli e' stato studiato apposta per incapsulare e nascondere cio' che accade ai livelli piu' bassi.
Nel livello 0 si studia addiruttura la trasmissione elettrica (o ottica, o quello che vuoi), i rimbalzi di segnale... nessuno richiede tale livello a meno che tu non debba implementare i device, o debba studiare il canale a livello fisico e produrre cavi...
Allo stesso modo puoi pensare ai Socket come ad una scatola nera che non userai direttamente se farai uso delle TCPClient/TCPListener,
Oppure potrai fare a meno di studiare le TCPClient/TCPListener se farai uso delle WebClient/HttpListener.
Oppure potrai fare a meno di usare l'HttpListener se userai un WebServer di quelli commericiali.
Oppure potrai fare a meno di usare WebClient se dovrai mostrare un filmato audio/video mediante il componente .NET Managed che espone WindowsMediaPlayer, che potrebbe fare uso di WebClient (non penso proprio, ma e' solo un esempio, molto probabilmente si spinge giu' addirittura fino ai Socket).

Insomma, a seconda di cio' che hai bisogno puoi scegliere il livello giusto e usare quanto di quel livello gia' esiste, tralasciando lo studio dei livelli inferiori a quando servira'.
Ma almeno sapere cosa sono i livelli e a che problematiche rispondono penso sia utile. Quando servira' approfondire si potra' aprire il libro. Ma bisogna sapere almeno che quel libro esiste...
A questo ritengo dovrebbe mirare l'universita'. Io invece conosco putroppo a memoria i bit dei pacchetti IP, TCP e datagrammi UDP, non mi servono e non mi sono mai serviti a nulla e non riesco a dimenticarli.

[Oceans11]

Insomma, a seconda di cio' che hai bisogno puoi scegliere il livello giusto e usare quanto di quel livello gia' esiste, tralasciando lo studio dei livelli inferiori a quando servira'.
Ma almeno sapere cosa sono i livelli e a che problematiche rispondono penso sia utile. Quando servira' approfondire si potra' aprire il libro. Ma bisogna sapere almeno che quel libro esiste...
A questo ritengo dovrebbe mirare l'universita'. Io invece conosco putroppo a memoria i bit dei pacchetti IP, TCP e datagrammi UDP, non mi servono e non mi sono mai serviti a nulla e non riesco a dimenticarli.

Conosco a grandi linee come si comporta lo stack iso/osi e quello tcp/ip, come pure ho sentito spesso che non bisogna reinventarsi ogni volta la ruota. Ma da qualche parte dovrò cominciare no?
Personalmente preferisco un approccio bottom-up, anche se al giorno d'oggi può essere altamente sconsigliato. Probabilmente per costruirsi un'automobile uno dovrebbe comprare i pezzi e poi assemblarli, senza lontanamente neanche immaginare come si costruisca una ruota.

Siccome però l'università (ingegneria informatica) non mi ha dato/sta dando conoscenze "adeguate", per quanto mi riguarda, e visto che lo faccio per cultura personale, vorrei approfondire l'argomento. Credo che una chiara visione di ciò che si fà ad ogni livello non possa che farmi bene, no?

Esempio: conoscere a memoria ogni singolo byte dei pacchetti è esagerato forse, ma non averli visti mai è un'altra cosa.