Esempio n. 1
0
        public static bool TryGetResolver(string value, out BindingParameterResolver resolver)
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new ArgumentNullException("value");
            }

            resolver = _resolvers.FirstOrDefault(p => value.StartsWith(p.Name, StringComparison.OrdinalIgnoreCase));
            return(resolver != null);
        }
Esempio n. 2
0
        public static bool IsSystemParameter(string value)
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new ArgumentNullException("value");
            }

            BindingParameterResolver resolver = null;

            return(TryGetResolver(value, out resolver));
        }
Esempio n. 3
0
        internal static bool IsValidIdentifier(string identifier)
        {
            // built-in sysetem identifiers are valid
            if (BindingParameterResolver.IsSystemParameter(identifier))
            {
                return(true);
            }

            // match against our identifier regex
            // note that system identifiers include a '-' character so wouldn't
            // pass this test
            return(Regex.IsMatch(identifier, IdentifierPattern));
        }
Esempio n. 4
0
        public static BindingTemplateToken NewExpression(string expression)
        {
            // BindingData takes precedence over builtins.
            BindingParameterResolver builtin;

            BindingParameterResolver.TryGetResolver(expression, out builtin);

            // check for formatter, which is applied to finale results.
            string format = null;

            if (builtin == null)
            {
                int indexColon = expression.IndexOf(':');
                if (indexColon > 0)
                {
                    format     = expression.Substring(indexColon + 1);
                    expression = expression.Substring(0, indexColon);
                }
            }

            if (!BindingTemplateParser.IsValidIdentifier(expression))
            {
                throw new FormatException($"Invalid template expression '{expression}");
            }

            // Expression is just a series of dot operators like:  a.b.c
            var parts = expression.Split('.');

            // For backwards compat, first part can't have a '-'
            if (builtin == null)
            {
                if (parts[0].IndexOf('-') >= 0)
                {
                    throw new FormatException($"The parameter name '{parts[0]}' is invalid.");
                }
            }

            foreach (var part in parts)
            {
                if (string.IsNullOrWhiteSpace(part))
                {
                    throw new InvalidOperationException($"Illegal expression: {parts}");
                }
            }

            return(new ExpressionToken(parts, format, builtin));
        }
Esempio n. 5
0
        /// <summary>
        /// Resolves original parameterized template into a string by replacing parameters with values provided as
        /// a dictionary.
        /// </summary>
        /// <param name="parameters">Dictionary providing parameter values.</param>
        /// <returns>Resolved string if succeeded.</returns>
        /// <exception cref="InvalidOperationException">Thrown when required parameter value is not available.
        /// </exception>
        public string Bind(IReadOnlyDictionary <string, string> parameters)
        {
            StringBuilder builder = new StringBuilder();

            if (_ignoreCase && parameters != null)
            {
                // convert to a case insensitive dictionary
                var caseInsensitive = new Dictionary <string, string>(parameters.Count, StringComparer.OrdinalIgnoreCase);
                foreach (var pair in parameters)
                {
                    caseInsensitive.Add(pair.Key, pair.Value);
                }
                parameters = caseInsensitive;
            }

            foreach (BindingTemplateToken token in Tokens)
            {
                if (token.IsParameter)
                {
                    string value;
                    BindingParameterResolver resolver = null;
                    if (parameters != null && parameters.TryGetValue(token.Value, out value))
                    {
                        // parameter is resolved from binding data
                        builder.Append(value);
                    }
                    else if (BindingParameterResolver.TryGetResolver(token.Value, out resolver))
                    {
                        // parameter maps to one of the built-in system binding
                        // parameters (e.g. rand-guid, datetime, etc.)
                        value = resolver.Resolve(token.Value);
                        builder.Append(value);
                    }
                    else
                    {
                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, "No value for named parameter '{0}'.", token.Value));
                    }
                }
                else
                {
                    builder.Append(token.Value);
                }
            }

            return(builder.ToString());
        }
Esempio n. 6
0
 public ExpressionToken(string[] expressionParts, string format, BindingParameterResolver builtin)
 {
     _expressionParts = expressionParts;
     _builtin         = builtin;
     _format          = format;
 }