예제 #1
0
        /// <summary>
        /// Registers a custom formatter that represents an object in a readable text format.
        /// </summary>
        /// <param name="type">The type of the object to format.</param>
        /// <param name="formatter">A delegate that performs the formatting operation.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="type"/> or <paramref name="formatter"/> is null.</exception>
        /// <exception cref="InvalidOperationException">Thrown if a custom formatter for the specified type was already registered.</exception>
        public void Register(Type type, FormattingFunc formatter)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }
            if (formatter == null)
            {
                throw new ArgumentNullException("formatter");
            }

            lock (syncRoot)
            {
                Data data;

                if (formatters.TryGetValue(type, out data))
                {
                    data.Count++;
                }
                else
                {
                    formatters[type] = new Data(formatter);
                }
            }
        }
        /// <summary>
        /// Constructs a custom conversion rule.
        /// </summary>
        /// <param name="formatterFunc">The formatting operation.</param>
        public CustomFormattingRule(FormattingFunc formatterFunc)
        {
            if (formatterFunc == null)
                throw new ArgumentNullException("formatterFunc");

            this.formatterFunc = formatterFunc;
        }
예제 #3
0
        /// <summary>
        /// Registers a strongly-tped custom formatter for the specified types.
        /// </summary>
        /// <typeparam name="T">The type of the object to format.</typeparam>
        /// <param name="formatter">A delegate that performs the formatting operation.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="formatter"/> is null.</exception>
        /// <exception cref="InvalidOperationException">Thrown if a custom formatter for the specified type was already registered.</exception>
        public void Register <T>(FormattingFunc <T> formatter)
        {
            if (formatter == null)
            {
                throw new ArgumentNullException("formatter");
            }

            Register(typeof(T), x => formatter((T)x));
        }
예제 #4
0
        /// <summary>
        /// Constructs a custom conversion rule.
        /// </summary>
        /// <param name="formatterFunc">The formatting operation.</param>
        public CustomFormattingRule(FormattingFunc formatterFunc)
        {
            if (formatterFunc == null)
            {
                throw new ArgumentNullException("formatterFunc");
            }

            this.formatterFunc = formatterFunc;
        }
예제 #5
0
        public void IsRegisteredFor_should_return_true_for_registered_type()
        {
            var customFormatters = new CustomFormatters();

            customFormatters.Register <Foo>(x => String.Empty);
            FormattingFunc func = customFormatters.Find(typeof(Foo));

            Assert.IsNotNull(func);
        }
예제 #6
0
        public void Formats()
        {
            var customFormatters = new CustomFormatters();

            customFormatters.Register <Foo>(x => String.Format("Foo's value is {0}.", x.Value));
            FormattingFunc func   = customFormatters.Find(typeof(Foo));
            string         output = func(new Foo(123));

            Assert.AreEqual("Foo's value is 123.", output);
        }
예제 #7
0
        public void Register_and_unregister_ok()
        {
            var customFormatters = new CustomFormatters();

            customFormatters.Register <Foo>(x => String.Empty);
            customFormatters.Unregister <Foo>();
            FormattingFunc func = customFormatters.Find(typeof(Foo));

            Assert.IsNull(func);
        }
예제 #8
0
        private IFormattingRule GetPreferredRule(Type type)
        {
            lock (preferredRules)
            {
                IFormattingRule preferredRule;

                if (!preferredRules.TryGetValue(type, out preferredRule))
                {
                    // Try to get a custom user converter.
                    FormattingFunc operation = extensionPoints.CustomFormatters.Find(type);
                    preferredRule = (operation != null) ? new CustomFormattingRule(operation) : GetPreferredRuleWithoutCache(type);
                    preferredRules.Add(type, preferredRule);
                }

                return(preferredRule);
            }
        }
예제 #9
0
 public Data(FormattingFunc formatter)
 {
     this.formatter = formatter;
 }