public static void Run()
        {
            // ExStart:AddChildBookmark
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_AsposePdfFacades_Bookmarks();
            // Create bookmarks
            Aspose.Pdf.Facades.Bookmarks bookmarks = new Aspose.Pdf.Facades.Bookmarks();
            Bookmark childBookmark1 = new Bookmark();
            childBookmark1.PageNumber = 1;
            childBookmark1.Title = "First Child";
            Bookmark childBookmark2 = new Bookmark();
            childBookmark2.PageNumber = 2;
            childBookmark2.Title = "Second Child";

            bookmarks.Add(childBookmark1);
            bookmarks.Add(childBookmark2);

            Bookmark bookmark = new Bookmark();
            bookmark.Action = "GoTo";
            bookmark.PageNumber = 1;
            bookmark.Title = "Parent";

            bookmark.ChildItems = bookmarks;

            // Create PdfBookmarkEditor class
            PdfBookmarkEditor bookmarkEditor = new PdfBookmarkEditor();
            // Bind PDF document
            bookmarkEditor.BindPdf(dataDir+ "AddChildBookmark.pdf");
            // Create bookmarks
            bookmarkEditor.CreateBookmarks(bookmark);
            // Save updated document
            bookmarkEditor.Save(dataDir+ "AddChildBookmark_out.pdf");
            // ExEnd:AddChildBookmark
        }

        public void Add(string title, string url, string description, string snapshotBase64String, IEnumerable<Tag> tags, Website website, string userId)
        {
            var bookmark = new Bookmark
            {
                Description = description,
                UserId = userId,
                Title = title,
                Url = url,
                SnapshotBase64String = snapshotBase64String

            };

            //check for existing website
            var existingWebsite = websiteService.GetWebsiteByName(website.Name, userId).FirstOrDefault();
            if (existingWebsite != null)
            {
                bookmark.WebSite = existingWebsite;
            }
            else
            {
                var websiteToAdd = new Website
                {
                    Name = website.Name,
                    FaviconBase64String = website.FaviconBase64String
                };

                bookmark.WebSite = website;
            }

            AddTags(bookmark, tags, userId);

            this.bookmarks.Add(bookmark);
            this.bookmarks.SaveChanges();
        }

        private void Continue(NativeActivityContext context, Bookmark bookmark, object obj)
        {
            var args = (object[])obj;
            var userID = (int)args[0];
            UserID.Set(context, userID);

            var result = 0;
            var id = ID.Get(context);
            var item = ProjectProcessService.GetById(id);
            ProjectProcessService.LoadReference(item, i => i.Owner);
            var appraisalResult = ProjectProcessService.GetAppraisalResult(item);
            var userCount = UserService.Count();

            if (appraisalResult.Item1 + appraisalResult.Item2 < userCount * 0.8)//投票人数未达到所有人的 80%
            {
                result = 0;
            }
            else
            {
                if (appraisalResult.Item1 > appraisalResult.Item2 * 2)//同意的人数大于不同意人数的两倍
                {
                    result = 1;
                    InboxService.Create(UserRoleEnum.全员, item.ID, RedirectType.项目流程查看, InboxService.APPRAISAL_FINISH_PROCESS_PROJECT, item.ID.ToString(), appraisalResult.Item1.ToString(), appraisalResult.Item2.ToString(), "通过", item.Owner.NickName);
                    InboxService.Create(UserRoleEnum.运营组成员, item.ID, RedirectType.项目流程处理, InboxService.DESIGN_PROCESS_PROJECT, item.ID.ToString(), item.Owner.NickName);
                }
                else
                {
                    result = -1;
                    InboxService.Create(UserRoleEnum.全员, item.ID, RedirectType.项目流程查看, InboxService.APPRAISAL_FINISH_PROCESS_PROJECT, item.ID.ToString(), appraisalResult.Item1.ToString(), appraisalResult.Item2.ToString(), "不通过", item.Owner.NickName);
                }
            }
            Rusult.Set(context, result);
        }

 protected override void OnCancelTimer(Bookmark bookmark)
 {
     lock (this.ThisLock)
     {
         this.RegisteredTimers.RemoveTimer(bookmark);
     }
 }

 // Constructor
 public ExprNodeAssignment(Bookmark bookmark, ExprNode lhs, ExprNode rhs, Token op)
     : base(bookmark)
 {
     Lhs = lhs;
     Rhs = rhs;
     Op = op;
 }

    public static void AddBookmark(string username, string title, string url, string[] tags, string notes)
    {
        //Console.WriteLine("{0} {1} {2} {3} {4}", username, title, url, string.Join(", ", tags), notes);

        BookmarksEntities context = new BookmarksEntities();

        Bookmark newBookmark = new Bookmark();
        newBookmark.User = CreateOrLoadUser(context, username);
        newBookmark.Title = title;
        newBookmark.URL = url;
        newBookmark.Notes = notes;

        foreach (var tagName in tags)
        {
            Tag tag = CreateOrLoadTag(context, tagName);
            newBookmark.Tags.Add(tag);
        }

        //dopulnitelnite tagotve------------------------
        //string[] titleTags = Regex.Split(title, @"\W+");
        string[] titleTags = Regex.Split(title, @"[,'!\. ;?-]+");
        foreach (var titleTagName in titleTags)
        {
            Tag titleTag = CreateOrLoadTag(context, titleTagName);
            newBookmark.Tags.Add(titleTag);
        }
        //dopulnitelnite tagotve-----------------------

        context.Bookmarks.Add(newBookmark);
        context.SaveChanges();
    }

 // This ctor is only used by subclasses which make their own determination about no persist or not
 protected BookmarkWorkItem(BookmarkCallbackWrapper callbackWrapper, Bookmark bookmark, object value)
     : base(callbackWrapper.ActivityInstance)
 {
     this.callbackWrapper = callbackWrapper;
     this.bookmark = bookmark;
     this.state = value;
 }

        public static void Main()
        {
            // The path to the documents directory.
            string dataDir = Path.GetFullPath("../../../Data/");
            //create bookmarks
            Bookmarks bookmarks = new Bookmarks();
            Bookmark childBookmark1 = new Bookmark();
            childBookmark1.PageNumber = 1;
            childBookmark1.Title = "First Child";
            Bookmark childBookmark2 = new Bookmark();
            childBookmark2.PageNumber = 2;
            childBookmark2.Title = "Second Child";

            bookmarks.Add(childBookmark1);
            bookmarks.Add(childBookmark2);

            Bookmark bookmark = new Bookmark();
            bookmark.Action = "GoTo";
            bookmark.PageNumber = 1;
            bookmark.Title = "Parent";

            bookmark.ChildItems = bookmarks;

            //create PdfBookmarkEditor class
            PdfBookmarkEditor bookmarkEditor = new PdfBookmarkEditor();
            //bind PDF document
            bookmarkEditor.BindPdf(dataDir+ "input.pdf");
            //create bookmarks
            bookmarkEditor.CreateBookmarks(bookmark);
            //save updated document
            bookmarkEditor.Save(dataDir+ "output.pdf");
        }

        private void OnBookmarkCallback(NativeActivityContext context, Bookmark bookmark)
        {
            var log = context.Resolve<ILoggerFactory>() != null
                    ? context.Resolve<ILoggerFactory>().Create(typeof(SubProcess))
                    : null;
            var parser = context.Resolve<IScriptParser>();
            var extension = context.GetExtension<DataFieldExtension>();

            //完成规则解析
            if (this.Result != null
                && parser != null
                && this.FinishRule != null
                && this.FinishRule.Count > 0)
            {
                foreach (var i in this.FinishRule)
                    if (parser.EvaluateRule(i.Value, extension))
                    {
                        this.Result.Set(context, i.Key);
                        if (log != null)
                            log.InfoFormat("SubProcess节点完成规则“{0}”测试通过，将进入节点“{1}”", i.Value, i.Key);
                        break;
                    }
            }
            //所有逻辑完成才可删除，若上述逻辑失败则将此书签用于错误恢复
            context.RemoveBookmark(bookmark);
        }

        /// <summary>
        /// Copies content of the bookmark and adds it to the end of the specified node.
        /// The destination node can be in a different document.
        /// </summary>
        /// <param name="importer">Maintains the import context </param>
        /// <param name="srcBookmark">The input bookmark</param>
        /// <param name="dstNode">Must be a node that can contain paragraphs (such as a Story).</param>
        private static void AppendBookmarkedText(NodeImporter importer, Bookmark srcBookmark, CompositeNode dstNode)
        {
            // This is the paragraph that contains the beginning of the bookmark.
            Paragraph startPara = (Paragraph)srcBookmark.BookmarkStart.ParentNode;

            // This is the paragraph that contains the end of the bookmark.
            Paragraph endPara = (Paragraph)srcBookmark.BookmarkEnd.ParentNode;

            if ((startPara == null) || (endPara == null))
                throw new InvalidOperationException("Parent of the bookmark start or end is not a paragraph, cannot handle this scenario yet.");

            // Limit ourselves to a reasonably simple scenario.
            if (startPara.ParentNode != endPara.ParentNode)
                throw new InvalidOperationException("Start and end paragraphs have different parents, cannot handle this scenario yet.");

            // We want to copy all paragraphs from the start paragraph up to (and including) the end paragraph,
            // therefore the node at which we stop is one after the end paragraph.
            Node endNode = endPara.NextSibling;

            // This is the loop to go through all paragraph-level nodes in the bookmark.
            for (Node curNode = startPara; curNode != endNode; curNode = curNode.NextSibling)
            {
                // This creates a copy of the current node and imports it (makes it valid) in the context
                // of the destination document. Importing means adjusting styles and list identifiers correctly.
                Node newNode = importer.ImportNode(curNode, true);

                // Now we simply append the new node to the destination.
                dstNode.AppendChild(newNode);
            }
        }

        public static void AddBookmarks(string username, string title, string url, string[] tags, string notes)
        {
            var dbCon = new BookmarksEntities();

            using (dbCon)
            {
                var bookmark = new Bookmark();
                bookmark.Notes = notes;
                bookmark.URL = url;
                bookmark.Title = title;

                bookmark.User = CreateOrLoadUser(dbCon, username);

                foreach (var tagName in tags)
                {
                    var tag = CreateOrLoadTag(dbCon, tagName);

                    bookmark.Tags.Add(tag);
                }

                var titleTags = Regex.Split(title, @"[ ,-\.;!?]+");

                foreach (var titleTag in titleTags)
                {
                    var tag = CreateOrLoadTag(dbCon, titleTag);

                    bookmark.Tags.Add(tag);
                }

                dbCon.Bookmarks.Add(bookmark);
                dbCon.SaveChanges();
            }
        }

        private bool MatchProgram(Bookmark bookmark, FuzzyMatcher matcher)
        {
            if ((bookmark.Score = matcher.Evaluate(bookmark.Name).Score) > 0) return true;
            if ((bookmark.Score = matcher.Evaluate(bookmark.PinyinName).Score) > 0) return true;
            if ((bookmark.Score = matcher.Evaluate(bookmark.Url).Score / 10) > 0) return true;

            return false;
        }

        void Continue(NativeActivityContext context, Bookmark bookmark, object obj)
        {
            var eventArgs = obj as WorkflowNotificationEventArgs;
            if (eventArgs.NotificationType != WorkflowNotificationObserver.CONTENTCHANGEDNOTIFICATIONTYPE)
                return;

            InstanceManager.ReleaseWait(notificationId.Get(context));
        }

 public static Bookmark CreateBookmark(int bookmarkId, int userId, int ordinal)
 {
     Bookmark bookmark = new Bookmark();
     bookmark.BookmarkId = bookmarkId;
     bookmark.UserId = userId;
     bookmark.Ordinal = ordinal;
     return bookmark;
 }

 // Add another variable declaration
 public void AddDeclaration(Bookmark bookmark, string Name, ast.Expression InitialValue)
 {
     var v = new Variable();
     v.Bookmark = bookmark;
     v.Name = Name;
     v.InitialValue = InitialValue;
     Variables.Add(v);
 }

 /// <summary>
 /// 添加子流程启动信息
 /// </summary>
 /// <param name="context"></param>
 /// <param name="referredBookmark"></param>
 /// <param name="activityName"></param>
 /// <param name="flowNodeIndex"></param>
 public void AddSubProcess(NativeActivityContext context, Bookmark referredBookmark, string activityName, int flowNodeIndex)
 {
     this._instances.Add(new SubProcessActivityInstance(context.WorkflowInstanceId
         , flowNodeIndex
         , context.ActivityInstanceId
         , activityName
         , referredBookmark.Name));
 }

 /// <summary>
 /// Gets a specific article from a bookmark based on its href.
 /// </summary>
 /// <param name="bookmark">The bookmark that has the article to be returned.</param>
 /// <returns>The full article as a string. This is useful for immediately saving it.</returns>
 public async Task<Article> GetArticle(Bookmark bookmark)
 {
     var request = new RestRequest(bookmark.ArticleHref.Replace("/api/rest/v1", ""));
     var content = await ReadabilityClient.MakeRequestAsync(request).ConfigureAwait(false);
     var js = new StringReader(content);
     var jr = new JsonTextReader(js);
     var serializer = new JsonSerializer();
     return serializer.Deserialize<Article>(jr);
 }

        private void Initialize()
        {
            // Create new map with a base map
            Map myMap = new Map(Basemap.CreateImageryWithLabels());

            // Set the map view, map property to the base map
            MyMapView.Map = myMap;

            // Create a set of predefined bookmarks; each one follows the pattern of:
            // ~ Initialize a viewpoint pointing to a latitude longitude
            // ~ Create a new bookmark
            // ~ Give the bookmark a name
            // ~ Assign the viewpoint
            // ~ Add the bookmark to bookmark collection of the map
            // ~ Add the bookmark to the UI combo box for the user to choose from 

            // Bookmark-1
            Viewpoint myViewpoint1 = new Viewpoint(27.3805833, 33.6321389, 6000);
            Bookmark myBookmark1 = new Bookmark();
            myBookmark1.Name = "Mysterious Desert Pattern";
            myBookmark1.Viewpoint = myViewpoint1;
            MyMapView.Map.Bookmarks.Add(myBookmark1);
            bookmarkChooser.Items.Add(myBookmark1);

            // Bookmark-2
            Viewpoint myViewpoint2 = new Viewpoint(37.401573, -116.867808, 6000);
            Bookmark myBookmark2 = new Bookmark();
            myBookmark2.Name = "Strange Symbol";
            myBookmark2.Viewpoint = myViewpoint2;
            MyMapView.Map.Bookmarks.Add(myBookmark2);
            bookmarkChooser.Items.Add(myBookmark2);

            // Bookmark-3
            Viewpoint myViewpoint3 = new Viewpoint(-33.867886, -63.985, 40000);
            Bookmark myBookmark3 = new Bookmark();
            myBookmark3.Name = "Guitar-Shaped Forest";
            myBookmark3.Viewpoint = myViewpoint3;
            MyMapView.Map.Bookmarks.Add(myBookmark3);
            bookmarkChooser.Items.Add(myBookmark3);

            // Bookmark-4
            Viewpoint myViewpoint4 = new Viewpoint(44.525049, -110.83819, 6000);
            Bookmark myBookmark4 = new Bookmark();
            myBookmark4.Name = "Grand Prismatic Spring";
            myBookmark4.Viewpoint = myViewpoint4;
            MyMapView.Map.Bookmarks.Add(myBookmark4);
            bookmarkChooser.Items.Add(myBookmark4);

            // Set the initial combo box selection to the lat bookmark added
            bookmarkChooser.SelectedItem = MyMapView.Map.Bookmarks.Last();

            // Zoom to the last bookmark
            myMap.InitialViewpoint = myMap.Bookmarks.Last().Viewpoint;

            // Hide the controls for adding an additional bookmark
            BorderAddBookmark.Visibility = Visibility.Collapsed;
        }

 internal void Initialize(FolderWatcherExtension extension, Bookmark bookmark, string folder, string pattern, bool subfolders, string subscriberDisplayName)
 {
     if (this.IsInitialized)
     {
         throw new InvalidOperationException(String.Format(
             Properties.Resources.SubscriptionHandleAlreadyInitialized, subscriberDisplayName));
     }
     this.Id = extension.Subscribe(bookmark, folder, pattern, subfolders);
 }

 /// <summary>
 /// Used to resume bookmark outside workflow.
 /// </summary>
 /// <param name="bookmark">The value of Bookmark to be resumed</param>
 public void ResumeBookmark(Bookmark bookmark)
 {
     // This method is necessary due to CSDMain 223257.
     IAsyncResult asyncResult = this.instance.BeginResumeBookmark(bookmark, null, Fx.ThunkCallback(new AsyncCallback(StateMachineExtension.OnResumeBookmarkCompleted)), this.instance);
     if (asyncResult.CompletedSynchronously)
     {
         this.instance.EndResumeBookmark(asyncResult);
     }
 }