ProjectContext.WaitForQueue method

Office 2013 and later

Waits for the specified queue job to complete, or for a maximum number of seconds.

Namespace:  Microsoft.ProjectServer.Client
Assembly:  Microsoft.ProjectServer.Client (in Microsoft.ProjectServer.Client.dll)

public JobState WaitForQueue(
	QueueJob job,
	int timeoutSeconds


Type: Microsoft.ProjectServer.Client.QueueJob

An object that represents the queued job.

Type: System.Int32

The maximum number of seconds to wait for the queue job to complete.

Return value

Type: Microsoft.ProjectServer.Client.JobState
The state of the queue job. If the job completes successfully, returns JobState.Success.

The Console example named QueueCreateProject does the following jobs:

  • Parses the command line to get the name of a new project, and an optional queue job wait time. The default wait time is 10 seconds. For example, if a project named Test proj 1 does not exist in Project Web App, you can run the application with the QueueCreateProject -projName "Test proj 1" command.

  • Creates a ProjectContext object for the specified Project Web App instance.

  • Gets the GUID of the enterprise project type (EPT) named "Basic Project Plan".

  • Creates a project by using the CreateTestProject method, which sets the properties of a ProjectCreationInformation object.

  • Waits for the Project Server Queue Service to publish the new project, by using the ProjectContext.WaitForQueue method.

  • Lists the published projects. If the QueueCreateProject application does not call the WaitForQueue method, the published projects may not yet include the new project.

For more information about this example, see Getting started with the Project Server CSOM and .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://ServerName/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))

            projContext = new ProjectContext(pwaPath);

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


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

                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;
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine("\nThere is a problem in the queue. Timeout is {0} seconds.", 
                    Console.WriteLine("\tQueue JobState: {0}", jobState.ToString());

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

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

                // 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(
                        ept => ept.Name == eptName));

                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);
                //eptUid = eptList.First(ept => 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.

            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,

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

                for (int i = 0; i < 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 >= argsLen) return false;
                            projName = args[i];
                        case "*timeout":
                        case "*t":
                            if (++i >= argsLen) return false;
                            timeoutSeconds = Convert.ToInt32(args[i]);
                        case "*?":
                            error = true;
            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();

        private static void ExitApp()
            Console.Write("\nPress any key to exit... ");