コード例 #1
0
        /// <summary>
        /// Parses a string representation of a Lookup value to a LookupFieldValue instance.
        /// </summary>
        /// <param name="fieldValue">Field value to parse.</param>
        /// <returns>LookupFieldValue instance representing the specified string value.</returns>
        public static LookupFieldValue Parse(string fieldValue)
        {
            if (string.IsNullOrEmpty(fieldValue))
            {
                return(null);
            }

            LookupFieldValue result = new LookupFieldValue();

            if (fieldValue == "***")
            {
                result.IsSecret = true;
            }
            else
            {
                //
                // Find the delimiter.
                //
                int index = fieldValue.IndexOf(";#", StringComparison.Ordinal);

                //
                // Set the id.
                //
                int id;
                if (!int.TryParse(fieldValue.Substring(0, index), NumberStyles.Integer, CultureInfo.InvariantCulture, out id))
                {
                    throw new ArgumentException("Invalid lookup field identifier.", "fieldValue");
                }
                result._id = id;

                //
                // Set the value.
                //
                if (index >= 0)
                {
                    index += 2;
                    if (index < fieldValue.Length)
                    {
                        result._value = fieldValue.Substring(index, fieldValue.Length - index);
                    }
                }
                else
                {
                    result._value = "";
                }
            }

            return(result);
        }
コード例 #2
0
        /// <summary>
        /// Parses a string representation of a LookupMulti value to a LookupMultiFieldValue instance.
        /// </summary>
        /// <param name="fieldValue">Field value to parse.</param>
        /// <returns>LookupMultiFieldValue instance representing the specified string value.</returns>
        public static LookupMultiFieldValue Parse(string fieldValue)
        {
            if (string.IsNullOrEmpty(fieldValue))
            {
                return(null);
            }

            LookupMultiFieldValue result = new LookupMultiFieldValue();

            //
            // Keep track of found identifiers to eliminate duplicates.
            //
            Dictionary <int, bool> values = new Dictionary <int, bool>();

            //
            // Remove trailing ;# if present.
            //
            if (fieldValue.StartsWith(";#", StringComparison.Ordinal))
            {
                fieldValue = fieldValue.Substring(2);
            }

            //
            // Find all the id;#value sequences and parse them.
            //
            int b = 0;
            int j;

            while (b < fieldValue.Length)
            {
                //
                // Look for next occurrence of ;#.
                //
                int i = fieldValue.IndexOf(";#", b, StringComparison.Ordinal);

                //
                // If the current position (b) and the position where a delimiter is found are the same, there's no id.
                // In this case we'll need to skip the value part of the pair and move on to the next pair.
                //
                bool skip = (i == b);

                //
                // No more occurrences of delimiters, take the remainder of the string.
                //
                if (i < 0)
                {
                    j = fieldValue.Length;
                }
                //
                // Delimiter found. Skip it, and try to find a corresponding value by looking for the next delimiter.
                //
                else
                {
                    i += 2;
                    if (i < fieldValue.Length)
                    {
                        j = fieldValue.IndexOf(";#", i, StringComparison.Ordinal);

                        if (j < 0)
                        {
                            j = fieldValue.Length;
                        }
                    }
                    else
                    {
                        j = fieldValue.Length;
                    }
                }

                //
                // If the pair was considered valid, i.e. no absent id part, parse it.
                //
                if (!skip)
                {
                    string t = fieldValue.Substring(b, j - b);
                    if (t != ";#")
                    {
                        try
                        {
                            //
                            // Parse the pair and look for duplicates.
                            //
                            var val = LookupFieldValue.Parse(t);
                            if (!values.ContainsKey(val.Id))
                            {
                                values.Add(val.Id, true);
                                result._values.Add(val);
                            }
                        }
                        catch (ArgumentException) { }
                    }
                }

                //
                // Get rid of the last delimiter and move on to the next pair.
                //
                b = j + 2;
            }

            return(result);
        }