Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

WorkItemTimerJobState - Classe

SharePoint 2013

Utilisé pour effectuer le suivi d'état pour chaque itération de traitement des éléments de travail.

System.Object
  Microsoft.Office.Server.Utilities.WorkItemTimerJobState

Espace de noms :  Microsoft.Office.Server.Utilities
Assembly :  Microsoft.Office.Server (dans Microsoft.Office.Server.dll)

public class WorkItemTimerJobState

Dérivez une classe à partir de cette classe pour prendre en charge le code en cours d'exécution sur les points où les sites et collections de sites sont modifiées lors du traitement d'éléments de travail dans un travail de minuteur qui est dérivé d'un objet SPWorkItemJobDefinition .

L'exemple de code suivant illustre un exemple de définition de tâche travail élément.

using System;
using System.Globalization;
using System.Threading;

using Microsoft.Office.Server.Utilities;

using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;


namespace Microsoft.SDK.SharePointServer.Samples
{
    /// <summary>
    /// This a sample work item timer job definition using TimerJobUtility
    /// </summary>
    /// <remarks>
    /// <para>
    /// This example shows the structure of a work item timer job and
    /// has comments for where you would add your code to perform specific
    /// tasks.
    /// </para>
    /// </remarks>
    public sealed class SampleWorkItemJobDefinition : SPWorkItemJobDefinition
    {
        // Replace with your job name.  Must be unique in the farm.
        private static string jobName = "AdventureWorksSampleWorkItemTimerJob";

        // Replace this with your own GUID
        private static Guid sampleWorkItemType = new Guid("3E445118-77B7-4917-A8E0-C4D729AC5805");

        /// <summary>
        /// Instance of the state class.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Keeps track of the state of the job across work items.
        /// </para>
        /// <para>
        /// This is instantiated and disposed within the Execute method since the instance
        /// of the SPWorkItemJobDefinition class can be reused by the timer job
        /// infrasturcture.
        /// </para>
        /// </remarks>
        private SampleWorkItemJobState timerJobState;

        /// <summary>
        /// This class keeps track of the state of the work item job.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Add properties to this class for any state you need kept.
        /// </para>
        /// </remarks>
        internal class SampleWorkItemJobState : WorkItemTimerJobState
        {
            // Set this to false if you do not require the WorkItemTimerJobState.Web
            // property to be fetched for each work item
            private static bool fetchWeb = true;

            // Set this to false if you do not require the WorkItemTimerJobState.User
            // property to be fetched for each work item
            private static bool fetchUser = true;

            /// <summary>
            /// Default constructor.
            /// </summary>
            public SampleWorkItemJobState()
                : base(SampleWorkItemJobState.fetchWeb, SampleWorkItemJobState.fetchUser)
            {
            }

            /// <summary>
            /// Called after changing the <see cref="Site" /> for next work item.
            /// </summary>
            /// <param name="wi"></param>
            protected override void OnSiteChanged(SPWorkItem workItem)
            {
                base.OnSiteChanged(workItem);

                // Add your code here if you need to update any state that is tied
                // to the SPSite of the work item
                // Similarly you can override OnSiteChanging to perform any per-SPSite
                // processing required before the SPSite is change.
                // Similarly you can override OnWebChanging/OnWebChanged for any state
                // or processing required on a per-SPWeb basis.
            }
        }

        /// <summary>
        /// Process one work item
        /// </summary>
        /// <param name="workItem">work item to process</param>
        /// <param name="timerJobState">job state</param>
        /// <remarks>
        /// <para>
        /// This method is called in the culture of timerJobState.Web
        /// </para>
        /// </remarks>
        private void ProcessWorkItemCore(SPWorkItem workItem, SampleWorkItemJobState timerJobState)
        {
            // Put your code here
        }


        /// <summary>
        /// Default constructor.  Only used for deserialization.
        /// </summary>
        public SampleWorkItemJobDefinition() : base()
        {
        }

        /// <summary>
        /// Public constructor.  Use this to register the job on a web application.
        /// </summary>
        /// <param name="webApplication">web application to register job to run on</param>
        /// <remarks>
        /// <para>
        /// This job will process all site collections within the web application.
        /// </para>
        /// <para>
        /// See the registration PowerShell script for how to register the job.
        /// </para>
        /// </remarks>
        public SampleWorkItemJobDefinition(SPWebApplication webApplication)
            : base(SampleWorkItemJobDefinition.jobName, webApplication)
        {
        }

        /// <summary>
        /// Name of the job
        /// </summary>
        /// <remarks>
        /// <para>
        /// This will be shown in the central administration timer job UI.
        /// </para>
        /// </remarks>
        public override string DisplayName
        {
            get
            {
                return Microsoft.SDK.SharePointServer.Samples.SampleWorkItemJob.JobDisplayName;
            }
        }

        /// <summary>
        /// Description of the job
        /// </summary>
        /// <remarks>
        /// <para>
        /// This will be shown in the central administration timer job UI.
        /// </para>
        /// </remarks>
        public override string Description
        {
            get
            {
                return Microsoft.SDK.SharePointServer.Samples.SampleWorkItemJob.JobDescription;
            }
        }

        /// <summary>
        /// Type of work item
        /// </summary>
        /// <returns>The Guid representing the type of work item</returns>
        public override Guid WorkItemType()
        {
            return SampleWorkItemJobDefinition.sampleWorkItemType;
        }

        public override void Execute(SPJobState jobState)
        {
            // create an instance of the state class
            timerJobState = new SampleWorkItemJobState();

            try
            {
                // Call the base class implementation which will process
                // the work items
                base.Execute(jobState);
            }
            finally
            {
                // destroy the job state instance to ensure it
                // does not get reused
                timerJobState.Dispose();
                timerJobState = null;
            }
        }

        protected override bool ProcessWorkItem(
            SPContentDatabase db,
            SPWorkItemCollection workItems,
            SPWorkItem workItem,
            SPJobState jobState)
        {
            TimerJobUtility tju = new TimerJobUtility(SampleWorkItemJobDefinition.jobName, jobState);

            // Call ProcessWorkItem, passing in our timerJobState
            return tju.ProcessWorkItem(workItems, workItem, this.timerJobState, 
                delegate(SPWorkItem wi, WorkItemTimerJobState tjs)
                {
                    // Save the current cultures
                    CultureInfo savedCulture = Thread.CurrentThread.CurrentCulture;
                    CultureInfo savedUICulture = Thread.CurrentThread.CurrentUICulture;

                    try
                    {
                        SampleWorkItemJobState sampleTJS = (SampleWorkItemJobState)tjs;

                        // Set the thread cultures to match the work item web
                        Thread.CurrentThread.CurrentCulture = sampleTJS.Web.Locale;
                        Thread.CurrentThread.CurrentUICulture = sampleTJS.Web.UICulture;

                        // Process the work item
                        ProcessWorkItemCore(wi, sampleTJS);
                    }
                    catch
                    {
                        // protect against exception filters running in the web's culture
                        throw;
                    }
                    finally
                    {
                        // Restore the thread cultures
                        Thread.CurrentThread.CurrentCulture = savedCulture;
                        Thread.CurrentThread.CurrentUICulture = savedUICulture;
                    }
                }
            );
        }
    }
}

Tous les membres statique (Partagé dans Visual Basic)s publics de ce type sont thread-safe. Cela n’est pas garanti pour les membres d’instance.
Afficher: