ProjectContext.WaitForQueue(QueueJob, Int32) Método

public:
 Microsoft::ProjectServer::Client::JobState WaitForQueue(Microsoft::ProjectServer::Client::QueueJob ^ job, int timeoutSeconds);

public Microsoft.ProjectServer.Client.JobState WaitForQueue(Microsoft.ProjectServer.Client.QueueJob job, int timeoutSeconds);

member this.WaitForQueue : Microsoft.ProjectServer.Client.QueueJob * int -> Microsoft.ProjectServer.Client.JobState

Public Function WaitForQueue (job As QueueJob, timeoutSeconds As Integer) As JobState

Parámetros

Devoluciones

Estado del trabajo de cola. Si el trabajo se completa correctamente, devuelve Success.

Ejemplos

El ejemplo de consola denominado QueueCreateProject realiza los siguientes trabajos:

• Analiza la línea de comandos para obtener el nombre de un nuevo proyecto y un tiempo de espera de trabajo de cola opcional. El tiempo de espera predeterminado es de 10 segundos. Por ejemplo, si un proyecto denominado Test proj 1 no existe en Project Web App, puede ejecutar la aplicación con el comando QueueCreateProject -projName "Test proj 1".
• Crea un objeto ProjectContext para la instancia de Project Web App especificada.
• Obtiene el GUID del tipo de proyecto de empresa (EPT) denominado "Plan de proyecto básico".
• Crea un proyecto mediante el método CreateTestProject , que establece las propiedades de un objeto ProjectCreationInformation .
• Espera a que El servicio de cola de Project Server publique el nuevo proyecto mediante el método ProjectContext.WaitForQueue .
• Enumera los proyectos publicados. Si la aplicación QueueCreateProject no llama al método WaitForQueue , es posible que los proyectos publicados aún no incluyan el nuevo proyecto.

Para obtener más información sobre este ejemplo, vea Introducción al CSOM de Project Server y .NET.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.ProjectServer.Client;

namespace QueueCreateProject
{
    class Program
    {
        private const string pwaPath = "http://<i>ServerName</i>/pwa/"; // Change the path to Project Web App.
        private static string basicEpt = "Basic Project Plan";   // Basic enterprise project type.
        private static string projName = string.Empty;
        private static int timeoutSeconds = 10;  // The maximum wait time for a queue job, in seconds.

        private static ProjectContext projContext;

        static void Main(string[] args)
        {
            if (!ParseCommandLine(args))
            {
                Usage();
                ExitApp();
            }

            projContext = new ProjectContext(pwaPath);

            if (CreateTestProject())
                ListPublishedProjects();
            else
                Console.WriteLine("\nProject creation failed: {0}", projName);

            ExitApp();
        }

        // Create a project.
        private static bool CreateTestProject()
        {
            bool projCreated = false;

            try
            {
                Console.Write("\nCreating project: {0} ...", projName);
                ProjectCreationInformation newProj = new ProjectCreationInformation();

                newProj.Id = Guid.NewGuid();
                newProj.Name = projName;
                newProj.Description = "Test creating a project with CSOM";
                newProj.Start = DateTime.Today.Date;

                // Setting the EPT GUID is optional. If no EPT is specified, Project Server uses 
                // the default EPT. 
                newProj.EnterpriseProjectTypeId = GetEptUid(basicEpt);

                PublishedProject newPublishedProj = projContext.Projects.Add(newProj);
                QueueJob qJob = projContext.Projects.Update();

                // Calling Load and ExecuteQuery for the queue job is optional. If qJob is 
                // not initialized when you call WaitForQueue, Project Server initializes it.
                // projContext.Load(qJob);
                // projContext.ExecuteQuery();

                JobState jobState = projContext.WaitForQueue(qJob, timeoutSeconds);

                if (jobState == JobState.Success)
                {
                    projCreated = true;
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine("\nThere is a problem in the queue. Timeout is {0} seconds.", 
                        timeoutSeconds);
                    Console.WriteLine("\tQueue JobState: {0}", jobState.ToString());
                    Console.ResetColor();
                }

                Console.WriteLine();
            }
            catch(Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("\nError: {0}", ex.Message);
                Console.ResetColor();
            }
            return projCreated;
        }

        // Get the GUID of the specified enterprise project type.
        private static Guid GetEptUid(string eptName)
        {
            Guid eptUid = Guid.Empty;

            try
            {
                // Get the list of EPTs that have the specified name. 
                // If the EPT name exists, the list will contain only one EPT.
                var eptList = projContext.LoadQuery(
                    projContext.EnterpriseProjectTypes.Where(
                        ept =&gt; ept.Name == eptName));
                projContext.ExecuteQuery();

                eptUid = eptList.First().Id;

                // Alternate routines to find the EPT GUID. Both (a) and (b) download the entire list of EPTs.
                // (a) Using a foreach block:
                //foreach (EnterpriseProjectType ept in projSvr.EnterpriseProjectTypes)
                //{
                //    if (ept.Name == eptName)
                //    {
                //        eptUid = ept.Id;
                //        break;
                //    }
                //}
                // (b) Querying for the EPT list, and then using a lambda expression to select the EPT:
                //var eptList = projContext.LoadQuery(projContext.EnterpriseProjectTypes);
                //projContext.ExecuteQuery();
                //eptUid = eptList.First(ept =&gt; ept.Name == eptName).Id;
            }
            catch (Exception ex)
            {
                string msg = string.Format("GetEptUid: eptName = \"{0}\"\n\n{1}",
                    eptName, ex.GetBaseException().ToString());
                throw new ArgumentException(msg);
            }
            return eptUid;
        }

        // List the published projects.
        private static void ListPublishedProjects()
        {
            // Get the list of projects on the server.
            projContext.Load(projContext.Projects);
            projContext.ExecuteQuery();

            Console.WriteLine("\nProject ID : Project name : Created date");

            foreach (PublishedProject pubProj in projContext.Projects)
            {
                Console.WriteLine("\n\t{0} :\n\t{1} : {2}", pubProj.Id.ToString(), pubProj.Name,
                    pubProj.CreatedDate.ToString());
            }
        }

        // Parse the command line. Return true if there are no errors.
        private static bool ParseCommandLine(string[] args)
        {
            bool error = false;
            int argsLen = args.Length;

            try
            {
                for (int i = 0; i &lt; argsLen; i++)
                {
                    if (error) break;
                    if (args[i].StartsWith("-") || args[i].StartsWith("/"))
                        args[i] = "*" + args[i].Substring(1).ToLower();

                    switch (args[i])
                    {
                        case "*projname":
                        case "*n":
                            if (++i &gt;= argsLen) return false;
                            projName = args[i];
                            break;
                        case "*timeout":
                        case "*t":
                            if (++i &gt;= argsLen) return false;
                            timeoutSeconds = Convert.ToInt32(args[i]);
                            break;
                        case "*?":
                        default:
                            error = true;
                            break;
                    }
                }
            }
            catch (FormatException)
            {
                error = true;
            }
            if (string.IsNullOrEmpty(projName)) error = true;
            return !error;
        }

        private static void Usage()
        {
            string example = "Usage: QueueCreateProject -projName | -n \"New project name\" [-timeout | -t sec]";
            example += "\nExample: QueueCreateProject -n \"My new project\"";
            example += "\nDefault timeout seconds = " + timeoutSeconds.ToString();
            Console.WriteLine(example);
        }

        private static void ExitApp()
        {
            Console.Write("\nPress any key to exit... ");
            Console.ReadKey(true);
            Environment.Exit(0);
        }
    }
}