Erste Schritte mit dem Project Server-CSOM und .NET
Sie können das clientseitige Objektmodell (CSOM) von Project Server 2013 verwenden, um Project Online und lokale Lösungen mit .NET Framework 4 zu entwickeln. Dieser Artikel beschreibt, wie Sie eine Konsolenanwendung erstellen, die das CSOM zum Erstellen und Veröffentlichen von Projekten verwendet. Nach dem Veröffentlichen eines Projekts wartet die Anwendung, bis der Project Server-Warteschlangendienst die Veröffentlichung abgeschlossen hat und listet dann die veröffentlichten Projekte auf.
Eine allgemeine Einführung in das Project Server-CSOM finden Sie unter Updates für Entwickler in Project 2013. Referenzthemen im CSOM-Namespace finden Sie unter Microsoft.ProjectServer.Client.
Erstellen eines CSOM-Projekts in Visual Studio
Sie können Visual Studio 2010 oder Visual Studio 2012 verwenden, um Lösungen zu entwickeln, die das Project Server-CSOM verwenden. Das Project Server-CSOM umfasst drei Assemblys für die Entwicklung von Clientanwendungen, Microsoft Silverlight-Anwendungen und Windows Phone 8-Anwendungen mit .NET Framework 4. Das CSOM umfasst außerdem eine JavaScript-Datei für die Entwicklung von Webanwendungen, wie in Microsoft.ProjectServer.Client beschrieben.
Sie können die benötigte CSOM-Assembly vom Project Server-Computer oder aus dem Project 2013-SDK-Download auf einen Remote-Entwicklungscomputer kopieren. Die QueueCreateProject-Konsolenanwendung, die in diesem Thema beschrieben wird, ist keine Silverlight- oder Windows Phone 8-Anwendung. Sie werden also die Microsoft.ProjectServer.Client.dll-Assembly benötigen. Da das CSOM unabhängig von der WCF- oder ASMX-basierten Project Server Interface (PSI) ist, müssen Sie keine Dienstverweise für die PSI festlegen oder den Microsoft.Office.Project.Server.Library-Namespace festlegen.
Die QueueCreateProject-Anwendung verwendet Befehlszeilenargumente für den Namen des zu erstellenden Projekts und für das Warteschlangentimeoutlimit. In Prozedur 1 erstellen Sie die einfache Konsolenanwendung, fügen eine Routine zum Analysieren der Befehlszeile hinzu und fügen eine Verwendungsmeldung hinzu, wenn in der Befehlszeile Fehler auftreten.
Vorgehensweise 1: So erstellen Sie ein CSOM-Projekt in Visual Studio
Kopieren Sie die Microsoft.ProjectServer.Client.dll-Assembly aus dem
%ProgramFiles%\Common Files\Microsoft Shared\Web Server Extensions\15\ISAPI\Ordner auf Ihren Entwicklungscomputer. Kopieren Sie die Assembly in einen geeigneten Ordner für andere Project Server- und SharePoint-Verweisassemblys, die Sie verwenden, zC:\Project\Assemblies. B. .Kopieren Sie die Microsoft.SharePoint.Client.dll-Assembly und die Microsoft.SharePoint.Client.Runtime.dll-Assembly aus demselben Quellordner auf Ihren Entwicklungscomputer. Die Microsoft.ProjectServer.Client.dll-Assembly verfügt über Abhängigkeiten für die zugehörigen SharePoint-Assemblys.
Erstellen Sie in Visual Studio eine Windows-Konsolenanwendung, und legen Sie das Zielframework auf .NET Framework 4 fest. Nennen Sie die Anwendung z. B. QueueCreateProject.
Hinweis
Wenn Sie vergessen, das richtige Ziel festzulegen, nachdem Visual Studio das Projekts erstellt hat, öffnen Sie Eigenschaften von QueueCreateProject im Menü Projekt. Wählen Sie auf der Registerkarte Anwendung in der Dropdown-Liste Zielframework die Option .NET Framework 4. Verwenden Sie nicht .NET Framework 4 Client Profile.
Legen Sie im Projektmappen-Explorer Verweise auf die folgenden Assemblys fest:
- Microsoft.ProjectServer.Client.dll
- Microsoft.SharePoint.Client.dll
- Microsoft.SharePoint.Client.Runtime.dll
Bearbeiten Sie in der Datei „Program.cs“ die
using-Anweisungen wie folgt.using System; using System.Collections.Generic; using System.Linq; using System.Text; using Microsoft.ProjectServer.Client;Fügen Sie Methoden zum Analysieren der Befehlszeilenargumente für den Projektnamen und die Anzahl von Sekunden für das Warteschlangen-Zeitlimit, das Anzeigen von Verwendungsinformationen und das Beenden der Anwendung hinzu. Ersetzen Sie den Hauptteil des Codes in der Datei „Program.cs“ durch den folgenden Code.
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); } } }
Abrufen des Projektkontexts
Die CSOM-Entwicklung erfordert, dass das ProjectContext-Objekt mit der Project Web App-URL initialisiert wird. Der Code in Verfahren 2 verwendet die pwaPath-Konstante. Wenn Sie beabsichtigen, die Anwendung für mehrere Instanzen von Project Web App zu verwenden, können Sie pwaPath zu einer Variablen machen und ein weiteres Befehlszeilenargument hinzufügen.
Vorgehensweise 2: So rufen Sie den Projektkontext ab
Fügen Sie Program-Klassenkonstanten und -Variablen hinzu, die von der QueueCreateProject-Anwendung verwendet werden. Zusätzlich zur Project Web App-URL verwendet die Anwendung den Namen des standardmäßigen Enterprise-Projekttyps (EPT), den Namen des zu erstellenden Projekts und ein maximales Warteschlangen-Zeitlimit in Sekunden. In diesem Fall ermöglicht Ihnen die timeoutSeconds-Variable zu testen, wie sich verschiedene Werte für das Zeitlimit auf die Anwendung auswirken. Das ProjectContext-Objekt ist das primäre Objekt für den Zugriff auf das CSOM.
private const string pwaPath = "https://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;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 Project Web App-URL initialisiert. Die CreateTestProject-Methode und die ListPublishedProjects-Methode werden in Verfahren 4 und Verfahren 5 gezeigt.projContext = new ProjectContext(pwaPath); if (CreateTestProject()) ListPublishedProjects(); else Console.WriteLine("\nProject creation failed: {0}", projName);
Abrufen eines Enterprise-Projekttyps
Die QueueCreateProject-Beispielanwendung wählt explizit den Enterprise-Projekt-EPT aus, um zu zeigen, wie eine Anwendung den EPT für ein Projekt auswählen kann. Wenn die Projekterstellungsinformationen die EPT-GUID nicht angeben, verwendet eine Anwendung den Standard-EPT. Die GetEptUid-Methode wird von der CreateTestProject-Methode verwendet, die in Verfahren 4 beschriebenen wird.
Die GetEptUid-Methode fragt das ProjectContext-Objekt für die Auflistung von EnterpriseProjectTypes ab, deren EPT-Namen dem angegebenen Namen entsprechen. Nach dem Ausführen der Abfrage wird die eptUid-Variable auf die GUID des ersten EnterpriseProjectType-Objekts in der eptList-Auflistung festgelegt. Da EPT-Namen eindeutig sind, gibt es nur ein EnterpriseProjectType-Objekt mit dem angegebenen Namen.
Verfahren 3. So rufen Sie die GUID eines EPT für ein neues Projekt ab
Fügen Sie die GetEptUid-Methode zur Program-Klasse hinzu.
// 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 ermitteln. Die in der GetEptUid-Methode gezeigte Abfrage ist effizient, da sie nur das eine EnterpriseProjectType-Objekt herunterlädt, das dem EPT-Namen entspricht. Die folgende alternative Routine ist weniger effizient, da sie die vollständige Liste der EPTs in die Clientanwendung herunterlädt und die Liste mehrmals durchläuft.
foreach (EnterpriseProjectType ept in projSvr.EnterpriseProjectTypes)
{
if (ept.Name == eptName)
{
eptUid = ept.Id;
break;
}
}
Die folgende Routine verwendet eine LINQ-Abfrage und einen Lambda-Ausdruck zum Auswählen des EPT-Objekts, lädt jedoch auch alle EnterpriseProjectType-Objekte herunter.
var eptList = projContext.LoadQuery(projContext.EnterpriseProjectTypes);
projContext.ExecuteQuery();
eptUid = eptList.First(ept => ept.Name == eptName).Id;
Festlegen der Erstellungsinformationen und Veröffentlichen des Projekts
Die CreateTestProject-Methode erstellt ein ProjectCreationInformation-Objekt und gibt die Informationen an, die zum Erstellen eines Projekts erforderlich sind. Die Projekt-GUID und der Name sind erforderlich; Das Startdatum, die Projektbeschreibung und die EPT-GUID sind optional.
Nach dem Festlegen der neuen Projekteigenschaften fügt die Projects.Add-Methode das Projekt zur Projects-Auflistung hinzu. Zum Speichern und Veröffentlichen des Projekts müssen Sie die Projects.Update-Methode aufrufen, um eine Nachricht an die Project Server-Warteschlange zu senden und das Projekt zu erstellen.
Prozedur 4. Erstellen Sie das Projekt, und veröffentlichen Sie das Projekt, um die neuen Projekteigenschaften festzulegen.
Fügen Sie die CreateTestProject-Methode zur Program-Klasse hinzu. Mit dem folgende Code wird ein Projekt erstellt und veröffentlicht, es wird jedoch nicht gewartet, bis der Warteschlangenauftrag abgeschlossen ist.
// 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; }Ersetzen Sie den Kommentar
/* Add code here to wait for the queue. */durch den folgenden Code, damit auf den Abschluss des Warteschlangenauftrags gewartet wird. Die Routine wartet maximal die für timeoutSeconds angegebene Anzahl von Sekunden oder fährt fort, wenn der Warteschlangenauftrag vor dem Zeitlimit abgeschlossen ist. Mögliche Zustände von Aufträgen in der Warteschlange finden Sie unter Microsoft.ProjectServer.Client.JobState.Das Aufrufen der Load-Methode und der ExecuteQuery-Methode für das QueueJob-Objekt ist optional. Wenn das QueueJob-Objekt beim Aufrufen der WaitForQueue-Methode nicht initialisiert ist, initialisiert Project Server die Methode.
// 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();
Auflisten der veröffentlichten Projekte
Die ListPublishedProjects-Methode ruft die Sammlung aller Projekte ab, die in Project Web App veröffentlicht wurden. Wenn der Warteschlangenauftrag, der in Verfahren 4 ein Projekt erstellt, nicht erfolgreich abgeschlossen wurde oder das Zeitlimit überschreitet, wird das neue Projekt nicht in die Projects-Sammlung aufgenommen.
Prozedur 5. So listen Sie die veröffentlichten Projekte auf
Fügen Sie die ListPublishedProjects-Methode zur Program-Klasse hinzu.
// 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()); } }Legen Sie den richtigen Wert für die Project Web App-URL fest, kompilieren Sie die QueueCreateProject-Anwendung, und testen Sie dann die Anwendung wie in Verfahren 6 beschrieben.
Testen der QueueCreateProject-Anwendung
Beim ersten Ausführen der QueueCreateProject-Anwendung auf einer Testinstanz von Project Web App, insbesondere dann, wenn Sie Project Server auf einem virtuellen Computer installiert haben, benötigt die Anwendung möglicherweise mehr Zeit für die Ausführung als das Standardzeitlimit für Warteschlangen von 10 Sekunden.
Verfahren 6. So testen Sie die Anwendung QueueCreateProject
Öffnen Sie das Fenster Eigenschaften von QueueCreateProject, wählen Sie die Registerkarte Debuggen, und fügen Sie dann die folgenden Befehlszeilenargumente in den Abschnitt Startoptionen ein:
-n "Test proj 1" -t 20Führen Sie die Anwendung aus (drücken Sie z. B. F5). Wenn das Zeitlimit lang genug ist, zeigt die Anwendung die folgende Ausgabe an (wenn in Ihrer Project Web App-Instanz andere veröffentlichte Projekte vorhanden sind, werden diese ebenfalls 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...Führen Sie einen weiteren Test mit den folgenden Befehlszeilenargumenten durch, um das standardmäßige Warteschlangen-Zeitlimit von 10 Sekunden anzuwenden:
-n "Test proj 1"Da „Test Proj 1“ bereits vorhanden ist, zeigt die Anwendung folgende Ausgabe an.
Creating project: Test proj 1 ... Error: PJClientCallableException: ProjectNameAlreadyExists ProjectNameAlreadyExists projName = Test proj 1 Project creation failed: Test proj 1 Press any key to exit...Führen Sie einen weiteren Test mit den folgenden Befehlszeilenargumenten durch, um das standardmäßige Warteschlangen-Zeitlimit von 10 Sekunden anzuwenden:
-n "Test proj 2"Die QueueCreateProject-Anwendung erstellt und veröffentlicht das Projekt mit dem Namen „Test Proj 2“.
Führen Sie einen weiteren Test mit den folgenden Befehlszeilenargumenten durch, und legen Sie das Zeitlimit so kurz fest, dass der Warteschlangenauftrag nicht abgeschlossen werden kann:
-n "Test proj 3" -t 1Da das Warteschlangen-Zeitlimit zu kurz ist, wird das Projekt nicht erstellt. 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...Ändern Sie den Code so, dass die Anwendung nicht auf den Warteschlangenauftrag wartet. Kommentieren Sie beispielsweise den Code aus, der auf die Warteschlange wartet, mit Ausnahme der
projCreated = trueZeile, wie folgt.//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(); //}Kompilieren Sie die Anwendung neu, und führen Sie einen weiteren Test mit den folgenden Befehlszeilenargumente durch:
-n "Test proj 4"Da die WaitForQueue-Routine auskommentiert ist, verwendet die Anwendung nicht den Standardwert für das Zeitlimit. Obwohl die Anwendung nicht auf die Warteschlange wartet, zeigt sie möglicherweise „Test Proj 4“ an, 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 Projektcenter-Seite in Project Web App (https://ServerName/ProjectServerName/Projects.aspx), um die veröffentlichten Projekte anzuzeigen. Die folgende Abbildung zeigt, dass die Projekte veröffentlicht wurden.
Überprüfen der veröffentlichten Projekte in Project Web App
Die QueueCreateProject-Beispielanwendung zeigt ein typisches Beispiel für die Erstellung einer Projektentität mit dem CSOM anhand der ProjectCreationInformation-Klasse, wie Sie das Projekt zur veröffentlichten Auflistung hinzufügen, wie auf einen Auftrag in der Warteschlange mit der WaitForQueue-Methode auf einen Warteschlangenauftrag gewartet wird, und wie die Auflistung der veröffentlichten Projekte aufgelistet wird.
Vollständiges Codebeispiel
Nachfolgend ist der vollständige Code für die QueueCreateProject-Beispielanwendung aufgeführt. Die Microsoft.ProjectServer.Client.ProjectCreationInformation-Klassenreferenz 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 = "https://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);
}
}
}