What's difference between this code:
using (Stream fs = new FileStream(sTempFile ))
{
	 fs.BeginWrite(buffer, 0, nRead, ae.End(), null);
	 yield return 1;
	 fs.EndWrite(ae.DequeueAsyncResult());
}

and this one (notice AsyncEnumerator.End's param):
using (Stream fs = new FileStream(sTempFile ))
{
	 fs.BeginWrite(buffer, 0, nRead, ae.End(fs.EndWrite), null);
	 yield return 1;
	 fs.EndWrite(ae.DequeueAsyncResult());
}

Is there any sence in passing fs.EndWrite to ae.End method? When should I do
this?

What will change if I add cancelation:

using (Stream fs = new FileStream(sTempFile ))
{
	 fs.BeginWrite(buffer, 0, nRead, ae.End(), null);
	 yield return 1;
	 if (ae.IsCanceled())
	 {
		 ae.DiscardGroup(0);
		 yield break;
	 }
	 fs.EndWrite(ae.DequeueAsyncResult());
}
Is it correct? Or I should pass fs.EndWrite to ae.End() ?

Thnx in advance.

Sorry for this. I tried to delete the post. And it seemed to be deleted but not.

Thank you for detailed answer!
In other words it's better always specify a EndXXX-callback for AE.End() and
call ThrowOnMissingDiscardGroup(true)?
Because if there will be cancelation it's the only way to go if not is't safer
code for future changes, right?


--- In PowerThreading@yahoogroups.com, "Jeffrey Richter (Wintellect LLC)"
<JeffreyR@...> wrote:
>
> My AsyncEnumerator class has 2 overloaded End methods:
>       public AsyncCallback End();
>      public AsyncCallback End(int group, AsyncEnumerator.EndObjectXxx
callback);
>
> The most commonly used of these is the first, End().
> The End method that takes an int group is used when you want to take advantage
of AE's discard feature; described in this magazine column:
http://msdn.microsoft.com/en-us/magazine/cc721613.aspx#id0390064.
> If you do not have the AE discard the in-coming IAsyncResult automatically,
then the group and the EndObjectXxx delegate are not used.
> If you have the AE automatically discard the in-coming IAsyncResult, then you
can have it discard all incoming IAsyncResults that are part of a specific group
by calling:
> void DiscardGroup(int group);
> If the AE does discard an IAsyncReuslt for you, it does so by calling an
EndXxx method which you passed as the EndObjectXxx delegate to AE's End method.
>
> My AsyncEnumerator class also has this method:
>       public AsyncCallback EndVoid(int group, AsyncEnumerator.EndVoidXxx
callback);
>
> This method works just like the End method that takes an EndObjectXxx but it
allows you to pass an EndXxx method that returns 'void'.
>
> Your 2nd sample below won't actually compile because there is no End method
that takes just a delegate without also taking a discard group.
> However, if you passed a discard group Int32, then the 2 samples would behave
identically.
>
> In your 3rd sample, you will get an exception thrown if the AE is canceled
because the operation will complete, its IAsyncResult will come in, the AE will
try to discard the IAsyncResult but it can't because you didn't specify a
discard group and an EndObjectXxx delegate when calling AE's End method.
>
> Also, it is not necessary to call DiscardGroup if you exit the iterator
entirely. Because, when you exit the iterator entirely (yield break), then I
automatically discard all groups for you - this can simplify your code some.
> One more thing...If you intend to use cancelation, then you can call this
method at the top of your iterator:
> void ThrowOnMissingDiscardGroup(true);
>
> This method tells the AE object that you intend to use cancelation, can if you
ever call the End method that doesn't take a discard group and a callback, an
exception will immediately be thrown as opposed to an exception occurring only
if cancelation actually does occur.
> -- Jeffrey Richter (http://Wintellect.com<http://wintellect.com/>)
>
> From: PowerThreading@yahoogroups.com [mailto:PowerThreading@yahoogroups.com]
On Behalf Of evilshrike
> Sent: Thursday, August 06, 2009 8:41 AM
> To: PowerThreading@yahoogroups.com
> Subject: [PowerThreading] When to use AsyncEnumerator.End's parameters
>
>
>
> What's difference between this code:
> using (Stream fs = new FileStream(sTempFile ))
> {
> fs.BeginWrite(buffer, 0, nRead, ae.End(), null);
> yield return 1;
> fs.EndWrite(ae.DequeueAsyncResult());
> }
>
> and this one (notice AsyncEnumerator.End's param):
> using (Stream fs = new FileStream(sTempFile ))
> {
> fs.BeginWrite(buffer, 0, nRead, ae.End(fs.EndWrite), null);
> yield return 1;
> fs.EndWrite(ae.DequeueAsyncResult());
> }
>
> Is there any sence in passing fs.EndWrite to ae.End method? When should I do
this?
>
> What will change if I add cancelation:
>
> using (Stream fs = new FileStream(sTempFile ))
> {
> fs.BeginWrite(buffer, 0, nRead, ae.End(), null);
> yield return 1;
> if (ae.IsCanceled())
> {
> ae.DiscardGroup(0);
> yield break;
> }
> fs.EndWrite(ae.DequeueAsyncResult());
> }
> Is it correct? Or I should pass fs.EndWrite to ae.End() ?
>
> Thnx in advance.
>

class Program

static void Main(string[] args)

string[] files = Properties.Settings.Default.FilePath.Split(';');

string server = "xxx.xxx.xxx.xxx";

int port = 52000;

foreach (string file in files)

Console.WriteLine("Sending " + file + " to Server...");

PowerThreadingClient.Start(server, port, file);

while (PowerThreadingClient.IsBusy(server, port))

Thread.Sleep(10000);

public static class PowerThreadingClient

private static Hashtable _processingTable = new Hashtable();

#region Start

public static void Start(String hostNameOrAddress, Int32 port, String filePath)

AsyncEnumerator ae = new AsyncEnumerator();

ae.BeginExecute(ProcessWithPacketHashing(ae, hostNameOrAddress, port, filePath), ae.EndExecute, null);

#region ProcessWithPacketHashing

private static IEnumerator<Int32> ProcessWithPacketHashing(AsyncEnumerator ae, String hostNameOrAddress, Int32 port, String filePath)

if (!File.Exists(filePath))

throw new FileNotFoundException(string.Format("{0} could not be found.", filePath));

IPAddress[] ipAddresses;

EndPoint endPoint;

Socket client = null;

if (!_processingTable.ContainsKey(string.Format("{0}:{1}", hostNameOrAddress, port)))

_processingTable.Add(string.Format("{0}:{1}", hostNameOrAddress, port), true);

ipAddresses = Dns.GetHostAddresses(hostNameOrAddress);

endPoint = new IPEndPoint(ipAddresses[0], port);

using (client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP))

string fileDir = Path.GetDirectoryName(filePath);

string hash = HashFile(filePath);

byte[] fileInfo = GetFileInfoBytes(filePath, hash);

byte[] filePositionBytes = new byte[8];

client.BeginConnect(endPoint, ae.End(), null);

yield return 1;

client.BeginSend(fileInfo, 0, fileInfo.Length, SocketFlags.None, ae.End(), null);

yield return 1;

int bytesSent = client.EndSend(ae.DequeueAsyncResult());

client.BeginReceive(filePositionBytes, 0, filePositionBytes.Length, SocketFlags.None, ae.End(), null);

yield return 1;

int bytesReceived = client.EndReceive(ae.DequeueAsyncResult());

Int64 filePosition = 0;

if (bytesReceived == 8)

filePosition = BitConverter.ToInt64(filePositionBytes, 0);

Console.WriteLine("Got the file start position: " + filePosition);

Int64 bytesToSend = 0;

using (FileStream fs = File.OpenRead(filePath))

Byte[] fileBytes;

// Set the fileBytes, the bytes we will read from the file, equal to the max buffer size less the size of the packet hash size and 4 bytes for an int that tells the server how much data to expect

fileBytes = new Byte[Properties.Settings.Default.MaxBufferSize - Properties.Settings.Default.SHA256Length - 4];

if (fs.CanSeek)

fs.Seek(filePosition, SeekOrigin.Begin);

while (bytesToSend != 0)

if (bytesToSend < fileBytes.Length)

Array.Resize(ref fileBytes, (int)bytesToSend);

for (int bytesReadSoFar = 0; bytesReadSoFar < fileBytes.Length; )

int bytesReadThisTime = fs.Read(fileBytes, bytesReadSoFar, fileBytes.Length - bytesReadSoFar);

string packetHash = SHA256Utils.GenerateSHA256Hash(fileBytes);

Byte[] packetHashBytes = Convert.FromBase64String(packetHash);

Byte[] hashAndData = new Byte[fileBytes.Length + packetHashBytes.Length + 4];

Byte[] dataLengthBytes = BitConverter.GetBytes(hashAndData.Length);

Array.Copy(dataLengthBytes, hashAndData, dataLengthBytes.Length);

Array.Copy(packetHashBytes, 0, hashAndData, dataLengthBytes.Length, packetHashBytes.Length);

Array.Copy(fileBytes, 0, hashAndData, dataLengthBytes.Length + packetHashBytes.Length, fileBytes.Length);

client.BeginSend(hashAndData, 0, hashAndData.Length, SocketFlags.None, ae.End(), null);

yield return 1;

client.BeginDisconnect(true, ae.End(), null);

yield return 1;

Console.WriteLine("Socket Disconnected");

_processingTable.Remove(string.Format("{0}:{1}", hostNameOrAddress, port));

#region Process

private static IEnumerator<Int32> Process(AsyncEnumerator ae, String hostNameOrAddress, Int32 port, String filePath)

if (!File.Exists(filePath))

throw new FileNotFoundException(string.Format("{0} could not be found.", filePath));

IPAddress[] ipAddresses;

EndPoint endPoint;

Socket client = null;

if (!_processingTable.ContainsKey(string.Format("{0}:{1}", hostNameOrAddress, port)))

_processingTable.Add(string.Format("{0}:{1}", hostNameOrAddress, port), true);

ipAddresses = Dns.GetHostAddresses(hostNameOrAddress);

endPoint = new IPEndPoint(ipAddresses[0], port);

using (client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP))

string fileDir = Path.GetDirectoryName(filePath);

string hash = HashFile(filePath);

byte[] fileInfo = GetFileInfoBytes(filePath, hash);

byte[] filePositionBytes = new byte[8];

client.BeginConnect(endPoint, ae.End(), null);

yield return 1;

client.BeginSend(fileInfo, 0, fileInfo.Length, SocketFlags.None, ae.End(), null);

yield return 1;

int bytesSent = client.EndSend(ae.DequeueAsyncResult());

client.BeginReceive(filePositionBytes, 0, filePositionBytes.Length, SocketFlags.None, ae.End(), null);

yield return 1;

int bytesReceived = client.EndReceive(ae.DequeueAsyncResult());

Int64 filePosition = 0;

if (bytesReceived == 8)

filePosition = BitConverter.ToInt64(filePositionBytes, 0);

Console.WriteLine("Got the file start position: " + filePosition);

Int64 bytesToSend = 0;

using (FileStream fs = File.OpenRead(filePath))

Byte[] fileBytes;

fileBytes = new Byte[Properties.Settings.Default.MaxBufferSize];

if (fs.CanSeek)

fs.Seek(filePosition, SeekOrigin.Begin);

while (bytesToSend != 0)

if (bytesToSend < fileBytes.Length)

fileBytes = new Byte[bytesToSend];

for (int bytesReadSoFar = 0; bytesReadSoFar < fileBytes.Length; )

int bytesReadThisTime = fs.Read(fileBytes, bytesReadSoFar, fileBytes.Length - bytesReadSoFar);

client.BeginSend(fileBytes, 0, fileBytes.Length, SocketFlags.None, ae.End(), null);

yield return 1;

client.BeginDisconnect(true, ae.End(), null);

yield return 1;

Console.WriteLine("Socket Disconnected");

_processingTable.Remove(string.Format("{0}:{1}", hostNameOrAddress, port));

#region IsBusy

public static bool IsBusy(string server, int port)

bool isBusy = false;

if (_processingTable.ContainsKey(string.Format("{0}:{1}", server, port)))

isBusy = true;

return isBusy;

#region GetFileInfoBytes

private static byte[] GetFileInfoBytes(string fileName, string hash)

if (!File.Exists(fileName))

throw new FileNotFoundException("GetFileInfoBytes cannot find the specified file.");

FileInfo fi = new FileInfo(fileName);

byte[] fileNameBytes = Encoding.UTF8.GetBytes(Path.GetFileName(fileName));

byte[] fileNameLen = BitConverter.GetBytes(fileNameBytes.Length);

byte[] hashBytes = Convert.FromBase64String(hash);

byte[] hashLen = BitConverter.GetBytes(hashBytes.Length);

byte[] fileSizeBytes = BitConverter.GetBytes(fi.Length);

Byte[] dataLength = BitConverter.GetBytes(fileNameLen.Length + fileNameBytes.Length + fileSizeBytes.Length + hashLen.Length + hashBytes.Length + 4);

byte[] fileInfo = new byte[fileNameLen.Length + fileNameBytes.Length + fileSizeBytes.Length + hashLen.Length + hashBytes.Length + 4];

Array.Copy(dataLength, fileInfo, dataLength.Length);

Array.Copy(fileNameLen, 0, fileInfo, dataLength.Length, fileNameLen.Length);

Array.Copy(fileNameBytes, 0, fileInfo, dataLength.Length + fileNameLen.Length, fileNameBytes.Length);

Array.Copy(fileSizeBytes, 0, fileInfo, dataLength.Length + fileNameLen.Length + fileNameBytes.Length, fileSizeBytes.Length);

Array.Copy(hashLen, 0, fileInfo, dataLength.Length + fileNameLen.Length + fileNameBytes.Length + fileSizeBytes.Length, hashLen.Length);

Array.Copy(hashBytes, 0, fileInfo, dataLength.Length + fileNameLen.Length + fileNameBytes.Length + fileSizeBytes.Length + hashLen.Length, hashBytes.Length);

return fileInfo;

#region HashFile

private static string HashFile(string filePath)

string hash = string.Empty;

if (File.Exists(filePath + ".sha"))

using (StreamReader sr = new StreamReader(filePath + ".sha"))

else

hash = SHA256Utils.GenerateSHA256Hash(filePath);

using (StreamWriter sw = new StreamWriter(string.Format("{0}.sha", filePath)))

return hash;

--- In PowerThreading@yahoogroups.com, "Jeffrey Richter (Wintellect LLC)" <JeffreyR@...> wrote:
>
> Send me some code.
>
> --Jeffrey Richter (http://Wintellect .com)
>
> ________________________________
> From: bonneteit ebonnett@...
> Sent: Thursday, August 06, 2009 12:36 PM
> To: PowerThreading@yahoogroups.com PowerThreading@yahoogroups.com
> Subject: [PowerThreading] AsyncEnumerator.BeginExecute question
>
>
>
> I am calling my static class called PowerThreadingSocketClient from a Console app. I call the Start method, just like it shows in the example. From there, I new up an AsyncEnumerator and call BeginExecute passing my Process method in (and a couple of other params). In the Process method, I am transferring a/some large file(s). However, the BeginExecute, being async, returns right away and the Start method ends. This is closing my client socket immediately. I put a Console.Read in there and the file xfers but that isn't going to work in a real situation.
>
> Is there something I'm missing? Do I have to pass in a Socket instead of creating it in the Process method?
>
> TIA,
>
> Evan
>

I see.  Thanks a lot for the answer.  I posted my code but it doesn't contain
the call to Start in the iterator method.  I'll make that change now.

--- In PowerThreading@yahoogroups.com, Nikos Baxevanis <baxevanis@...> wrote:
>
>
> Hi Evan,
>
>
>
> All you need to do is have your Process method call again the static method
that creates the AE.
>
> Since all this is happening on a threadpool thread you may stop the program
anytime by hitting any key.
>
> There is a very good example in
\PowerThreading\PowerThreading-Samples\AsyncEnumerator\TcpServer
>
> You may also look at the following code,
>
>
>
>     internal sealed class Program {
>         private static void Main() {
>             TcpListener listener = new TcpListener(addr, tcpPort);
>             listener.Start();
>
>             ConnectionListener.Start(listener);
>
>             Console.ReadLine(); // Wait for the user to press any key and
exit.
>
>             listener.Stop();
>         }
>
>     }
>
>
>
>     internal static class ConnectionListener {
>         public static void Start(TcpListener listener) {
>             AsyncEnumerator ae = new AsyncEnumerator();
>             ae.BeginExecute(Process(ae,
>                 listener), ae.EndExecute, null);
>         }
>
>         private static IEnumerator<Int32> Process(AsyncEnumerator ae,
TcpListener listener) {
>             listener.BeginAcceptSocket(ae.End(), null);
>             yield return 1;
>
>             Socket socket;
>             try {  socket = listener.EndAcceptSocket(ae.DequeueAsyncResult());
}
>             catch (ObjectDisposedException) { yield break;}
>
>             Start(listener); // Accept another client.
>
>             // You may call sockets BeginXxx, EndXxx methods here using AE.
>             // ...
>         }
>     }
>
>
>
>
>
> -Nikos Baxevanis
>
>
>
> To: PowerThreading@yahoogroups.com
> From: ebonnett@...
> Date: Thu, 6 Aug 2009 19:35:39 +0000
> Subject: [PowerThreading] AsyncEnumerator.BeginExecute question
>
>
>
>
>
> I am calling my static class called PowerThreadingSocketClient from a Console
app. I call the Start method, just like it shows in the example. From there, I
new up an AsyncEnumerator and call BeginExecute passing my Process method in
(and a couple of other params). In the Process method, I am transferring a/some
large file(s). However, the BeginExecute, being async, returns right away and
the Start method ends. This is closing my client socket immediately. I put a
Console.Read in there and the file xfers but that isn't going to work in a real
situation.
>
> Is there something I'm missing? Do I have to pass in a Socket instead of
creating it in the Process method?
>
> TIA,
>
> Evan
>
>
>
>
>
>
>
>
>
> _________________________________________________________________
> Σύρετε φωτογραφίες στο παράθυρο του Messenger. Δείτε πώς.
> http://download.live.com/messenger
>

Hi, I am stuck on .NET 2.0 and am using this library for a project. I originally
designed around this library because of the ReadWriterLock class as well as the
option to use other locks.

Although I wanted to use a multiple reader, one writer system, the only locks
that worked well for me were the MonitorResourceLocks.

Now, I am getting a strange deadlock case and am wondering if one thread does a
.WaitToRead() and another does a .WaitToWrite() on a MonitorResourceLock, could
they deadlock? Do I need to do only reads or only writes with a
monitorresourcelock?

Thanks,
-Allan

Hi everyone,

I'm trying to use an AsyncEnumerator that's called (ultimately) from an ASP.NET
MVC 2 controller:

AsyncEnumerator<List<string>> ae = new AsyncEnumerator<List<string>>();
List<string> list = ae.EndExecute(ae.BeginExecute(MyEnumerator(ae, "foo bar"),
null));

When I execute this code in a unit test or test console app, it runs fine (it's
being called from the main thread).  However, when I execute it in the web site,
it blocks forever (it's being called from a worker thread).  My enumerator just
never gets called after the yield return 1; it looks like the calls to the
AsyncCallbacks in my async operations within my enumerator are stuck in
sleep/wait/join.  I am sure that all the asynchronous operations I'm performing
within my enumerator are returning properly.

Do I need to do anything special to make this work?  Thanks in advance.

Simon

Thanks for your response.  It fixed my problem.  I was trying to understand why
and found this blog post:
http://www.aaronlerch.com/blog/2007/05/19/net-20-winforms-multithreading-and-a-f\
ew-long-days/

That is very similar to the problem I'm having with the
AspNetSynchronizationContext.  Since there are multiple requests coming in from
the page (Javascript), I think what's happening is that the
AspNetSynchronizationContext referenced by the AE no longer has a message loop,
meaning that the callback to my enumerator never gets called.  Setting
ae.SyncContext = null; fixes the problem ... and I don't care about the callback
thread in this case so it's fine.

I think I would still have the same problem if I were using the AE
asynchronously here.

If any of my reasoning is incorrect, please let me know.

Simon

PS - I hate that I'm calling this synchronously ... it's just a temporary
measure until I can convert some more of the surrounding code to the async
pattern.

--- In PowerThreading@yahoogroups.com, Charles Prakash Dasari <prakashd@...>
wrote:
>
> You seem to be running your calls in the synchronous mode - i.e. not waiting
for a callback. You should clear up the sync context on AE if you want to run in
the sync mode.
>
> The following statement just after creating AE should do:
>
> ae.SyncContext = null;
>
> Regards,
> Prakash
>
> From: PowerThreading@yahoogroups.com [mailto:PowerThreading@yahoogroups.com]
On Behalf Of simonyun
> Sent: Wednesday, August 12, 2009 6:50 AM
> To: PowerThreading@yahoogroups.com
> Subject: [PowerThreading] AsyncEnumerator blocking forever when called sync
from ASP.NET MVC 2 controller
>
>
>
> Hi everyone,
>
> I'm trying to use an AsyncEnumerator that's called (ultimately) from an
ASP.NET MVC 2 controller:
>
> AsyncEnumerator<List<string>> ae = new AsyncEnumerator<List<string>>();
> List<string> list = ae.EndExecute(ae.BeginExecute(MyEnumerator(ae, "foo bar"),
null));
>
> When I execute this code in a unit test or test console app, it runs fine
(it's being called from the main thread). However, when I execute it in the web
site, it blocks forever (it's being called from a worker thread). My enumerator
just never gets called after the yield return 1; it looks like the calls to the
AsyncCallbacks in my async operations within my enumerator are stuck in
sleep/wait/join. I am sure that all the asynchronous operations I'm performing
within my enumerator are returning properly.
>
> Do I need to do anything special to make this work? Thanks in advance.
>
> Simon
>

I think the answer to your question is that even if the AE is being called
synchronously, the *enumerator* is performing async operations and needs to be
called back into (by the callback returned from ae.End()).  So you'd still, in
UI cases, want the enumerator to be called by the UI thread.

Simon

--- In PowerThreading@yahoogroups.com, Charles Prakash Dasari <prakashd@...>
wrote:
>
> So this brings one question to me: What is the use of copying
Thread.CurrentThread.SynchronizationContext to AsyncEnumerator.SyncContext when
the passed in callback is null in ae.BeginExecute call?
>
> Regards,
> Prakash
>
> From: PowerThreading@yahoogroups.com [mailto:PowerThreading@yahoogroups.com]
On Behalf Of Charles Prakash Dasari
> Sent: Wednesday, August 12, 2009 9:44 AM
> To: PowerThreading@yahoogroups.com
> Subject: RE: [PowerThreading] AsyncEnumerator blocking forever when called
sync from ASP.NET MVC 2 controller
>
>
> You seem to be running your calls in the synchronous mode - i.e. not waiting
for a callback. You should clear up the sync context on AE if you want to run in
the sync mode.
>
> The following statement just after creating AE should do:
>
> ae.SyncContext = null;
>
> Regards,
> Prakash
>
> From: PowerThreading@yahoogroups.com [mailto:PowerThreading@yahoogroups.com]
On Behalf Of simonyun
> Sent: Wednesday, August 12, 2009 6:50 AM
> To: PowerThreading@yahoogroups.com
> Subject: [PowerThreading] AsyncEnumerator blocking forever when called sync
from ASP.NET MVC 2 controller
>
>
>
> Hi everyone,
>
> I'm trying to use an AsyncEnumerator that's called (ultimately) from an
ASP.NET MVC 2 controller:
>
> AsyncEnumerator<List<string>> ae = new AsyncEnumerator<List<string>>();
> List<string> list = ae.EndExecute(ae.BeginExecute(MyEnumerator(ae, "foo bar"),
null));
>
> When I execute this code in a unit test or test console app, it runs fine
(it's being called from the main thread). However, when I execute it in the web
site, it blocks forever (it's being called from a worker thread). My enumerator
just never gets called after the yield return 1; it looks like the calls to the
AsyncCallbacks in my async operations within my enumerator are stuck in
sleep/wait/join. I am sure that all the asynchronous operations I'm performing
within my enumerator are returning properly.
>
> Do I need to do anything special to make this work? Thanks in advance.
>
> Simon
>

Jeffrey,

Do you have a recommended way to guard against the race condition you describe
below?  I want to use an async enumerator to first execute one async operation
with a timeout, followed by several operations in parallel with a different
timeout value.

I'm worried about the race condition since it could prevent subsequent
operations from being processed properly because IsCanceled() will return true
as a result of the first timer's expiration before the second call to
SetCancelTimeout() can be made.

Thanks,
Simon

--- In PowerThreading@yahoogroups.com, "Jeffrey Richter (Wintellect LLC)"
<JeffreyR@...> wrote:
>
> Well, I got free minute and I looked at my code...Good news: I already do what
you want.
> Yes, you can periodically call SetCancelTimeout. When you do, I dispose of the
current timer, and if you don't pass Timeout.Infinite (-1), then I create a new
Timer that goes off when you want it to.
> Note, that there may be a race condition though: after a yield return, your
iterator code may be executing and the current timer could go off before you
call SetCancelTimeout.
> If this happens, then the next time, you call yield return, I will call back
into your code immediately and IsCanceled will return true.
>
> -- Jeffrey Richter (http://Wintellect.com<http://wintellect.com/>)
>
> From: PowerThreading@yahoogroups.com [mailto:PowerThreading@yahoogroups.com]
On Behalf Of jon_reis
> Sent: Tuesday, February 17, 2009 9:58 AM
> To: PowerThreading@yahoogroups.com
> Subject: [PowerThreading] Re: FW: Timeouts
>
>
> Hi Jeffrey, thanks for taking the time to help me out.
>
> I tried your suggestion to implement my own EndExecute function to handle
exceptions thrown by Process and this works nicely. Thank you.
>
> I tried your suggestion of using the overloaded ae.End() that takes a dicard
group. I am using ae.End(0, c => null) everywhere since I don't need to do
anything special to clean up. Is this OK, or should I be doing something else?
>
> I tried your suggestion of using a DiscardGroup, but I'm still a little
confused as to how these function. The code as I have it below does not work
properly. It seems the DiscardGroup remembers that group 0, has been discarded
and causes the call to //(1) to be discarded during the second iteration of the
while loop. Am I supposed to increment the DiscardGroup each time I use it up to
a maximum of 64? Besides being pretty combersome, it will only allow me to
receive 64 messages before I run out of DiscardGroups. I don't understand the
usecase for DiscardGroup, what I really want is a DiscardPending that throws out
all pending operations. I'm sure like the other things I have run into that I
must be missing something here.
>
> In your original response you state:
>
> [JR] No. SetCancelTimeout applies to the entire AE object. That is, you are
cancelling the whole workflow, not just a part of it.
>
> I do want to cancel the entire workflow, but I want to change the timeout for
each operation. Like:
>
> ae.SetCancelTimeout(60000,null); // read for 60 seconds
> stream.BeginRead(bbuffer.Array, bbuffer.Length, bbuffer.SpaceAvailable,
ae.End(0, c => null), null);
> yeild 1;
> ae.SetCancelTimeout(-1,null); // turn off cancel
> if(ae.IsCanceled()) yield break;
>
> Will the second call to SetCancelTimout disable the timeout?
>
>
>
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>
>  private void Start()
>     {
>       AsyncEnumerator ae = new AsyncEnumerator();
>       ae.BeginExecute(Process(ae, _listener), EndExecute, ae);
>     }
>
>     private void EndExecute(IAsyncResult result)
>     {
>       try
>       {
>         AsyncEnumerator ae = (AsyncEnumerator)result.AsyncState;
>         ae.EndExecute(result);
>       }
>       catch(Exception ex)
>       {
>         if(OnException != null) OnException(this, ex);
>       }
>     }
>
>     private IEnumerator<Int32> Process(AsyncEnumerator ae, TcpListener server)
>     {
>       server.BeginAcceptTcpClient(ae.End(0,c=>null), null);
>       yield return 1;
>
>       if(_isExiting)
>         yield break;
>
>       using(TcpClient client =
server.EndAcceptTcpClient(ae.DequeueAsyncResult()))
>       {
>         int timeout = 60000;
>         Start();  // Accept another client
>         using(Stream stream = client.GetStream())
>         {
>           CountdownTimer countdownTimer = new CountdownTimer();
>           Buffer<byte> bbuffer = new Buffer<byte>();
>           while(true)
>           {
>             bbuffer.SpaceAvailable += 64 * 1024;
>             stream.BeginRead(bbuffer.Array, bbuffer.Length,
bbuffer.SpaceAvailable, ae.End(0, c => null), null); //(1)
>             countdownTimer.BeginCountdown(timeout, ae.End(0, c=>null), ae);
>             yield return 1;
>
>             timeout = 5000;
>             if(countdownTimer.Expired) // I added this method to the timer you
gave me
>             {
>               ae.DiscardGroup(0);
>               break;
>             }
>             int result = stream.EndRead(ae.DequeueAsyncResult());
>             ae.DiscardGroup(0);
>
>             if(result == 0) break; //client shutdown
>             bbuffer.Length += result;
>             if(bbuffer.Array.ReverseFind(0, bbuffer.Length,
_framing.EndFrameBytes) >= 0) // look for end of message marker
>             {
>               // Write outputData back to client
>               stream.BeginWrite(bbuffer.Array, 0, bbuffer.Length, ae.End(0, c
=> null), null);
>               yield return 1;
>
>               stream.EndWrite(ae.DequeueAsyncResult());
>               bbuffer.Length = 0;
>               timeout = 60000; // wait longer for the start of the next
message
>             }
>           }
>         }
>       }
>    }
>

Jeffrey,

Calling the AE synchronously was just a temporary measure until I could convert
more of the surrounding code to the APM.  And there's a lot of it to convert.

If I set the SyncContext property to null, am I still guaranteed to have only
one thread executing inside the iterator at once?  I'm assuming that if
SyncContext is null, the callback can happen on any ThreadPool thread; I'm not
sure if this means that multiple callbacks can now happen at once since they're
not all necessarily being dispatched to the same thread (as far as I know).

Thanks,
Simon

--- In PowerThreading@yahoogroups.com, "Jeffrey Richter (Wintellect LLC)"
<JeffreyR@...> wrote:
>
> Short answer: after new'ing up the ae, do this: ae.SyncConext = null;
>
> You can search the Yahoo news group for other posts about hanging and
SyncContext.
> Alternatively, don't wait for the AE synchronously by calling EndExecute the
way you. This kinda defeats the purpose of  using the AE anyway.
>
> -- Jeffrey Richter (http://Wintellect.com<http://wintellect.com/>)
>
> From: PowerThreading@yahoogroups.com [mailto:PowerThreading@yahoogroups.com]
On Behalf Of simonyun
> Sent: Wednesday, August 12, 2009 6:50 AM
> To: PowerThreading@yahoogroups.com
> Subject: [PowerThreading] AsyncEnumerator blocking forever when called sync
from ASP.NET MVC 2 controller
>
>
>
> Hi everyone,
>
> I'm trying to use an AsyncEnumerator that's called (ultimately) from an
ASP.NET MVC 2 controller:
>
> AsyncEnumerator<List<string>> ae = new AsyncEnumerator<List<string>>();
> List<string> list = ae.EndExecute(ae.BeginExecute(MyEnumerator(ae, "foo bar"),
null));
>
> When I execute this code in a unit test or test console app, it runs fine
(it's being called from the main thread). However, when I execute it in the web
site, it blocks forever (it's being called from a worker thread). My enumerator
just never gets called after the yield return 1; it looks like the calls to the
AsyncCallbacks in my async operations within my enumerator are stuck in
sleep/wait/join. I am sure that all the asynchronous operations I'm performing
within my enumerator are returning properly.
>
> Do I need to do anything special to make this work? Thanks in advance.
>
> Simon
>

Thank you for the response.

Actually, in my case I *do* want a timeout on the first operation.  Then, after
that operation completes, I want to set a new timeout value for the parallel
operations.  Is there any way to avoid the race condition in this case without
using two separate AEs?

Simon

--- In PowerThreading@yahoogroups.com, "Jeffrey Richter (Wintellect LLC)"
<JeffreyR@...> wrote:
>
> If you want to execute the first operation without a timeout at all, then just
don't call SetCancelTimeout until after it competes before you initiate the
parallel operations.
> -- Jeffrey Richter (http://Wintellect.com<http://wintellect.com/>)
>
> From: PowerThreading@yahoogroups.com [mailto:PowerThreading@yahoogroups.com]
On Behalf Of simonyun
> Sent: Thursday, August 13, 2009 4:26 PM
> To: PowerThreading@yahoogroups.com
> Subject: [PowerThreading] Re: FW: Timeouts
>
>
>
> Jeffrey,
>
> Do you have a recommended way to guard against the race condition you describe
below? I want to use an async enumerator to first execute one async operation
with a timeout, followed by several operations in parallel with a different
timeout value.
>
> I'm worried about the race condition since it could prevent subsequent
operations from being processed properly because IsCanceled() will return true
as a result of the first timer's expiration before the second call to
SetCancelTimeout() can be made.
>
> Thanks,
> Simon
>
> --- In
PowerThreading@yahoogroups.com<mailto:PowerThreading%40yahoogroups.com>,
"Jeffrey Richter (Wintellect LLC)" <JeffreyR@<mailto:JeffreyR@>> wrote:
> >
> > Well, I got free minute and I looked at my code...Good news: I already do
what you want.
> > Yes, you can periodically call SetCancelTimeout. When you do, I dispose of
the current timer, and if you don't pass Timeout.Infinite (-1), then I create a
new Timer that goes off when you want it to.
> > Note, that there may be a race condition though: after a yield return, your
iterator code may be executing and the current timer could go off before you
call SetCancelTimeout.
> > If this happens, then the next time, you call yield return, I will call back
into your code immediately and IsCanceled will return true.
> >
> > -- Jeffrey Richter (http://Wintellect.com<http://wintellect.com/>)
> >
> > From:
PowerThreading@yahoogroups.com<mailto:PowerThreading%40yahoogroups.com>
[mailto:PowerThreading@yahoogroups.com<mailto:PowerThreading%40yahoogroups.com>]
On Behalf Of jon_reis
> > Sent: Tuesday, February 17, 2009 9:58 AM
> > To: PowerThreading@yahoogroups.com<mailto:PowerThreading%40yahoogroups.com>
> > Subject: [PowerThreading] Re: FW: Timeouts
> >
> >
> > Hi Jeffrey, thanks for taking the time to help me out.
> >
> > I tried your suggestion to implement my own EndExecute function to handle
exceptions thrown by Process and this works nicely. Thank you.
> >
> > I tried your suggestion of using the overloaded ae.End() that takes a dicard
group. I am using ae.End(0, c => null) everywhere since I don't need to do
anything special to clean up. Is this OK, or should I be doing something else?
> >
> > I tried your suggestion of using a DiscardGroup, but I'm still a little
confused as to how these function. The code as I have it below does not work
properly. It seems the DiscardGroup remembers that group 0, has been discarded
and causes the call to //(1) to be discarded during the second iteration of the
while loop. Am I supposed to increment the DiscardGroup each time I use it up to
a maximum of 64? Besides being pretty combersome, it will only allow me to
receive 64 messages before I run out of DiscardGroups. I don't understand the
usecase for DiscardGroup, what I really want is a DiscardPending that throws out
all pending operations. I'm sure like the other things I have run into that I
must be missing something here.
> >
> > In your original response you state:
> >
> > [JR] No. SetCancelTimeout applies to the entire AE object. That is, you are
cancelling the whole workflow, not just a part of it.
> >
> > I do want to cancel the entire workflow, but I want to change the timeout
for each operation. Like:
> >
> > ae.SetCancelTimeout(60000,null); // read for 60 seconds
> > stream.BeginRead(bbuffer.Array, bbuffer.Length, bbuffer.SpaceAvailable,
ae.End(0, c => null), null);
> > yeild 1;
> > ae.SetCancelTimeout(-1,null); // turn off cancel
> > if(ae.IsCanceled()) yield break;
> >
> > Will the second call to SetCancelTimout disable the timeout?
> >
> >
> >
> > +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> >
> > private void Start()
> > {
> > AsyncEnumerator ae = new AsyncEnumerator();
> > ae.BeginExecute(Process(ae, _listener), EndExecute, ae);
> > }
> >
> > private void EndExecute(IAsyncResult result)
> > {
> > try
> > {
> > AsyncEnumerator ae = (AsyncEnumerator)result.AsyncState;
> > ae.EndExecute(result);
> > }
> > catch(Exception ex)
> > {
> > if(OnException != null) OnException(this, ex);
> > }
> > }
> >
> > private IEnumerator<Int32> Process(AsyncEnumerator ae, TcpListener server)
> > {
> > server.BeginAcceptTcpClient(ae.End(0,c=>null), null);
> > yield return 1;
> >
> > if(_isExiting)
> > yield break;
> >
> > using(TcpClient client = server.EndAcceptTcpClient(ae.DequeueAsyncResult()))
> > {
> > int timeout = 60000;
> > Start(); // Accept another client
> > using(Stream stream = client.GetStream())
> > {
> > CountdownTimer countdownTimer = new CountdownTimer();
> > Buffer<byte> bbuffer = new Buffer<byte>();
> > while(true)
> > {
> > bbuffer.SpaceAvailable += 64 * 1024;
> > stream.BeginRead(bbuffer.Array, bbuffer.Length, bbuffer.SpaceAvailable,
ae.End(0, c => null), null); //(1)
> > countdownTimer.BeginCountdown(timeout, ae.End(0, c=>null), ae);
> > yield return 1;
> >
> > timeout = 5000;
> > if(countdownTimer.Expired) // I added this method to the timer you gave me
> > {
> > ae.DiscardGroup(0);
> > break;
> > }
> > int result = stream.EndRead(ae.DequeueAsyncResult());
> > ae.DiscardGroup(0);
> >
> > if(result == 0) break; //client shutdown
> > bbuffer.Length += result;
> > if(bbuffer.Array.ReverseFind(0, bbuffer.Length, _framing.EndFrameBytes) >=
0) // look for end of message marker
> > {
> > // Write outputData back to client
> > stream.BeginWrite(bbuffer.Array, 0, bbuffer.Length, ae.End(0, c => null),
null);
> > yield return 1;
> >
> > stream.EndWrite(ae.DequeueAsyncResult());
> > bbuffer.Length = 0;
> > timeout = 60000; // wait longer for the start of the next message
> > }
> > }
> > }
> > }
> > }
> >
>

 

Thank you for the response.

Actually, in my case I *do* want a timeout on the first operation. Then, after that operation completes, I want to set a new timeout value for the parallel operations. Is there any way to avoid the race condition in this case without using two separate AEs?

Simon

--- In PowerThreading@yahoogroups.com, "Jeffrey Richter (Wintellect LLC)" <JeffreyR@...> wrote:
>
> If you want to execute the first operation without a timeout at all, then just don't call SetCancelTimeout until after it competes before you initiate the parallel operations.
> -- Jeffrey Richter (http://Wintellect.com<http://wintellect.com/>)
>
> From: PowerThreading@yahoogroups.com [mailto:PowerThreading@yahoogroups.com] On Behalf Of simonyun
> Sent: Thursday, August 13, 2009 4:26 PM
> To: PowerThreading@yahoogroups.com
> Subject: [PowerThreading] Re: FW: Timeouts
>
>
>
> Jeffrey,
>
> Do you have a recommended way to guard against the race condition you describe below? I want to use an async enumerator to first execute one async operation with a timeout, followed by several operations in parallel with a different timeout value.
>
> I'm worried about the race condition since it could prevent subsequent operations from being processed properly because IsCanceled() will return true as a result of the first timer's expiration before the second call to SetCancelTimeout() can be made.
>
> Thanks,
> Simon
>
> --- In PowerThreading@yahoogroups.com<mailto:PowerThreading%40yahoogroups.com>, "Jeffrey Richter (Wintellect LLC)" <JeffreyR@<mailto:JeffreyR@>> wrote:
> >
> > Well, I got free minute and I looked at my code...Good news: I already do what you want.
> > Yes, you can periodically call SetCancelTimeout. When you do, I dispose of the current timer, and if you don't pass Timeout.Infinite (-1), then I create a new Timer that goes off when you want it to.
> > Note, that there may be a race condition though: after a yield return, your iterator code may be executing and the current timer could go off before you call SetCancelTimeout.
> > If this happens, then the next time, you call yield return, I will call back into your code immediately and IsCanceled will return true.
> >
> > -- Jeffrey Richter (http://Wintellect.com<http://wintellect.com/>)
> >
> > From: PowerThreading@yahoogroups.com<mailto:PowerThreading%40yahoogroups.com> [mailto:PowerThreading@yahoogroups.com<mailto:PowerThreading%40yahoogroups.com>] On Behalf Of jon_reis
> > Sent: Tuesday, February 17, 2009 9:58 AM
> > To: PowerThreading@yahoogroups.com<mailto:PowerThreading%40yahoogroups.com>
> > Subject: [PowerThreading] Re: FW: Timeouts
> >
> >
> > Hi Jeffrey, thanks for taking the time to help me out.
> >
> > I tried your suggestion to implement my own EndExecute function to handle exceptions thrown by Process and this works nicely. Thank you.
> >
> > I tried your suggestion of using the overloaded ae.End() that takes a dicard group. I am using ae.End(0, c => null) everywhere since I don't need to do anything special to clean up. Is this OK, or should I be doing something else?
> >
> > I tried your suggestion of using a DiscardGroup, but I'm still a little confused as to how these function. The code as I have it below does not work properly. It seems the DiscardGroup remembers that group 0, has been discarded and causes the call to //(1) to be discarded during the second iteration of the while loop. Am I supposed to increment the DiscardGroup each time I use it up to a maximum of 64? Besides being pretty combersome, it will only allow me to receive 64 messages before I run out of DiscardGroups. I don't understand the usecase for DiscardGroup, what I really want is a DiscardPending that throws out all pending operations. I'm sure like the other things I have run into that I must be missing something here.
> >
> > In your original response you state:
> >
> > [JR] No. SetCancelTimeout applies to the entire AE object. That is, you are cancelling the whole workflow, not just a part of it.
> >
> > I do want to cancel the entire workflow, but I want to change the timeout for each operation. Like:
> >
> > ae.SetCancelTimeout(60000,null); // read for 60 seconds
> > stream.BeginRead(bbuffer.Array, bbuffer.Length, bbuffer.SpaceAvailable, ae.End(0, c => null), null);
> > yeild 1;
> > ae.SetCancelTimeout(-1,null); // turn off cancel
> > if(ae.IsCanceled()) yield break;
> >
> > Will the second call to SetCancelTimout disable the timeout?
> >
> >
> >
> > +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> >
> > private void Start()
> > {
> > AsyncEnumerator ae = new AsyncEnumerator();
> > ae.BeginExecute(Process(ae, _listener), EndExecute, ae);
> > }
> >
> > private void EndExecute(IAsyncResult result)
> > {
> > try
> > {
> > AsyncEnumerator ae = (AsyncEnumerator)result.AsyncState;
> > ae.EndExecute(result);
> > }
> > catch(Exception ex)
> > {
> > if(OnException != null) OnException(this, ex);
> > }
> > }
> >
> > private IEnumerator<Int32> Process(AsyncEnumerator ae, TcpListener server)
> > {
> > server.BeginAcceptTcpClient(ae.End(0,c=>null), null);
> > yield return 1;
> >
> > if(_isExiting)
> > yield break;
> >
> > using(TcpClient client = server.EndAcceptTcpClient(ae.DequeueAsyncResult()))
> > {
> > int timeout = 60000;
> > Start(); // Accept another client
> > using(Stream stream = client.GetStream())
> > {
> > CountdownTimer countdownTimer = new CountdownTimer();
> > Buffer<byte> bbuffer = new Buffer<byte>();
> > while(true)
> > {
> > bbuffer.SpaceAvailable += 64 * 1024;
> > stream.BeginRead(bbuffer.Array, bbuffer.Length, bbuffer.SpaceAvailable, ae.End(0, c => null), null); //(1)
> > countdownTimer.BeginCountdown(timeout, ae.End(0, c=>null), ae);
> > yield return 1;
> >
> > timeout = 5000;
> > if(countdownTimer.Expired) // I added this method to the timer you gave me
> > {
> > ae.DiscardGroup(0);
> > break;
> > }
> > int result = stream.EndRead(ae.DequeueAsyncResult());
> > ae.DiscardGroup(0);
> >
> > if(result == 0) break; //client shutdown
> > bbuffer.Length += result;
> > if(bbuffer.Array.ReverseFind(0, bbuffer.Length, _framing.EndFrameBytes) >= 0) // look for end of message marker
> > {
> > // Write outputData back to client
> > stream.BeginWrite(bbuffer.Array, 0, bbuffer.Length, ae.End(0, c => null), null);
> > yield return 1;
> >
> > stream.EndWrite(ae.DequeueAsyncResult());
> > bbuffer.Length = 0;
> > timeout = 60000; // wait longer for the start of the next message
> > }
> > }
> > }
> > }
> > }
> >
>