Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen.
Übersetzung
Original

Erste Schritte mit dem Project Server-CSOM und .NET

Office 2013

Erste Schritte bei der Entwicklung mit der .NET Framework-Schnittstelle für das Project Server mithilfe der clientseitigen Objektmodell (CSOM), und erfahren Sie, wie Projekte programmgesteuert zu erstellen.

Letzte Änderung: Montag, 9. März 2015

Gilt für: Project Server 2013

Das Project Server 2013 mithilfe der clientseitigen Objektmodell (CSOM) können Sie um Project Online und lokale Lösungen mit der .NET Framework 4 zu entwickeln. In diesem Artikel wird beschrieben, wie zum Erstellen einer Konsolenanwendung, die das CSOM zum Erstellen und Veröffentlichen von Projekten verwendet werden. Nach der Veröffentlichung eines Projekts, die Anwendung wartet darauf, dass der Project Server-Warteschlangendienst auf Fertig stellen, mit der Veröffentlichungsaktion und zeigt dann die veröffentlichten Projekte.

For a general introduction to the Project Server CSOM, see Was ist neu und was ist für Entwickler in Project 2013. For reference topics in the CSOM namespace, see Microsoft.ProjectServer.Client.

Sie können Visual Studio 2010 oder Visual Studio 2012 zum Entwickeln von Lösungen, die die Project Server-CSOM verwenden. Die Project Server-CSOM umfasst drei Assemblys für die Entwicklung von Clientanwendungen, Microsoft Silverlight Anwendungen und Windows Phone 8-Anwendungen mithilfe der .NET Framework 4. Das CSOM enthält auch eine JavaScript-Datei für die Entwicklung von Webanwendungen, wie in Microsoft.ProjectServer.Clientbeschrieben.

Sie können die CSOM-Assembly, die Sie aus der Project Server-Computer müssen oder die Project 2013 SDK heruntergeladen werden und einem remote Entwicklungscomputer kopieren. Die QueueCreateProject Konsolenanwendung, die in diesem Thema beschrieben wird ist keiner Silverlight oder einer Windows Phone 8-Anwendung, damit Sie die Assembly Microsoft.ProjectServer.Client.dll benötigen. Da das CSOM unabhängig von der WCF-basierte oder ASMX-basierte Project Server Interface (PSI) ist, müssen Sie keinen zum Festlegen von Dienstverweise für die PSI, oder verwenden Sie den Microsoft.Office.Project.Server.Library -Namespace.

Die QueueCreateProject -Anwendung verwendet Befehlszeilenargumente für den Namen des Projekts, um das Erstellen und das Zeitlimit für die Warteschlange. In Schritt 1 Erstellen der Standardkonsolenanwendung, eine Routine zum Analysieren der Befehlszeile hinzufügen und eine Hilfetext hinzufügen, falls Fehler in der Befehlszeile sind.

Schritt 1. So erstellen Sie eine CSOM-Projekt in Visual Studio

  1. Kopieren Sie die Assembly Microsoft.ProjectServer.Client.dll aus dem Ordner %ProgramFiles%\Common Files\Microsoft Shared\Web Server Extensions\15\ISAPI\ auf Ihrem Entwicklungscomputer. Kopieren Sie die Assembly in einen Ordner komfortable für andere Project Server und SharePoint-Verweisassemblys, die Sie, wie etwa C:\Project\Assemblies verwenden.

  2. Kopieren Sie die Assembly Microsoft.SharePoint.Client.dll und Microsoft.SharePoint.Client.Runtime.dll aus Assembly im gleichen Ordner Quelle auf Ihrem Entwicklungscomputer. Die Assembly Microsoft.ProjectServer.Client.dll ist abhängig von der zugehörigen SharePoint-Assemblys.

  3. Erstellen Sie eine Windows-Konsolenanwendung in Visual Studio und legen Sie das Zielframework auf .NET Framework 4. Nennen Sie beispielsweise die Anwendung QueueCreateProject.

    Hinweis Hinweis

    Wenn Sie vergessen, das richtige Ziel, festzulegen, nachdem Visual Studio das Projekt erstellt haben, öffnen Sie im Menü ProjektQueueCreateProject Eigenschaften. Wählen Sie auf der Registerkarte Anwendung in der Dropdownliste Zielframework.NET Framework 4. Verwenden Sie das .NET Framework 4 Client Profile nicht.

  4. Legen Sie im Projektmappen-Explorer Verweise auf die folgenden Assemblys:

    • Microsoft.ProjectServer.Client.dll

    • Microsoft.SharePoint.Client.dll

    • Microsoft.SharePoint.Client.Runtime.dll

  5. Bearbeiten Sie die Anweisungen using wie folgt, in der Datei Program.cs.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Microsoft.ProjectServer.Client;
    
  6. Anzeigen von Informationen zur Verwendung von Methoden verwenden, um die Befehlszeilenargumente für den Projektnamen und die Anzahl der Sekunden für Warteschlangentimeout, analysieren und beenden Sie die Anwendung hinzufügen. Ersetzen Sie den Hauptteil des Codes in der Datei Program.cs durch den folgenden Code ein.

    namespace QueueCreateProject
    {
        class Program
        {
            static void Main(string[] args)
            {
                if (!ParseCommandLine(args))
                {
                    Usage();
                    ExitApp();
                }
    
                /* Add calls to methods here to get the project context and create a project. */
    
                ExitApp();
            }
    
            // 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 < 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];
                                break;
                            case "*timeout":
                            case "*t":
                                if (++i >= 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);
            }
        }
    }
    

CSOM Entwicklung erfordert das ProjectContext -Objekt, das mit der URL Project Web App initialisiert werden. Der Code in Verfahren 2 verwendet die pwaPath -Konstante. Wenn Sie die Anwendung für mehrere Instanzen von Project Web App verwenden möchten, können Sie pwaPath stellen Sie eine Variable und Hinzufügen einer anderen Befehlszeilenargument.

Schritt 2. Zum Abrufen des Projektkontexts

  1. Fügen Sie Program Klasse Konstanten und Variablen, die der Webanwendung QueueCreateProject verwendet wird. Neben der URL Project Web App verwendet die Anwendung den Namen der standardmäßige Enterprise-Projekttyp (EPT), den Namen des Projekts zum Erstellen und eine maximale Warteschlangentimeout in Sekunden an. In diesem Fall kann die Variable timeoutSeconds Sie testen, wie verschiedene Werte für das Zeitlimit für die Anwendung auswirken. Das ProjectContext -Objekt ist das primäre Objekt für den Zugriff auf die CSOM.

    private const string pwaPath = "http://ServerName/pwa/"; // Change the path to your Project Web App instance.
    private static string basicEpt = "Enterprise Project";   // 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;
    
  2. Ersetzen Sie den Kommentar /* Add calls to methods here to get the project context and create a project. */ , durch den folgenden Code. Das Microsoft.ProjectServer.Client.ProjectContext -Objekt wird mit der URL Project Web App initialisiert. In den Verfahren 4 und 5 Verfahren werden die CreateTestProject -Methode und die ListPublishedProjects -Methode angezeigt.

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

Die Beispielanwendung QueueCreateProject wählt explizit Enterprise Standardprojekt-EPT um anzuzeigen, wie eine Anwendung die EPT für ein Projekt auswählen kann. Wenn die Informationen zur Erstellung von Projekt nicht die EPT GUID angegeben wird, würde eine Anwendung der Standard-EPT verwenden. Die GetEptUid -Methode wird von der CreateTestProject -Methode verwendet, die im Verfahren 4 beschrieben wird.

Die GetEptUid -Methode fragt das ProjectContext -Objekt für die Auflistung der EnterpriseProjectTypes , wobei der EPT Name angegebenen Namen entspricht. Nach dem Ausführen der Abfrage, wird die Variable eptUid auf die GUID des ersten EnterpriseProjectType -Objekts in der Auflistung eptList festgelegt. Da EPT Namen eindeutig sind, besteht nur ein EnterpriseProjectType -Objekt, das dem angegebenen Namen ab.

Schritt 3. Um die GUID der eines EPT für ein neues Projekt zu erhalten

  • Die GetEptUid -Methode der Program -Klasse hinzufügen.

    // 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 => ept.Name == eptName));
            projContext.ExecuteQuery();
    
            eptUid = eptList.First().Id;
        }
        catch (Exception ex)
        {
            string msg = string.Format("GetEptUid: eptName = \"{0}\"\n\n{1}",
                eptName, ex.GetBaseException().ToString());
            throw new ArgumentException(msg);
        }
        return eptUid;
    }
    

Es gibt mehrere Möglichkeiten, die EPT GUID zu erhalten. Die Abfrage in der GetEptUid -Methode dargestellt ist effizient, da sie nur das einzige Objekt EnterpriseProjectType heruntergeladen, das mit dem Namen EPT übereinstimmt. Die folgenden alternative Routine ist weniger effizient, da es eine vollständige Liste der EPTs an die Clientanwendung heruntergeladen und im durchlaufen und der Liste.

foreach (EnterpriseProjectType ept in projSvr.EnterpriseProjectTypes)
{
    if (ept.Name == eptName)
    {
        eptUid = ept.Id;
        break;
    }
}

Die folgende Routine mithilfe einen LINQ-Abfrage und Lambda-Ausdruck das EPT-Objekt ausgewählt, aber weiterhin alle Objekte EnterpriseProjectType downloads.

var eptList = projContext.LoadQuery(projContext.EnterpriseProjectTypes);
projContext.ExecuteQuery();
eptUid = eptList.First(ept => ept.Name == eptName).Id;

Die CreateTestProject -Methode erstellt ein ProjectCreationInformation -Objekt und gibt die Informationen, die zum Erstellen eines Projekts erforderlich ist. Die Projekt-GUID und Name sind erforderlich. der Anfangstermin, Projektbeschreibung und EPT GUID sind optional.

Nach dem Festlegen der neuen Projekteigenschaften, fügt die Projects.Add -Methode des Projekts zur Projects -Auflistung. Um zu speichern und veröffentlichen Sie das Projekt, müssen Sie die Projects.Update -Methode zum Senden einer Nachricht an die Project Server-Warteschlange, und erstellen Sie das Projekt aufrufen.

Schritt 4. Die neue Projekteigenschaften festlegen, das Projekt zu erstellen und veröffentlichen Sie das Projekt

  1. Die CreateTestProject -Methode der Program -Klasse hinzufügen. Der folgende Code erstellt und ein Projekt veröffentlicht, aber wartet nicht, die für die Durchführung von Warteschlangenaufträgen.

    // 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();
    
            /* Add code here to wait for the queue. */
        }
        catch(Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("\nError: {0}", ex.Message);
            Console.ResetColor();
        }
        return projCreated;
    }
    
  2. Ersetzen Sie den Kommentar /* Add code here to wait for the queue. */ , durch den folgenden Code für den Warteschlangenauftrag gewartet. Die Routine wartet, bis zu der angegebenen timeoutSeconds Anzahl von Sekunden oder wird fortgesetzt, wenn vor dem Timeout der Warteschlangenauftrag beendet wurde. Mögliche Warteschlange Auftragsstatusangaben finden Sie unter Microsoft.ProjectServer.Client.JobState.

    Das Aufrufen der Load -Methode und die ExecuteQuery -Methode für das Objekt QueueJob ist optional. Wenn das QueueJob -Objekt nicht initialisiert wird, wenn Sie die WaitForQueue -Methode aufrufen, Project Server wird initialisiert.

    // Calling Load and ExecuteQuery for the queue job is optional.
    // 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();
    

Die ListPublishedProjects -Methode ruft die Auflistung aller Projekte, die in Project Web App veröffentlicht werden. Wenn der Warteschlangenauftrag erstellt, die in Verfahren 4 ein Projekt nicht erfolgreich abgeschlossen oder Zeitüberschreitung, das neue Projekt wird in der Projects -Auflistung nicht enthalten.

5-Prozedur. So Listen Sie die veröffentlichten Projekte

  1. Die ListPublishedProjects -Methode der Program -Klasse hinzufügen.

    // 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());
        }
    }
    
  2. Legen Sie den richtigen Wert für die URL Project Web App, kompilieren Sie die Anwendung QueueCreateProject , und Testen Sie die Anwendung wie in der Prozedur 6.

Die Anwendung Sie zuerst die QueueCreateProject Anwendung auf eine Testinstanz des Project Web App ausführen, insbesondere dann, wenn Project Server auf einem virtuellen Computer installiert ist unter Umständen mehr Zeit als das Standardtimeout für die Warteschlange von zehn Sekunden ausgeführt werden.

Schritt 6. So testen Sie die Anwendung QueueCreateProject

  1. Öffnen Sie das Fenster QueueCreateProject Eigenschaften, wählen Sie die Registerkarte Debuggen, und fügen Sie die folgenden Befehlszeilenargumente im Abschnitt Startoptionen: -n "Test proj 1" -t 20

    Führen Sie die Anwendung (z. B. drücken Sie F5 ). Wenn Sie der Timeoutwert lange genug ist, zeigt die Anwendung die folgende Ausgabe (wenn andere veröffentlichte Projekte in Ihrer Instanz Project Web App vorhanden ist, sie werden auch werden angezeigt):

    Creating project: Test proj 1 ...
    
    Project ID : Project name : Created date
    
            b34d7009-753f-4abb-9191-f4b15a82aac3 :
            Test proj 1 : 9/22/2011 11:27:57 AM
    
    Press any key to exit...
    
  2. Führen Sie einen weiteren Test mit das Standardtimeout 10 Sekunden Warteschlange verwendet die folgenden Befehlszeilenargumente: -n "Test proj 1"

    Da Test Proj 1 bereits vorhanden ist, zeigt die Anwendung die folgende Ausgabe.

    Creating project: Test proj 1 ...
    Error: PJClientCallableException: ProjectNameAlreadyExists
    ProjectNameAlreadyExists
    projName = Test proj 1
    
    Project creation failed: Test proj 1
    
    Press any key to exit...
    
  3. Führen Sie einen weiteren Test mit das Standardtimeout 10 Sekunden Warteschlange verwendet die folgenden Befehlszeilenargumente: -n "Test proj 2"

    Die QueueCreateProject -Anwendung erstellt und veröffentlicht das Projekt mit dem Namen Test Proj 2.

  4. Führen Sie einen anderen Test mit den folgenden Befehlszeilenargumente, und legen den Timeoutwert zu kurz für Warteschlangenauftrag beendet sein: -n "Test proj 3" –t 1

    Da das Warteschlangentimeout zu kurz ist, wird das Projekt nicht erstellt werden. Die Anwendung zeigt die folgende Ausgabe.

    Creating project: Test proj 3 ...
    There is a problem in the queue. Timeout is 1 seconds.
            Queue JobState: Unknown
    
    Project creation failed: Test proj 3
    
    Press any key to exit...
    
  5. Ändern Sie den Code, damit die Anwendung nicht darauf warten, dass der Warteschlangenauftrag. Beispielsweise kommentieren Sie den Code, der wie folgt auf die Warteschlange, mit Ausnahme der Zeile projCreated = true wartet.

    //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();
    //}
    
    

  6. Kompilieren Sie die Anwendung neu, und führen Sie einen anderen Test mit den folgenden Befehlszeilenargumente: -n "Test proj 4"

    Da die WaitForQueue -Routine auskommentiert ist, wird die Anwendung nicht den Standardwert der Timeout verwendet. Obwohl die Anwendung nicht für die Warteschlange wartet, kann es Test Proj 4, anzeigen, wenn die Veröffentlichungsaktion in Project Server schnell genug ist.

    Creating project: Test proj 4 ...
    
    Project ID : Project name : Created date
    
            cdd54103-082f-425c-b075-9ff52ac7d4e6 :
            Test proj 2 : 9/25/2011 4:28:55 PM
    
            b34d7009-753f-4abb-9191-f4b15a82aac3 :
            Test proj 1 : 9/22/2011 11:27:57 AM
    
            5c0c73f2-f5dd-499b-8bd8-ebb74bf8c122 :
            Test proj 4 : 9/25/2011 4:39:21 PM
    
    Press any key to exit...
    

Aktualisieren Sie die Project Center-Seite in Project Web App (http://ServerName/ProjectServerName/Projects.aspx), die veröffentlichten Projekte angezeigt. Abbildung 1 zeigt, dass die Testprojekte veröffentlicht werden.

Abbildung 1. Überprüfen der veröffentlichten Projekte in Project Web App

Überprüfen der veröffentlichten Projekte in Project Web App

Die QueueCreateProject -Beispielanwendung zeigt ein typisches Beispiel dafür, wie Sie zum Erstellen einer Project-Entität mit dem Clientobjektmodell mithilfe der ProjectCreationInformation -Klasse, wie Sie das Projekt veröffentlichten -Auflistung hinzugefügt, wie einem Warteschlangenauftrag gewartet, mithilfe der WaitForQueue -Methode und zum Aufzählen der Auflistung von veröffentlichten Projekten.

Es folgt der vollständige Code für die QueueCreateProject Beispielanwendung aus. Microsoft.ProjectServer.Client.ProjectCreationInformation Class Reference enthält auch den Code in diesem Thema.

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 your Project Web App instance.
        private static string basicEpt = "Enterprise Project";   // 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 => 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 => 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 < 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];
                            break;
                        case "*timeout":
                        case "*t":
                            if (++i >= 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);
        }
    }
}
Anzeigen:
© 2015 Microsoft