{"id":1096,"date":"2021-07-28T20:35:18","date_gmt":"2021-07-28T20:35:18","guid":{"rendered":"https:\/\/www.parametriczoo.com\/?p=1096"},"modified":"2021-07-28T21:36:03","modified_gmt":"2021-07-28T21:36:03","slug":"grasshopper-plugin-event-based-asynchronous-programming-in-c","status":"publish","type":"post","link":"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/","title":{"rendered":"Grasshopper plugin & Event based asynchronous programming in C#"},"content":{"rendered":"

[et_pb_section fb_built=”1″ _builder_version=”3.22.7″][et_pb_row _builder_version=”3.22.7″][et_pb_column type=”4_4″ _builder_version=”3.22.7″][et_pb_text _builder_version=”3.22.7″]<\/p>\n

I am just working on a Grasshopper plugin which requires multi-threading. At the beginning I had some problem with implementing the asynchronized event and expiring the grasshopper solution from another thread. It seams that this topic is already discussed and there are some snipped codes you may find on Rhino forum , however, I could not find a complete implementation of asynchronous programming which uses the\u00a0AsyncCompletedEventArgs\u00a0<\/a>within the Grasshopper component. Today I managed to use Asynchronized operation and I would like to share a few files as template which helps you to put up your code and take advantages of an asynchronous program. Please remember that asnych-programming is useful when you want to avoid the frozen UI or you are working with server side applications in which you need to wait for data to be downloaded or uploaded and also be noted that asynchronous programming does not always make things faster ! So if you are ready let’s jump into some code..<\/p>\n

 <\/p>\n

[\/et_pb_text][et_pb_accordion _builder_version=”3.22.7″][et_pb_accordion_item title=”Grasshopper Component” open=”off” _builder_version=”3.22.7″ title_text_shadow_horizontal_length=”0em” title_text_shadow_vertical_length=”0em” title_text_shadow_blur_strength=”0em” body_text_shadow_horizontal_length=”0em” body_text_shadow_vertical_length=”0em” body_text_shadow_blur_strength=”0em”]<\/p>\n

Here is a C# implementation of the grasshopper component which contains an asynchronous program.\u00a0 You have two flags defining the state of the program. Once you run the program you set the\u00a0taskIsRunning to true and once all tasks are completed you set it back to false. The\u00a0<\/span>taskIsCompleted flag is set to true in the same event however it is reset when the solution of the component is updated. In SolveInstance() method when no task is running and no tasks is completed (meaning component is updated when no task is running) we create an instance of our asynchronous program and assign handler to its events. As you can see in the code below when all tasks are completed we expire the solution and updated the outputs.<\/span><\/p>\n

[\/et_pb_accordion_item][et_pb_accordion_item title=”CODE” open=”off” _builder_version=”3.22.7″ title_text_shadow_horizontal_length=”0em” title_text_shadow_vertical_length=”0em” title_text_shadow_blur_strength=”0em” body_text_shadow_horizontal_length=”0em” body_text_shadow_vertical_length=”0em” body_text_shadow_blur_strength=”0em” background_color=”#eeeeee”]<\/p>\n

    \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n    \/\/\/<\/span> this is an example of implementation of Asynchronous Programming within grasshopper component<\/span>\n    \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n    public<\/span> class<\/span> AsychGHComponent<\/span> :<\/span> GHCustomComponent<\/span>\n    {<\/span>\n        \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n        \/\/\/<\/span> it is true when task is running and <\/span>\n        \/\/\/<\/span> then it is set to false after completation of all tasks.<\/span>\n        \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n        bool<\/span> taskIsRunning<\/span> =<\/span> false<\/span>;<\/span>\n        \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n        \/\/\/<\/span> it is true just after completaion of all tasks and <\/span>\n        \/\/\/<\/span> then it is set to false after updating the data <\/span>\n        \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n        bool<\/span> taskIsCompleted<\/span> =<\/span> false<\/span>;<\/span>\n        \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n        \/\/\/<\/span> if you wish to allow user to cancel operation<\/span>\n        \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n        CancellationTokenSource<\/span> cts<\/span>;<\/span>\n \n        \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n        \/\/\/<\/span> instance of the asynched-programm<\/span>\n        \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n        AsynchronousProgram<\/span> _myProgramm<\/span>;<\/span>\n \n        #region<\/span> constructor<\/span>\n        \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n        \/\/\/<\/span> this is an example of implementation of <\/span>\n        \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n        public<\/span> AsychGHComponent<\/span>()<\/span>\n          :<\/span> base<\/span>(<\/span>\"AsychGHComponent\"<\/span>,<\/span> \"AP\"<\/span>,
<\/span>              \"An example of Grasshopper plugin & Event based asynchronous programming in C#\"<\/span>,<\/span>              \n              \"mainCat\"<\/span>,<\/span> \"subCat\"<\/span>)<\/span>\n        {<\/span>\n        }<\/span>\n        #endregion<\/span>\n \n        #region<\/span> implementation of the base class<\/span>\n \n        \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n        \/\/\/<\/span> Registers all the input parameters for this component.<\/span>\n        \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n        protected<\/span> override<\/span> void<\/span> RegisterInputParams<\/span>(<\/span>GH_Component<\/span>.<\/span>GH_InputParamManager<\/span> pManager<\/span>)<\/span>\n        {<\/span>\n            \/\/----------------------------------------------<\/span>\n            \/\/------------- your code ----------------------<\/span>\n            \/\/---------------------------------------------- <\/span>\n \n        }<\/span>\n \n        \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n        \/\/\/<\/span> Registers all the output parameters for this component.<\/span>\n        \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n        protected<\/span> override<\/span> void<\/span> RegisterOutputParams<\/span>(<\/span>GH_Component<\/span>.<\/span>GH_OutputParamManager<\/span> pManager<\/span>)<\/span>\n        {<\/span>\n            \/\/----------------------------------------------<\/span>\n            \/\/------------- your code ----------------------<\/span>\n            \/\/----------------------------------------------<\/span>\n        }<\/span>\n \n        \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n        \/\/\/<\/span> This is the method that actually does the work.<\/span>\n        \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n        \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>DA<\/span>\"<\/span>><\/span>The DA object can be used to retrieve data from input parameters and <\/span>\n        \/\/\/<\/span> to store data in output parameters.<\/span><\/<\/span>param<\/span>><\/span>\n        protected<\/span> override<\/span> void<\/span> SolveInstance<\/span>(<\/span>IGH_DataAccess<\/span> DA<\/span>)<\/span>\n        {<\/span>\n \n            \/\/ check if the task is running then ignore the update<\/span>\n            if<\/span> (<\/span>taskIsRunning<\/span>)<\/span>\n                return<\/span>;<\/span>\n \n            if<\/span> (<\/span>taskIsCompleted<\/span>)<\/span>\n            {<\/span>\n \n                \/\/task is just completed we can update the solution !<\/span>\n \n                \/\/------------------------<\/span>\n                \/\/set the output data here<\/span>\n                \/\/------------------------<\/span>\n                \/\/ for the next call make sure we set the flag off again<\/span>\n                taskIsCompleted<\/span> =<\/span> false<\/span>;<\/span>\n                \/\/ dispose the cancellationtoken<\/span>\n                cts<\/span>.<\/span>Dispose<\/span>();<\/span>\n            }<\/span>\n            else<\/span>\n            {<\/span>\n                \/\/ the taskIsCompleted flag is not true therefore we can start new task !<\/span>\n                \/\/-------------------------------- cancellation -------------------------<\/span>\n                \/\/ you may allow user to cancel the operation by any means <\/span>\n                \/\/ simply call cts.Cancel();<\/span>\n                cts<\/span> =<\/span> new<\/span> CancellationTokenSource<\/span>();<\/span> \n                \/\/----------------------------------------------------------------------<\/span>\n \n                \/\/-------------------------------- run asynched programm----------------<\/span>\n                _myProgramm<\/span> =<\/span> new<\/span> AsynchronousProgram<\/span>();<\/span>\n                _myProgramm<\/span>.<\/span>AllTasksAreComplete<\/span> +=<\/span> _myProgramm_AllTasksAreComplete<\/span>;<\/span>\n                _myProgramm<\/span>.<\/span>OneTaskComplete<\/span> +=<\/span> _myProgramm_OneTaskComplete<\/span>;<\/span>\n                \/\/ set the flag so we don't call RunAsynchProgram twice<\/span>\n                taskIsRunning<\/span> =<\/span> true<\/span>;<\/span>\n                _myProgramm<\/span>.<\/span>RunAsynchProgram<\/span>(<\/span>cts<\/span>.<\/span>Token<\/span>);<\/span>\n                \/\/----------------------------------------------------------------------<\/span>\n            }<\/span>\n        }<\/span>\n \n        private<\/span> void<\/span> _myProgramm_OneTaskComplete<\/span>(<\/span>object<\/span> sender<\/span>,<\/span> AsyncTaskCompleteArgs<\/span> e<\/span>)<\/span>\n        {<\/span>\n            \/\/ one taks was completed.<\/span>\n            \/\/ you can report the progress \/ update preview \/ etc....<\/span>\n            if<\/span> (<\/span>e<\/span>.<\/span>Error<\/span>==<\/span>null<\/span>)<\/span>\n            {<\/span>\n                \/\/report progress or update UI<\/span>\n            }<\/span>\n            else<\/span>\n            {<\/span>\n                \/\/ check for user cancellation or maange excpetions...<\/span>\n            }<\/span>\n \n        }<\/span>\n \n        private<\/span> void<\/span> _myProgramm_AllTasksAreComplete<\/span>(<\/span>object<\/span> sender<\/span>,<\/span> EventArgs<\/span> e<\/span>)<\/span>\n        {<\/span>\n            \/\/ all tasks are completed we set the flag and expire the solution<\/span>\n            taskIsCompleted<\/span> =<\/span> true<\/span>;<\/span>\n            taskIsRunning<\/span> =<\/span> false<\/span>;<\/span>\n            \/\/ expire the solution, this jupms back to SolveInstance() <\/span>\n            ExpireSolution<\/span>(<\/span>true<\/span>);<\/span>\n        }<\/span>\n        public<\/span> override<\/span> Guid<\/span> ComponentGuid<\/span>\n        {<\/span>\n            get<\/span> {<\/span> return<\/span> new<\/span> Guid<\/span>(<\/span>\"e2d943bd-d860-4f71-b0bd-a366d2200451\"<\/span>);<\/span> }<\/span>\n        }<\/span>\n        #endregion<\/span>\n \n    }<\/span><\/pre>\n
[\/et_pb_accordion_item][et_pb_accordion_item title=”Asynchronous Program” open=”off” _builder_version=”3.22.7″ title_text_shadow_horizontal_length=”0em” title_text_shadow_vertical_length=”0em” title_text_shadow_blur_strength=”0em” body_text_shadow_horizontal_length=”0em” body_text_shadow_vertical_length=”0em” body_text_shadow_blur_strength=”0em”]<\/p>\n
In this class we use AsyncOperationManager<\/strong> <\/em><\/a>to wrap our operation into an AsyncOperation<\/strong> <\/em><\/a>and then assign a call back to it. The call back will fire an event when the operation is completed or encountered an error. Using\u00a0 AsyncTaskCompleteArgs<\/strong> <\/em><\/a>class we wrap our data which we have got from the operation into an event argument and then raise an event which is then catch from grasshopper plugin. Note that event is raised after completion of each task, therefore you must find a way to know when all tasks are completed , in this example I assume we know the total number of tasks and hence when we count the number of call backs and if it reaches the total number of task we raise our\u00a0\u00a0AllTasksAreComplete <\/strong>event which expires the grasshopper solution. You can also report the progress or update the grasshopper UI while listening to the\u00a0OneTaskComplete<\/strong> event from GH component<\/p>\n
[\/et_pb_accordion_item][et_pb_accordion_item title=”CODE” open=”off” _builder_version=”3.22.7″ title_text_shadow_horizontal_length=”0em” title_text_shadow_vertical_length=”0em” title_text_shadow_blur_strength=”0em” body_text_shadow_horizontal_length=”0em” body_text_shadow_vertical_length=”0em” body_text_shadow_blur_strength=”0em” background_color=”#eeeeee”]<\/p>\n
 \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n \/\/\/<\/span> this is an example of Async programming in DotNet<\/span>\n \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n public<\/span> class<\/span> AsynchronousProgram<\/span>\n {<\/span>\n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> call back to raise the <\/span><<\/span>c<\/span>><\/span>RowComplete<\/span><\/<\/span>c<\/span>><\/span> event<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     private<\/span> SendOrPostCallback<\/span> taskCompletedCallBack<\/span>;<\/span>\n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> somehow record the number of tasks you need to run. if that's not possible<\/span>\n     \/\/\/<\/span> then you may need to find a way to know if all tasks are completed.<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     int<\/span> numberOFTasks<\/span> ;<\/span>\n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> number of tasks which are completed.<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     int<\/span> completedTasks<\/span> =<\/span> 0<\/span>;<\/span>\n \n     #region<\/span> constructor<\/span>\n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> construct the graph , note you must call <\/span><<\/span>c<\/span>><\/span> ComputeGraphAsynch()<\/span><\/<\/span>c<\/span>><\/span> to calculate the Data<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     public<\/span> AsynchronousProgram<\/span>()<\/span>\n     {<\/span>\n         \/\/-------------------------------------<\/span>\n         \/\/---------------your code-------------<\/span>\n         \/\/-------------------------------------<\/span>\n \n         \/\/ create an instance of the callback, this callback fires the event for task completion<\/span>\n         taskCompletedCallBack<\/span> =<\/span> new<\/span> SendOrPostCallback<\/span>(<\/span>TaskCompleted<\/span>);<\/span>\n     }<\/span>\n \n     #endregion<\/span>\n \n \n     #region<\/span> Events and Delegates<\/span>\n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> raises when computation of a taks is completed<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     public<\/span> event<\/span> EventHandler<\/span><<\/span>AsyncTaskCompleteArgs<\/span>><\/span> OneTaskComplete<\/span>;<\/span>\n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> raises when computation of all tasks are completed<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     public<\/span> event<\/span> EventHandler<\/span><<\/span>EventArgs<\/span>><\/span> AllTasksAreComplete<\/span>;<\/span>\n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> a delegate which holds necessar data to compute a task<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>asyncOperation<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>state<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>cts<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     private<\/span> delegate<\/span> void<\/span> TaskCallBack<\/span>(<\/span>AsyncOperation<\/span> asyncOperation<\/span>,<\/span> int<\/span> state<\/span>,<\/span> CancellationToken<\/span> cts<\/span>);<\/span>\n     #endregion<\/span>\n \n     #region<\/span> implementatio of asycnh operations<\/span>\n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> the main method you need to call from UI thread (grasshopper plug-in)<\/span>\n     \/\/\/<\/span> listen to the methods <\/span><<\/span>c<\/span>><\/span>OneTaskComplete<\/span><\/<\/span>c<\/span>><\/span> and <\/span><<\/span>c<\/span>><\/span>AllTasksAreComplete<\/span><\/<\/span>c<\/span>><\/span> for completion<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>kuka<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>singularityCheck<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>cts<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     public<\/span> void<\/span> RunAsynchProgram<\/span>(<\/span>CancellationToken<\/span> cts<\/span>)<\/span>\n     {<\/span>\n         \/\/you may create multiple operation using a loop or recursion or ant other ways of iteration<\/span>\n         \/\/just make sure each operation has a unique id (state) 
         \/\/here I am just usig the iterator for simplicity             <\/span>\n\n         for<\/span>(<\/span>int<\/span> i<\/span>=<\/span>0<\/span>;<\/span>i<\/span><<\/span> numberOFTasks<\/span>;<\/span>i<\/span>++<\/span>)<\/span>\n         {<\/span> \n             \/\/ create an asynch operation <\/span>\n             AsyncOperation<\/span> asyncOperation<\/span> =<\/span> AsyncOperationManager<\/span>.<\/span>CreateOperation<\/span>(<\/span>i<\/span>);<\/span>\n             \/\/ build a call back <\/span>\n             TaskCallBack<\/span> myCallBack<\/span> =<\/span> new<\/span> TaskCallBack<\/span>(<\/span>computeTaskAsynch<\/span>);<\/span>\n             \/\/ enque the task using invoke. The call back will call the operation on the first possible <\/span>\n             \/\/thread and await its completion. when the tast is completed the OnTaskComplete() method<\/span>\n             \/\/gets called and an event is fired <\/span>\n             myCallBack<\/span>.<\/span>BeginInvoke<\/span>(<\/span>asyncOperation<\/span>,<\/span> i<\/span>,<\/span> cts<\/span>,<\/span> null<\/span>,<\/span> null<\/span>);<\/span>\n \n         }<\/span>\n \n     }<\/span>\n \n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> this method is used for call back only !<\/span>\n     \/\/\/<\/span> compute a single task (given state is the index of the row to be computed)<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>        <\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>asyncOperation<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>state<\/span>\"<\/span>><\/span>the index of the row in the graph (used also as Id for the action)<\/span><\/<\/span>param<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>token<\/span>\"<\/span>><\/span>The cancellation token from the UI thread<\/span><\/<\/span>param<\/span>><\/span>\n     void<\/span> computeTaskAsynch<\/span>(<\/span> AsyncOperation<\/span> asyncOperation<\/span>,<\/span> int<\/span> state<\/span>,<\/span> CancellationToken<\/span> token<\/span>)<\/span>\n     {<\/span>\n \n         AsyncTaskCompleteArgs<\/span> e<\/span>;<\/span>\n \n         try<\/span>\n         {<\/span>                \n             \/\/ do your stuff <\/span>\n             var<\/span> data<\/span> =<\/span> DoSomething<\/span>(<\/span>state<\/span>,<\/span>token<\/span>);<\/span>\n             \/\/ build the event argument <\/span>\n             e<\/span> =<\/span> new<\/span> AsyncTaskCompleteArgs<\/span>(<\/span>null<\/span>,<\/span> false<\/span>,<\/span> state<\/span>,<\/span> data<\/span>);<\/span>\n         }<\/span>\n         catch<\/span> (<\/span>Exception<\/span> exception<\/span>)<\/span>\n         {<\/span>\n             \/\/ user may cancel the operation or an exception may be thrown <\/span>\n             e<\/span> =<\/span> new<\/span> AsyncTaskCompleteArgs<\/span>(<\/span>exception<\/span>,<\/span> false<\/span>,<\/span> state<\/span>,<\/span> null<\/span>);<\/span>\n \n         }<\/span>\n         \/\/ post the operation and wait for the completion event(s)<\/span>\n         asyncOperation<\/span>.<\/span>PostOperationCompleted<\/span>(<\/span>taskCompletedCallBack<\/span>,<\/span> e<\/span>);<\/span>\n     }<\/span>\n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> do the actual work<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>taksId<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     private<\/span> object<\/span> DoSomething<\/span>(<\/span>int<\/span> taksId<\/span>,<\/span> CancellationToken<\/span> token<\/span>)<\/span>\n     {<\/span>\n         \/\/ check for uer interruption <\/span>\n         token<\/span>.<\/span>ThrowIfCancellationRequested<\/span>();<\/span>\n         \/\/----------------------<\/span>\n         \/\/------your code-------<\/span>\n         \/\/----------------------<\/span>\n         \n         return<\/span> null<\/span>;<\/span> \/\/ you can return something and pass it via event argument<\/span>\n     }<\/span>\n \n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> raise the RowComplete event, and if all rows are completed then raises the GraphComplete event<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>e<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     void<\/span> OnTaskComplete<\/span>(<\/span>AsyncTaskCompleteArgs<\/span> e<\/span>)<\/span>\n     {<\/span>\n         \/\/ inrement the number of tasks which are completed .<\/span>\n         completedTasks<\/span>++<\/span>;<\/span>\n         \/\/ in case of the error see if the user has canclled <\/span>\n         if<\/span> (<\/span>e<\/span>.<\/span>Error<\/span> !=<\/span> null<\/span>)<\/span>\n         {<\/span>\n             \/\/----------------------<\/span>\n             \/\/------your code-------<\/span>\n             \/\/----------------------<\/span>\n         }<\/span>\n         else<\/span>\n         {<\/span>\n             \/\/----------------------<\/span>\n             \/\/------your code-------<\/span>\n             \/\/----------------------<\/span>\n             \n         }<\/span>\n         \/\/ raise the event for a single task completion<\/span>\n         OneTaskComplete<\/span>?.<\/span>Invoke<\/span>(<\/span>this<\/span>,<\/span> e<\/span>);<\/span>\n         \/\/ if all tasks are completed then raise the AllTasksAreComplete event<\/span>\n         if<\/span> (<\/span>completedTasks<\/span> ==<\/span> numberOFTasks<\/span>)<\/span>\n             AllTasksAreComplete<\/span>?.<\/span>Invoke<\/span>(<\/span>this<\/span>,<\/span> new<\/span> EventArgs<\/span>());<\/span>\n     }<\/span>\n \n     \/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> calls the function <\/span><<\/span>c<\/span>><\/span>OnRowComplete()<\/span><\/<\/span>c<\/span>><\/span> from the call back<\/span>\n     \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n     \/\/\/<\/span> <\/span><<\/span>param<\/span> name<\/span>=<\/span>\"<\/span>state<\/span>\"<\/span>><\/<\/span>param<\/span>><\/span>\n     void<\/span> TaskCompleted<\/span>(<\/span>object<\/span> state<\/span>)<\/span>\n     {<\/span>\n         OnTaskComplete<\/span>((<\/span>AsyncTaskCompleteArgs<\/span>)<\/span>state<\/span>);<\/span>\n     }<\/span>\n     #endregion<\/span>\n \n }<\/span>\n<\/pre>\n
[\/et_pb_accordion_item][et_pb_accordion_item title=”Async Event” open=”off” _builder_version=”3.22.7″ title_text_shadow_horizontal_length=”0em” title_text_shadow_vertical_length=”0em” title_text_shadow_blur_strength=”0em” body_text_shadow_horizontal_length=”0em” body_text_shadow_vertical_length=”0em” body_text_shadow_blur_strength=”0em”]<\/p>\n
 <\/p>\n
[\/et_pb_accordion_item][et_pb_accordion_item title=”CODE” open=”on” _builder_version=”3.22.7″ title_text_shadow_horizontal_length=”0em” title_text_shadow_vertical_length=”0em” title_text_shadow_blur_strength=”0em” body_text_shadow_horizontal_length=”0em” body_text_shadow_vertical_length=”0em” body_text_shadow_blur_strength=”0em” background_color=”#eeeeee”]<\/p>\n
\/\/\/<\/span> <\/span><<\/span>summary<\/span>><\/span>\n    \/\/\/<\/span> implement <\/span><<\/span>c<\/span>><\/span>AsyncCompletedEventArgs<\/span><\/<\/span>c<\/span>><\/span> class <\/span>\n    \/\/\/<\/span> <\/span><\/<\/span>summary<\/span>><\/span>\n    public<\/span> class<\/span> AsyncTaskCompleteArgs<\/span> :<\/span> AsyncCompletedEventArgs<\/span>\n    {<\/span>\n        \/\/----------------------------------------------<\/span>\n        \/\/------------- your internal data--------------<\/span>\n        \/\/----------------------------------------------<\/span>\n        \/\/ data to be transgered by event argument<\/span>\n        public<\/span> object<\/span> Data<\/span> {<\/span> get<\/span>;<\/span> private<\/span> set<\/span>;<\/span> }<\/span>\n        public<\/span> AsyncTaskCompleteArgs<\/span>(<\/span>Exception<\/span> exception<\/span>,<\/span> bool<\/span> cancelled<\/span>,<\/span> int<\/span> userState<\/span>,<\/span> object<\/span> mydata<\/span>)<\/span> 
       :<\/span> base<\/span>(<\/span>exception<\/span>,<\/span> cancelled<\/span>,<\/span> userState<\/span>)<\/span>\n        {<\/span>\n            Data<\/span> =<\/span> mydata<\/span>;<\/span>\n        }<\/span>\n    }<\/span><\/pre>\n
[\/et_pb_accordion_item][\/et_pb_accordion][et_pb_code _builder_version=”3.22.7″][\/et_pb_code][\/et_pb_column][\/et_pb_row][\/et_pb_section]<\/p>\n","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"on","_et_pb_old_content":"","_et_gb_content_width":""},"categories":[64],"tags":[],"yoast_head":"\nGrasshopper plugin & Event based asynchronous programming in C# - Parametric Zoo<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Grasshopper plugin & Event based asynchronous programming in C# - Parametric Zoo\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/\" \/>\n<meta property=\"og:site_name\" content=\"Parametric Zoo\" \/>\n<meta property=\"article:published_time\" content=\"2021-07-28T20:35:18+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-07-28T21:36:03+00:00\" \/>\n<meta name=\"author\" content=\"PARA\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"PARA\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.parametriczoo.com\/#website\",\"url\":\"https:\/\/www.parametriczoo.com\/\",\"name\":\"Parametric Zoo\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.parametriczoo.com\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/\",\"url\":\"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/\",\"name\":\"Grasshopper plugin & Event based asynchronous programming in C# - Parametric Zoo\",\"isPartOf\":{\"@id\":\"https:\/\/www.parametriczoo.com\/#website\"},\"datePublished\":\"2021-07-28T20:35:18+00:00\",\"dateModified\":\"2021-07-28T21:36:03+00:00\",\"author\":{\"@id\":\"https:\/\/www.parametriczoo.com\/#\/schema\/person\/0368c6eb8bfe3a003504793be2a2e0e3\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.parametriczoo.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Grasshopper plugin & Event based asynchronous programming in C#\"}]},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.parametriczoo.com\/#\/schema\/person\/0368c6eb8bfe3a003504793be2a2e0e3\",\"name\":\"PARA\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.parametriczoo.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/2b2ff0ff40493545df12d0b31a504675?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/2b2ff0ff40493545df12d0b31a504675?s=96&d=mm&r=g\",\"caption\":\"PARA\"},\"url\":\"https:\/\/www.parametriczoo.com\/index.php\/author\/para\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Grasshopper plugin & Event based asynchronous programming in C# - Parametric Zoo","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/","og_locale":"en_US","og_type":"article","og_title":"Grasshopper plugin & Event based asynchronous programming in C# - Parametric Zoo","og_url":"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/","og_site_name":"Parametric Zoo","article_published_time":"2021-07-28T20:35:18+00:00","article_modified_time":"2021-07-28T21:36:03+00:00","author":"PARA","twitter_card":"summary_large_image","twitter_misc":{"Written by":"PARA"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebSite","@id":"https:\/\/www.parametriczoo.com\/#website","url":"https:\/\/www.parametriczoo.com\/","name":"Parametric Zoo","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.parametriczoo.com\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/","url":"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/","name":"Grasshopper plugin & Event based asynchronous programming in C# - Parametric Zoo","isPartOf":{"@id":"https:\/\/www.parametriczoo.com\/#website"},"datePublished":"2021-07-28T20:35:18+00:00","dateModified":"2021-07-28T21:36:03+00:00","author":{"@id":"https:\/\/www.parametriczoo.com\/#\/schema\/person\/0368c6eb8bfe3a003504793be2a2e0e3"},"breadcrumb":{"@id":"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.parametriczoo.com\/index.php\/2021\/07\/28\/grasshopper-plugin-event-based-asynchronous-programming-in-c\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.parametriczoo.com\/"},{"@type":"ListItem","position":2,"name":"Grasshopper plugin & Event based asynchronous programming in C#"}]},{"@type":"Person","@id":"https:\/\/www.parametriczoo.com\/#\/schema\/person\/0368c6eb8bfe3a003504793be2a2e0e3","name":"PARA","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.parametriczoo.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/2b2ff0ff40493545df12d0b31a504675?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/2b2ff0ff40493545df12d0b31a504675?s=96&d=mm&r=g","caption":"PARA"},"url":"https:\/\/www.parametriczoo.com\/index.php\/author\/para\/"}]}},"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/www.parametriczoo.com\/index.php\/wp-json\/wp\/v2\/posts\/1096"}],"collection":[{"href":"https:\/\/www.parametriczoo.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.parametriczoo.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.parametriczoo.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.parametriczoo.com\/index.php\/wp-json\/wp\/v2\/comments?post=1096"}],"version-history":[{"count":0,"href":"https:\/\/www.parametriczoo.com\/index.php\/wp-json\/wp\/v2\/posts\/1096\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.parametriczoo.com\/index.php\/wp-json\/wp\/v2\/media?parent=1096"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.parametriczoo.com\/index.php\/wp-json\/wp\/v2\/categories?post=1096"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.parametriczoo.com\/index.php\/wp-json\/wp\/v2\/tags?post=1096"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
Lastly you need to implement the\u00a0AsyncCompletedEventArgs<\/strong> <\/em><\/a>class whihc is used to transfer data by an async event. Simply pack your data and (instead of the object argument in template code) and you can read it from Grasshopper component. It is always uesfull to send data about the particular task which is completed as well as the number of completed tasks in case you want to display some progress.<\/p>\n