LookupTable.ReadLookupTables method

Office 2013 and later

Gets custom field lookup tables and corresponding code masks. The language parameter is used only if xmlFilter is an empty string.

Namespace:  WebSvcLookupTable
Assembly:  ProjectServerServices (in ProjectServerServices.dll)

<SoapDocumentMethodAttribute("http://schemas.microsoft.com/office/project/server/webservices/LookupTable/ReadLookupTables", RequestNamespace := "http://schemas.microsoft.com/office/project/server/webservices/LookupTable/",  _
	ResponseNamespace := "http://schemas.microsoft.com/office/project/server/webservices/LookupTable/",  _
	Use := SoapBindingUse.Literal, ParameterStyle := SoapParameterStyle.Wrapped)> _
Public Function ReadLookupTables ( _
	xmlFilter As String, _
	autoCheckOut As Boolean, _
	language As Integer _
) As LookupTableDataSet
Dim instance As LookupTable
Dim xmlFilter As String
Dim autoCheckOut As Boolean
Dim language As Integer
Dim returnValue As LookupTableDataSet

returnValue = instance.ReadLookupTables(xmlFilter, _
	autoCheckOut, language)


Type: System.String

XML filter to read specific data. An empty string returns all lookup table data.

Type: System.Boolean

If true, check out for making changes.

Type: System.Int32

Locale ID (LCID).

The primary DataTable in a LookupTableDataSet is the LookupTablesDataTable.


The xmlFilter parameter works with the Criteria operators to filter rows only in the primary LookupTablesDataTable. For example, you cannot use filter with the ReadLookupTables method to filter rows in the LookupTableTreesDataTable. If you try to filter rows in a secondary DataTable, the PSI returns a FilterInvalid exception.

However, you can use the Fields.Add method to filter columns in the primary LookupTablesDataTable and the in secondary LookupTableTreesDataTable and LookupTableMasksDataTable.

For more information about the xmlFilter parameter, see How to: Use a Filter Parameter with PSI Methods.

Project Server Permissions




Allows the user to connect to the Project Server database from Project Professional. Global permission.


Allows the user to modify the definitions of Enterprise custom fields and lookup table values. Global permission.

The ReadCustomFieldsTest sample does the following:

  • Reads all custom fields in the Project Web App installation that is specified by the endpoint address in the app.config file, and then writes an XML file of the CustomFieldDataSet.

  • Reads lookup table data for the specified language LCID, and then writes an XML file of the LookupTableDataSet. The lookup table XML data includes collections of the following tables: LookupTables, LookupTableMasks, and LookupTableTrees.

For information about using the code sample in a Microsoft Visual Studio 2010 project and creating an app.config file for configuration of the WCF endpoints, see Prerequisites for WCF-based code samples in Project 2013.

using System;
using System.Text;
using System.ServiceModel;
using System.Xml;
using PSLibrary = Microsoft.Office.Project.Server.Library;

namespace Microsoft.SDK.Project.Samples.ReadCustomFieldsTest
    class Program
        private const string ENDPOINT_CUSTOMFIELDS = "basicHttp_CustomFields";
        private const string ENDPOINT_LOOKUPTABLE = "basicHttp_LookupTable";
        // Change the output directory for your computer.
        private const string OUTPUT_FILES = @"C:\Project\Samples\Output\";

        private static SvcCustomFields.CustomFieldsClient customFieldsClient;
        private static SvcLookupTable.LookupTable lookupTableClient;

        private static string outFileCustomFieldsDs;
        private static string outFileLookupTableDs;
        private static int language = 1033;         // Use the English LCID by default.

        static void Main(string[] args)
            if (args.Length > 0 && args.Length < 3)
                if (args[0].ToLower() == "-lcid")
                    language = Convert.ToInt32(args[1]);

            outFileCustomFieldsDs = OUTPUT_FILES + "CustomFieldDataSet.xml";
            outFileLookupTableDs = OUTPUT_FILES + "LookupTableDataSet.xml";

                Console.WriteLine("Reading custom fields...");
                SvcCustomFields.CustomFieldDataSet customFieldDs = 
                    customFieldsClient.ReadCustomFields2(string.Empty, false);

                    "\nXML output of the CustomFieldDataSet:\n\t{0}",

                Console.WriteLine("Reading lookup tables...");
                SvcLookupTable.LookupTableDataSet lookupTableDs =
                    lookupTableClient.ReadLookupTables(string.Empty, false, language);

                    "\nXML output of the LookupTableDataSet:\n\t{0}",
            catch (FaultException fault)
                // Use the WCF FaultException, because the ASMX SoapException does not 
                // exist in a WCF-based application.
            catch (EndpointNotFoundException ex)
                Console.WriteLine("\nInnerException: \n" + ex.InnerException.Message);
            Console.Write("\nPress any key to exit... ");

        // Extract a PSClientError object from the WCF FaultException object, and
        // then display the exception details and each error in the PSClientError stack.
        private static void WriteFaultOutput(FaultException fault)
            string errAttributeName;
            string errAttribute;
            string errOut;
            string errMess = "".PadRight(30, '=') + "\r\n"
                + "Error details: " + "\r\n";

            PSLibrary.PSClientError error = Helpers.GetPSClientError(fault, out errOut);
            errMess += errOut;

            if (error != null)
                PSLibrary.PSErrorInfo[] errors = error.GetAllErrors();
                PSLibrary.PSErrorInfo thisError;

                for (int i = 0; i < errors.Length; i++)
                    thisError = errors[i];
                    errMess += "\r\n".PadRight(30, '=') + "\r\nPSClientError output:\r\n";
                    errMess += thisError.ErrId.ToString() + "\n";

                    for (int j = 0; j < thisError.ErrorAttributes.Length; j++)
                        errAttributeName = thisError.ErrorAttributeNames()[j];
                        errAttribute = thisError.ErrorAttributes[j];
                        errMess += "\r\n\t" + errAttributeName
                            + ": " + errAttribute;
            Console.ForegroundColor = ConsoleColor.Red;

        // Use the endpoints defined in app.config to configure the client.
        public static void ConfigClientEndpoints(string endpt)
            if (endpt == ENDPOINT_CUSTOMFIELDS)
                customFieldsClient = new SvcCustomFields.CustomFieldsClient(endpt);
            else if (endpt == ENDPOINT_LOOKUPTABLE)
                lookupTableClient = new SvcLookupTable.LookupTableClient(endpt);

    // Helper methods
    class Helpers
        /// <summary>
        /// Extract a PSClientError object from the ServiceModel.FaultException,
        /// for use in output of the GetPSClientError stack of errors.
        /// </summary>
        /// <param name="e"></param>
        /// <param name="errOut">Shows that FaultException has more information 
        /// about the errors than PSClientError has. FaultException can also contain 
        /// other types of errors, such as failure to connect to the server.</param>
        /// <returns>PSClientError object, for enumerating errors.</returns>
        public static PSLibrary.PSClientError GetPSClientError(FaultException e,
                                                               out string errOut)
            const string PREFIX = "GetPSClientError() returns null: ";
            errOut = string.Empty;
            PSLibrary.PSClientError psClientError = null;

            if (e == null)
                errOut = PREFIX + "Null parameter (FaultException e) passed in.";
                psClientError = null;
                // Get a ServiceModel.MessageFault object.
                var messageFault = e.CreateMessageFault();

                if (messageFault.HasDetail)
                    using (var xmlReader = messageFault.GetReaderAtDetailContents())
                        var xml = new XmlDocument();

                        var serverExecutionFault = xml["ServerExecutionFault"];
                        if (serverExecutionFault != null)
                            var exceptionDetails = serverExecutionFault["ExceptionDetails"];
                            if (exceptionDetails != null)
                                    errOut = exceptionDetails.InnerXml + "\r\n";
                                    psClientError =
                                        new PSLibrary.PSClientError(exceptionDetails.InnerXml);
                                catch (InvalidOperationException ex)
                                    errOut = PREFIX + "Unable to convert fault exception info ";
                                    errOut += "a valid Project Server error message. Message: \n\t";
                                    errOut += ex.Message;
                                    psClientError = null;
                                errOut = PREFIX + "The FaultException e is a ServerExecutionFault, "
                                    + "but does not have ExceptionDetails.";
                            errOut = PREFIX + "The FaultException e is not a ServerExecutionFault.";
                else // No detail in the MessageFault.
                    errOut = PREFIX + "The FaultException e does not have any detail.";
            errOut += "\r\n" + e.ToString() + "\r\n";
            return psClientError;


Other resources

How to: Use a Filter Parameter with PSI Methods