C# IFormatter.Format方法代码示例

        /// <inheritdoc />
        public string Format(object obj, IFormatter formatter)
        {
            Type type = obj.GetType();
            PropertyInfo keyProperty = type.GetProperty("Key");
            PropertyInfo valueProperty = type.GetProperty("Value");

            object key = keyProperty.GetValue(obj, null);
            object value = valueProperty.GetValue(obj, null);

            return string.Concat(formatter.Format(key), ": ", formatter.Format(value));
        }

        public override string FormatMessage(IFormatter<object> formatter)
        {
            if(ActualValue == null)
                return string.Format(ExpectMessages.EqualFormat, formatter.Format(null), formatter.Format(ExpectedString));
            var n = ActualString.IndexOfDifference(ExpectedString);
            var displayActual = formatter.Format(Center(ActualString, n, DisplayWidth));
            var displayExpected = formatter.Format(Center(ExpectedString, n, DisplayWidth));

            var format = string.Format("{0}\n{1}\n{2}^", Preamble, MessageFormat,
                new string('-', displayActual.IndexOfDifference(displayExpected) + ExpectMessages.EqualFormat.IndexOf('{')));
            return string.Format(format, displayActual, displayExpected);
        }

        public void Print(Client client, IFormatter formatter)
        {
            var result = formatter.Format(client);

            Console.WriteLine(result);

            // class Print does nto suit format strings, so to keep OOP principles
            // we create StringBasicFormat - a class only to format string when we need it
        }

        /// <inheritdoc />
        public string Format(object obj, IFormatter formatter)
        {
            var enumerable = (IEnumerable)obj;

            var str = new StringBuilder();
            str.Append('[');

            bool first = true;
            foreach (object value in enumerable)
            {
                if (first)
                    first = false;
                else
                    str.Append(", ");

                str.Append(formatter.Format(value));
            }

            str.Append(']');
            return str.ToString();
        }

 public virtual string FormatExpression(IFormatter<Expression> formatter)
 {
     return formatter.Format(body);
 }

 public string ToString(IFormatter<object> formatter)
 {
     return formatter.Format(Value);
 }

 public virtual string FormatActual(IFormatter<object> formatter)
 {
     return formatter.Format(Actual);
 }

 static void Format(IFormatter f) => Console.WriteLine(f.Format(1, 2, 3));

 public override string FormatExpected(IFormatter<object> formatter)
 {
     return string.Format(methodDisplay(arguments), formatter.Format(arguments[0]));
 }

 public void Setup()
 {
     _baseDate = DateTime.Now;
     _numberOfObjects = 10;
     _objectsToFormat = new List<DummyObject>();
     for (int i = 0; i < _numberOfObjects; i++)
     {
         _objectsToFormat.Add(new DummyObject()
                                  {
                                      SomeInt = i,
                                      SomeString = i.ToString(),
                                      SomeDateTime = _baseDate.AddDays(i),
                                      CompositeObj = new DummyObject() {SomeInt = 10 + i}
                                  });
     }
     _formatter = new Formatter<DummyObject>()
         .With(y => y.SomeInt, 0, 5, y => y.ToString("00000"))
         .With(y => y.SomeString, 2, 6, y => y.ToString().PadLeft(6, '_'))
         .With(y => y.SomeDateTime, 1, 8, y => y.ToString(_dateFormat))
         .WithDelimiter(";");
     _result = _formatter.Format(_objectsToFormat);
 }

        private static string FormatRecursive(object obj, IFormatter formatter)
        {
            Type objType = obj.GetType();

            var result = new StringBuilder();
            result.Append('{');
            result.Append(objType);
            result.Append(": ");

            var accessors = new List<KeyValuePair<string, Func<object, object>>>();
            foreach (FieldInfo field in objType.GetFields(BindingFlags.Instance | BindingFlags.Public))
            {
                accessors.Add(new KeyValuePair<string, Func<object, object>>(field.Name, field.GetValue));
            }

            foreach (PropertyInfo property in objType.GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                PropertyInfo capturedProperty = property; // avoid unintended variable capture in the lambda.
                if (property.CanRead && property.GetIndexParameters().Length == 0)
                    accessors.Add(new KeyValuePair<string, Func<object, object>>(property.Name,
                        x => capturedProperty.GetValue(x, null)));
            }

            accessors.Sort((a, b) => a.Key.CompareTo(b.Key));

            for (int i = 0; i < accessors.Count; i++)
            {
                object value;
                try
                {
                    value = accessors[i].Value(obj);
                }
                catch (Exception)
                {
                    continue;
                }

                if (i != 0)
                    result.Append(", ");

                result.Append(accessors[i].Key);
                result.Append(" = ");
                result.Append(formatter.Format(value));
            }

            result.Append('}');
            return result.ToString();
        }

 /// <inheritdoc />
 public string Format(object obj, IFormatter formatter)
 {
     var entry = (DictionaryEntry)obj;
     return string.Concat(formatter.Format(entry.Key), ": ", formatter.Format(entry.Value));
 }

 public override string FormatExpected(IFormatter<object> formatter) {
     return string.Format("url ending with {0}", formatter.Format(arguments[1]));
 }

 // This method takes an object that supports the IFormatter
 // interface. It will call that object's Format() method.
 private static void FormatRecord(IFormatter record)
 {
     record.Format();
 }

 public void Print(string name, IFormatter formatter)
 {
     Console.WriteLine(formatter.Format(name));
 }