Frankie wrote:I'm not sure what you mean by 'context' here. What I'm referring to isthat the task just needs a unique identifier.But what are you going to do with that identifier? For example, if allyou're going to do is use it to look up some data specific to thespecific instance of the operation, then why not just use the dataitself as the unique identifier?.Each of these 15 concurrent operations needs to be uniquelyidentified.Of course.The client, upon calling GrabFileAsync would then supply aunique identifier. When any of the 15 async operations completes or reportsprogress, etc, the client would then use the 'task id' to identify whichparticular GrabFileAsync operation has completed, etc.But what does 'identifying' which operation has completed gain you? Theidentification does you no good unless you somehow correlated theidentification with some data specific to the operation. So you mightas well use the data itself as your unique identifier.It's entirely possible that your meaning 'context' is the similar to mine.If so, maybe you could clarify why an integer isn't the best, and why goingwith some 'context' class would be better.See above.

1. A Concurrent Second Call Is Made On An Object Before The First Is Completed
2. Virtual Disk Service Error The Volume Is Not Formattable
3. How To Cancel Diskpart Format

A Concurrent Second Call Is Made On An Object Before The First Is Completed

All that adding an integer into the design does is create anextra level of indirection you need to resolve upon completion of anoperation. I don't see the point in doing that.As an example, consider the Socket class. When you call BeginReceive,you pass a 'state' parameter. This is what I'm calling 'context'.

Inthe most basic case, the code using the Socket instance would typicallypass at a minimum the Socket instance reference itself. Then in thereceive callback, the 'state' parameter passed to the callback can becast back to a Socket which can then be used to complete the operation(calling EndReceive, for example).If there were other data related to the receive operation that wasimportant (for example, perhaps the Socket is being used to transfer afile and you want to easily get the FileStream you're using to save thedata to the disk), then you'd have a class that contains both the Socketinstance reference as well as that other data (for example, theFileStream reference). Then in the receive callback method, you justcast the 'state' parameter back to your particular class, and from thatretrieve the Socket instance and other data (such as the FileStreaminstance reference).If you instead use a unique integer, then instead of just casting thevalue to the appropriate class, you have to use that integer to look upan instance of the appropriate class in some data structure, like anArray or Dictionary. Why add that extra bit of work when you couldjust pass the reference you want in the first place?Pete. Thanks for the dialog on this. To continue with it.But what are you going to do with that identifier? For example, if allyou're going to do is use it to look up some data specific to the specificinstance of the operation, then why not just use the data itself as theunique identifier?The identifier wouldn't necessarily be used to look up data related to theoperation.

The identifier would identify the specific instance of theoperation, itself. There's no reason that we must associate any data withan async operation. Just have it go to work. I would agree with theposition that states we would usually have data to associate with an asyncoperation, and therefore could/should use that to ID the operation as youare suggesting.Each of these 15 concurrent operations needs to be uniquely identified.Of course.The client, upon calling GrabFileAsync would then supply a uniqueidentifier. When any of the 15 async operations completes or reportsprogress, etc, the client would then use the 'task id' to identify whichparticular GrabFileAsync operation has completed, etc.But what does 'identifying' which operation has completed gain you? Theidentification does you no good unless you somehow correlated theidentification with some data specific to the operation. So you might aswell use the data itself as your unique identifier.Yes, but that's assuming that data must or can be associated with an asyncoperation prior to initiating it.

Can't we have async operations withoutassociated data? We can certainly have methods that return void and takezero parameters. They just 'do something'. What's to say we can't call sucha method asynchronously? At the bottom of this post I have a more detailedexample. The information we might want from such an asynchronous call mightinclude things about the call, itself, which might not be available beforecalling the method. Such data about the call, itself, might include thingslike 'user cancelled the operation before it completed', 'operation ran intoException xyz during the course of its operations', or 'the operation justnow completed.'

In these cases, we'd have to invent some identifier out ofthin air - perhaps a unique integer, which is what I was thinking in the OPhere. Maybe I'm still wrong about that.It's entirely possible that your meaning 'context' is the similar tomine.

Virtual Disk Service Error The Volume Is Not Formattable

If so, maybe you could clarify why an integer isn't the best, andwhy going with some 'context' class would be better.See above. All that adding an integer into the design does is create anextra level of indirection you need to resolve upon completion of anoperation. I don't see the point in doing that.Your 'unnecessary indirection' point is well taken -but only in cases werewe would have data to associate with the operation prior to kicking it off.If no data exists prior to initiating the async operation, then we'd have tocome up with some way to ID the operation.As an example, consider the Socket class. When you call BeginReceive, youpass a 'state' parameter. Sims 4 cheat cats and dogs. This is what I'm calling 'context'. In themost basic case, the code using the Socket instance would typically passat a minimum the Socket instance reference itself. Then in the receivecallback, the 'state' parameter passed to the callback can be cast back toa Socket which can then be used to complete the operation (callingEndReceive, for example).If there were other data related to the receive operation that wasimportant (for example, perhaps the Socket is being used to transfer afile and you want to easily get the FileStream you're using to save thedata to the disk), then you'd have a class that contains both the Socketinstance reference as well as that other data (for example, the FileStreamreference).

Then in the receive callback method, you just cast the'state' parameter back to your particular class, and from that retrievethe Socket instance and other data (such as the FileStream instancereference).Great example. Couldn't agree more! But this is an example where weactually have something to run with before kicking off the async operation.If you instead use a unique integer, then instead of just casting thevalue to the appropriate class, you have to use that integer to look up aninstance of the appropriate class in some data structure, like an Array orDictionary. Why add that extra bit of work when you could just pass thereference you want in the first place?Now, I can see this next question 'coming down mainstreet' -OkayFrankie, what is an example of an event for which we wouldn't have at leastsome data with which to uniquely ID the asycn operation prior to kickingit off? Here goes.I'm writing a utility app that will be used to update a bunch of Web sitesby copying files (.aspx, gif, etc) to various site directories. The utilityadditionally updates the underlying SQL Server database by (1) executing DDLscripts and (2) installing or updating stored procedures. Prior to launchingan update operation, the utility 'validates' the destination Web sites andSQL Server databases to be updated.

Specifically, the Validate methodensures that (1) each Web site's root directory exist, and that all requiredsubdirectories exist. A separate Validate method verifies connectivity tothe SQL Server databases. The utility does practically none of this gruntwork, itself.

How To Cancel Diskpart Format

Rather, it dynamically loads 'installers' which are classesthat implement a common IInstaller interface, which defines a Validatemethod. The client, here, doesn't know what is being validated.

All it'sdoing is looping through its list of IInstallers and telling each toValidate its environment. I'm modifying this arrangement so that theValidate methods can run asynchronously (i.e., so the interface will bemodified to define ValidateAsync in addition to the synchronous Validatemethod). All the client app will do is kick off these ValidateAsyncoperations which will in turn report (1) progress (i.e., 'SomeWebSite.comvalidated successfully', or 'failed to connect to TheDbNamedX' etc - foreach Web site and for each db), and (2) report when each ValidateAsyncoperation completes (including the usual AsycnCompletedEventArgs stuff). Inthis scenario I'm not sure how the client app that initiates theseValidateAsync operations would identify each async operation withoutassigning some unique ID invented out of thin air.I'd appreciate your further perspective on this.-Frankie. Frankie wrote:.It could be. But in my case I don't already have a class that refers tothe async operation.If you have no class that refers to the async operation, then how wouldyou use a numeric ID to map to an async operation?Surely the async operation has some data somewhere. Otherwise, youhave no way to reference it.In my case, the client is initiating the asyncoperation by calling the ValidateAsync method of an interface - so theclient doesn't know anything about the particular class implementing theasync operationSo what?

I never said there's an existing class that the client knowsabout. We are (as far as I know) talking about how the design couldbe, not how it is.So, just because there's no class the client knows about now, thatdoesn't mean there couldn't be one. Just return the reference to theclass implementing the async operation.It doesn't need to be the actual type known to the code that actuallyuses it. Publish some sort of base class or interface that you canreturn; all the client would know is 'this is my unique reference to theasync operation'.

Then the actual reference would be a class thatinherits or implements the base class or interface, respectively.ValidateAsync takes aparameter that can be any object. That parameter is subsequently used in the'event publisher/worker class' to identify the async operation.Why is the worker class using data from the client to identify its owndata? What happens if the client uses the same value twice? Frankie wrote:Thanks for the helpful dialog on this. I learned a lot as this was myinitial encounter with the Event-based async pattern and the MSDN sample iswhat I was basing everything off of. And thanks especially for posting somevery clear feedback and perspective on how you would modify the MSDN samplein a way that frees the client from having to come up with some arbitraryID.You're welcome. As you can see, it is often much easier to offercomments when there is a concrete example of code to start with(especially if that code sample is relatively minimal).I didn't really like it to begin with, and especially their use ofRandom.

Thus the OP here.Indeed. I hope if nothing else it's clear that using Random isn'tappropriate for generating task IDs. Note, however, that the use ofRandom in the sample code isn't for the task ID, but rather for thenumber to test for prime-ness. The sample code uses a GUID as the task ID.So, while there are obviously aspects of the sample I would dodifferently, it's not actually broken.:)Pete.

Definitionis a part of pattern and it is categorized under creational design patterns.In this article we are going to take a deeper look into the usage of the Singleton pattern. It is one of the most simple design pattern in terms of the modelling but on the other hand this is one of the most controversial pattern in terms of complexity of usage.In Java the Singleton pattern will ensure that there is only one instance of a class is created in the Java Virtual Machine. It is used to provide global point of access to the object.

In terms of practical use Singleton patterns are used in logging, caches, thread pools, configuration settings, device driver objects. Design pattern is often used in conjunction with. This pattern is also used in Service Locator JEE pattern.Structure.