Comment puis-je arrêter exception socketexception: “Une opération de blocage a été interrompue par un appel à WSACancelBlockingCall” d'être jeté?

Pourriez-vous m'aider à me débarrasser de cette exception:

Système.Net.Les Sockets.Exception socketexception: "Une opération de blocage a été
interrompu par un appel à WSACancelBlockingCall"

Ce que le code ci-dessous: envoie un message UDP pour le serveur et récupère répondre
(NAK ou ACK)
Code qui lève une exception: m_receiveBytes = m_receiver.Receive(ref m_from);

Code:

public partial class _Default : System.Web.UI.Page
{ 
static readonly object lockScheduleIem = new object();
IPAddress m_AddressSend;
IPAddress m_AddressRecieve;
int m_groupPortSend;
int m_groupPortReceive;
IPEndPoint m_IPAddressSend;
IPEndPoint m_IPAddressReceive;
Byte[] m_receiveBytes;
Thread m_thread;
UdpClient m_receiver;
ManualResetEvent m_mre;
UdpClient m_sender;
IPEndPoint m_from;
protected void Page_Init(object sender, EventArgs e)
{
m_AddressSend = IPAddress.Parse("10.43.60.177");
m_AddressRecieve = IPAddress.Parse("10.43.60.99");
int.TryParse("60200", out m_groupPortSend);
int.TryParse("206", out m_groupPortReceive);
m_IPAddressSend = new IPEndPoint(m_AddressSend, m_groupPortSend);
m_IPAddressReceive = new IPEndPoint(m_AddressRecieve, m_groupPortReceive);
m_mre = new ManualResetEvent(false);
m_from = new IPEndPoint(IPAddress.Any, 0);
}
protected void Page_Load(object sender, EventArgs e)
{
}
protected void Button1_Click(object sender, EventArgs e)
{
try
{
TimeSpan timeout;
timeout = new TimeSpan(0, 0, 0, 0, 5000);
m_sender = new UdpClient();
m_receiveBytes = null;
m_receiver = new UdpClient(m_IPAddressReceive);
m_thread = new Thread(new ThreadStart(ThreadProc));
m_thread.Start();
string str = string.Empty;
using (StreamReader sr = new StreamReader(@"C:\UDPmsgArchive\UDPmsg_Of_2011_10_18_13_7_33_968_634545400539687500.xml"))
str = sr.ReadToEnd();
byte[] XMLbytes = Encoding.ASCII.GetBytes(str);
m_sender.Send(XMLbytes, XMLbytes.Length, m_IPAddressSend);
m_mre.WaitOne(timeout, true);
m_mre.Reset();
m_receiver.Close();
if (m_receiveBytes != null)
Response.Write(Encoding.ASCII.GetString(m_receiveBytes, 0, m_receiveBytes.Length));
else
Response.Write("string.Empty");
}
catch (Exception ex)
{
Response.Write(ex.ToString());
}
}
public void ThreadProc()
{
try
{
m_receiveBytes = m_receiver.Receive(ref m_from); //ERROR HERE
m_mre.Set();
m_receiver.Close();
}
finally
{
m_mre.Set();
}
}
}

OriginalL'auteur user852194 | 2011-10-24

4

Si je suis en train de lire votre code à droite, vous êtes à partir d'un thread pour recevoir un message UDP. Si il reçoit le message, il définit un événement. Le thread principal démarre le thread et attend jusqu'à cinq secondes pour que l'événement à définir. Si l'événement n'est pas défini dans ce délai, le thread principal détruit le récepteur que le thread est en attente.

Qui va certainement lancer une exception.

Si vous vous attendez à éliminer l'exception, de modifier votre ThreadProc
```
try
{
//do stuff here
}
catch (SocketException) //or whatever the exception is that you're getting
{
}
```
Je suggère que vous pas inclure la m_mre.Set() appel à un finally section. Le thread principal appels Reset sur l'événement, après l'attente est terminée, si oui ou non il y a un délai d'attente. Si le thread appelle Set dans le enfin, le cas de l'état si un délai d'attente se produit, car la suite se passe:
```
main thread calls Reset()
main thread calls Close() on the client
ThreadProc calls Set() in the finally
```
Au lieu de cela, changer votre thread principal code ressemble à ceci:
```
if (m_mre.WaitOne(timeout, true))
{
//event was set by the thread proc
//process the received data
//and reset the event
m_mre.Reset();
}
else
{
//A timeout occurred.
//Close the receiver
m_receiver.Close();
}
```
Cela dit, vous vraiment n'avez pas à démarrer un thread à ce faire. Plutôt, vous pouvez utiliser le asynchrones capacités de UdpClient. Quelque chose comme:
```
//Set timeout on the socket
m_receiver.Client.ReceiveTimeout = 5000;
try
{
IAsyncResult ir = m_receiver.BeginReceive(null, null);
m_receivedBytes = m_receiver.EndReceive(ir, m_receiver.Client.RemoteEndPoint);
//process received bytes here
}
catch (SocketException)
{
//Timeout or some other error happened.
}
```
Vraiment apprécié, je vais essayer votre suggestion, et je vais vous donner du feedback
Salut Jim, j'ai essayer votre logique ci-dessous, mais malheureusement toujours le même message d'erreur.
Qu'est-ce que l'exception exacte que vous recevez? Est le catch effectivement attraper l'exception?
oui le même : Un blocage de l'opération a été interrompue par un appel à WSACancelBlockingCall.
C'est le texte de l'exception. Quel est le type d'exception? Est-il SocketException? Quelque chose d'autre?

OriginalL'auteur Jim Mischel

Vous devez vous connecter pour publier un commentaire.