protected override void BeforeDoWork(NativeActivityContext context)
        {
            var method = System.Reflection.MethodBase.GetCurrentMethod().Name;

            context.GetExtension <CompositionContainer>().SatisfyImportsOnce(this);

            _logger.Log(EventSeverity.Debug, method,
                        string.Format("[{0}] Processing RPSUid: [{1}], Bookmark name: [{2}], Extension Recorded Id:[{3}]",
                                      Thread.CurrentThread.ManagedThreadId,
                                      RPSUid.Get(context), BookmarkName, _processSpatialRegistrationObject.ConstructedBy));
        }
        protected override void OnBeforeCreateBookmark(NativeActivityContext context, out bool pCancelBookmarkCreation)
        {
            var method = System.Reflection.MethodBase.GetCurrentMethod().Name;

            pCancelBookmarkCreation = false;
            _logger.Log(EventSeverity.Debug, method,
                        string.Format("[{0}] Enter: Processing RPSUid: [{1}], Bookmark name: [{2}], Extension Recorded Id:[{3}]",
                                      Thread.CurrentThread.ManagedThreadId,
                                      RPSUid.Get(context), BookmarkName, _processSpatialRegistrationObject.ConstructedBy));

            var metadata = _processSpatialRegistrationObject.BuildMonitorMetadataForRPSData(RPSUid.Get(context));

            //
            // If the dataset we are planning to wait is already available
            // skip the bookmark creation and proceed to next activity.
            //
            if (_waitDataWrapper.IsDataAvailable(metadata))
            {
                pCancelBookmarkCreation = true;
                var dcmInstanceId = _processSpatialRegistrationObject.GetRPSDcmInstanceId(RPSUid.Get(context));
                OutRPSUnitId.Set(context, dcmInstanceId);

                _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] IsDataAvailable(): Processing RPSUid: [{1}], Bookmark name: [{2}], RPS  already available : Id [{3}]",
                                                                       Thread.CurrentThread.ManagedThreadId, RPSUid.Get(context), BookmarkName, dcmInstanceId));

                //if (!base._useQueryNotificationFor3DWorkflows)
                //{
                //    if (!String.IsNullOrEmpty(metadata.DataMonitoringEventId))
                //    {
                //        WaitEventManager.TryRemoveEvent(metadata.DataMonitoringEventId);
                //    }
                //}
            }
            else
            {
                BookmarkMetadata.Set(context, metadata.ToString());
                if (base._useQueryNotificationFor3DWorkflows)
                {
                    _waitDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
                                                         metadata, _waitHandlersRepository.Get("WorkQueueElement"));
                }
                else
                {
                    _waitDataWrapper.InitiateWaitForDataEvent(context.WorkflowInstanceId, BookmarkName,
                                                              metadata, _waitHandlersRepository.Get("WorkQueueElement"));
                }
            }

            _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing RPSUid: [{1}], Bookmark name: [{2}]",
                                                                   Thread.CurrentThread.ManagedThreadId, RPSUid.Get(context), BookmarkName));
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="context"></param>
        /// <param name="bookmark"></param>
        /// <param name="obj"></param>
        protected override void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark, string obj)
        {
            var method = System.Reflection.MethodBase.GetCurrentMethod().Name;

            Debug.Assert(bookmark.Name == BookmarkName);

            context.GetExtension <CompositionContainer>().SatisfyImportsOnce(this);
            _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Enter: Finished Processing RPSUid: [{1}], Bookmark name: [{2}]",
                                                                   Thread.CurrentThread.ManagedThreadId, RPSUid.Get(context), bookmark.Name));

            var dcmInstanceId = _processSpatialRegistrationObject.GetRPSDcmInstanceId(RPSUid.Get(context));

            OutRPSUnitId.Set(context, dcmInstanceId);

            _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Finished Processing RPSUid: [{1}], Bookmark name: [{2}]",
                                                                   Thread.CurrentThread.ManagedThreadId, RPSUid.Get(context), bookmark.Name));
        }
        protected override void OnAddToWorklist(NativeActivityContext context, Guid instanceId)
        {
            var method = System.Reflection.MethodBase.GetCurrentMethod().Name;

            _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Enter: Processing RPSUid: [{1}], Bookmark name: [{2}]",
                                                                   Thread.CurrentThread.ManagedThreadId, RPSUid.Get(context), BookmarkName));

            var    bookmarkManager = context.GetExtension <IQWorklistManager>();
            string bookmarkDesc    = BookmarkDesc.Get(context);

            bookmarkDesc = String.IsNullOrEmpty(bookmarkDesc) ? String.Empty : bookmarkDesc.Trim();
            bookmarkManager.AddWorklistItem(BookmarkName, IQBookmarkType.DBMonitor, bookmarkDesc, BookmarkMetadata.Get(context));

            _logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing RPSUid: [{1}], Context Bookmark name: [{2}]",
                                                                   Thread.CurrentThread.ManagedThreadId, RPSUid.Get(context), BookmarkName));
        }