Конина Анастасия

ObjectPrinting/IPropertyPrintingConfig.cs

@@ -0,0 +1,7 @@
+namespace ObjectPrinting
+{
+    public interface IPropertyPrintingConfig<TOwner, TPropType>
+    {
+        PrintingConfig<TOwner> ParentConfig { get; }
+    }
+}

ObjectPrinting/ObjectExtensions.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace ObjectPrinting
+{
+    public static class ObjectExtensions
+    {
+        public static string PrintToString<T>(this T obj)
+        {
+            return ObjectPrinter.For<T>().PrintToString(obj);
+        }
+    }
+}

ObjectPrinting/ObjectPrinting.csproj

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="6.12.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />
   </ItemGroup>

ObjectPrinting/PrintingConfig.cs

@@ -1,41 +1,108 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
 using System.Text;
+using ObjectPrinting.Solved;
 
 namespace ObjectPrinting
 {
     public class PrintingConfig<TOwner>
     {
+        private readonly Type[] finalTypes =
+        {
+            typeof(int), typeof(double), typeof(float), typeof(string),
+            typeof(DateTime), typeof(TimeSpan)
+        };
+
+        private readonly HashSet<Type> excludedTypes = new HashSet<Type>();
+        private readonly HashSet<MemberInfo> excludedMembers = new HashSet<MemberInfo>();
+
+        private readonly Dictionary<Type, Func<object, string>> typePrintingRules =
+            new Dictionary<Type, Func<object, string>>();
+
+        private readonly Dictionary<MemberInfo, Func<object, string>> memberPrintingRules =
+            new Dictionary<MemberInfo, Func<object, string>>();
+
+        private readonly Dictionary<Type, CultureInfo> typeCultures = new Dictionary<Type, CultureInfo>();
+        private readonly Dictionary<MemberInfo, CultureInfo> memberCultures = new Dictionary<MemberInfo, CultureInfo>();
+
+        private readonly Dictionary<MemberInfo, Func<string, string>> memberTrimToLength =
+            new Dictionary<MemberInfo, Func<string, string>>();
+
+        private Func<string, string> globalTrimToLength = x => x;
+        private MemberInfo currentMember;
+
+        public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>()
+        {
+            return new PropertyPrintingConfig<TOwner, TPropType>(this);
+        }
+
+        public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>(
+            Expression<Func<TOwner, TPropType>> memberSelector)
+        {
+            currentMember = ((MemberExpression) memberSelector.Body).Member;
+            return new PropertyPrintingConfig<TOwner, TPropType>(this);
+        }
+
+        public PrintingConfig<TOwner> Excluding<TPropType>(Expression<Func<TOwner, TPropType>> memberSelector)
+        {
+            currentMember = ((MemberExpression) memberSelector.Body).Member;
+            excludedMembers.Add(currentMember);
+            return this;
+        }
+
+        public PrintingConfig<TOwner> Excluding<TPropType>()
+        {
+            excludedTypes.Add(typeof(TPropType));
+            return this;
+        }
+
+
+        public void SetPrintingRule<TPropType>(Func<TPropType, string> print)
+        {
+            if (currentMember == null)
+                typePrintingRules[typeof(TPropType)] = x => print((TPropType) x);
+            else
+                memberPrintingRules[currentMember] = x => print((TPropType) x);
+            currentMember = null;
+        }
+
+        public void SetCulture<TPropType>(CultureInfo culture)
+        {
+            if (currentMember == null)
+                typeCultures[typeof(TPropType)] = culture;
+            else
+                memberCultures[currentMember] = culture;
+            currentMember = null;
+        }
+
+        public void SetMaxLength(int maxLen)
+        {
+            if (currentMember == null)
+                globalTrimToLength = x => x.Substring(0, Math.Min(x.Length, maxLen));
+
+            else
+                memberTrimToLength[currentMember] = x => x.Substring(0, Math.Min(x.Length, maxLen));
+
+
+            currentMember = null;
+        }
+
         public string PrintToString(TOwner obj)
         {
-            return PrintToString(obj, 0);
-        }
-
-        private string PrintToString(object obj, int nestingLevel)
-        {
-            //TODO apply configurations
-            if (obj == null)
-                return "null" + Environment.NewLine;
-
-            var finalTypes = new[]
-            {
-                typeof(int), typeof(double), typeof(float), typeof(string),
-                typeof(DateTime), typeof(TimeSpan)
-            };
-            if (finalTypes.Contains(obj.GetType()))
-                return obj + Environment.NewLine;
-
-            var identation = new string('\t', nestingLevel + 1);
-            var sb = new StringBuilder();
-            var type = obj.GetType();
-            sb.AppendLine(type.Name);
-            foreach (var propertyInfo in type.GetProperties())
-            {
-                sb.Append(identation + propertyInfo.Name + " = " +
-                          PrintToString(propertyInfo.GetValue(obj),
-                              nestingLevel + 1));
-            }
-            return sb.ToString();
+            var serialization = new Serialization(new SerializationConfig(excludedTypes,
+                excludedMembers,
+                typePrintingRules,
+                memberPrintingRules,
+                typeCultures,
+                memberCultures,
+                memberTrimToLength,
+                globalTrimToLength));
+            return serialization.Serialize(obj);
         }
     }
 }

ObjectPrinting/PropertyPrintingConfig.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Globalization;
+
+namespace ObjectPrinting
+{
+    public class PropertyPrintingConfig<TOwner, TPropType> : IPropertyPrintingConfig<TOwner, TPropType>
+    {
+        private readonly PrintingConfig<TOwner> printingConfig;
+
+        public PropertyPrintingConfig(PrintingConfig<TOwner> printingConfig)
+        {
+            this.printingConfig = printingConfig;
+        }
+
+        public PrintingConfig<TOwner> Using(Func<TPropType, string> print)
+        {
+            printingConfig.SetPrintingRule(print);
+            return printingConfig;
+        }
+
+        PrintingConfig<TOwner> IPropertyPrintingConfig<TOwner, TPropType>.ParentConfig => printingConfig;
+    }
+}

ObjectPrinting/PropertyPrintingConfigExtensions.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Globalization;
+
+namespace ObjectPrinting
+{
+    public static class PropertyPrintingConfigExtensions
+    {
+        public static string PrintToString<T>(this T obj, Func<PrintingConfig<T>, PrintingConfig<T>> config)
+        {
+            return config(ObjectPrinter.For<T>()).PrintToString(obj);
+        }
+
+        public static PrintingConfig<TOwner> SetMaxLength<TOwner>(
+            this PropertyPrintingConfig<TOwner, string> propConfig, int maxLen)
+        {
+            var propertyConfig = ((IPropertyPrintingConfig<TOwner, string>) propConfig).ParentConfig;
+
+            propertyConfig.SetMaxLength(maxLen);
+            return propertyConfig;
+        }
+
+        public static PrintingConfig<TOwner> Using<TOwner, TPropType>(
+            this PropertyPrintingConfig<TOwner, TPropType> propConfig, CultureInfo culture)
+            where TPropType : IFormattable
+        {
+            var printingConfig = ((IPropertyPrintingConfig<TOwner, TPropType>) propConfig).ParentConfig;
+            printingConfig.SetCulture<TPropType>(culture);
+            return printingConfig;
+        }
+    }
+}

ObjectPrinting/Serialization.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+
+namespace ObjectPrinting
+{
+    public class Serialization
+    {
+        private readonly SerializationConfig serializationConfig;
+        public Serialization(SerializationConfig serializationConfig)
+        {
+            this.serializationConfig = serializationConfig;
+        }
+
+        public string Serialize(object obj)
+        {
+            return PrintToString(obj, 0);
+        }
+
+        private string PrintToString(object obj, int nestingLevel)
+        {
+            if (nestingLevel > 100)
+                return "";
+
+            if (obj == null)
+                return "null";
+
+
+            if (serializationConfig.TypePrintingRules.TryGetValue(obj.GetType(), out var typePrintingRule))
+                return typePrintingRule(obj).ToString();
+
+            if (serializationConfig.FinalTypes.Contains(obj.GetType()))
+            {
+                if (serializationConfig.TypeCultures.TryGetValue(obj.GetType(), out var cultureInfo))
+                    return ((dynamic) obj).ToString(cultureInfo);
+                return obj.ToString();
+            }
+
+            return obj switch
+            {
+                IDictionary dictionary => SerializeDictionary(dictionary, nestingLevel),
+                IEnumerable enumerable => SerializeIEnumerable(enumerable, nestingLevel),
+                _ => SerializeMembers(obj, nestingLevel)
+            };
+        }
+
+        private string SerializeDictionary(IDictionary dictionary, int nestingLevel)
+        {
+            var sb = new StringBuilder();
+            var identation = new string('\t', nestingLevel + 1);
+            sb.AppendLine("{");
+            foreach (var key in dictionary.Keys)
+            {
+                sb.Append(identation + "{" + PrintToString(key, nestingLevel + 1) + Environment.NewLine
+                          + identation + ":" + PrintToString(dictionary[key], nestingLevel + 1) + "},"
+                          + Environment.NewLine);
+            }
+
+            sb.Append(identation + "}");
+            return sb.ToString();
+        }
+
+        private string SerializeIEnumerable(IEnumerable obj, int nestingLevel)
+        {
+            var identation = new string('\t', nestingLevel + 1);
+            var stringBuilder = new StringBuilder();
+            stringBuilder.AppendLine("[");
+            foreach (var key in obj)
+                stringBuilder.AppendLine(identation + PrintToString(key, nestingLevel + 1) + ",");
+
+            stringBuilder.Append(identation + "]");
+            var serializedIEnumerable = stringBuilder.ToString();
+
+            var lastIndexOf = serializedIEnumerable.LastIndexOf(",", StringComparison.Ordinal);
+            if (lastIndexOf != -1)
+                return serializedIEnumerable.Remove(lastIndexOf, 1);
+            return serializedIEnumerable;
+        }
+
+        private bool IsExcludedMember(MemberInfo memberInfo)
+        {
+            if ((memberInfo.MemberType & MemberTypes.Field) != 0)
+                return serializationConfig.ExcludedTypes.Contains((memberInfo as FieldInfo)?.FieldType) ||
+                       serializationConfig.ExcludedMembers.Contains(memberInfo);
+
+            if ((memberInfo.MemberType & MemberTypes.Property) != 0)
+                return serializationConfig.ExcludedTypes.Contains((memberInfo as PropertyInfo)?.PropertyType) ||
+                       serializationConfig.ExcludedMembers.Contains(memberInfo);
+
+            return false;
+        }
+
+
+        private string SerializeMembers(object obj, int nestingLevel)
+        {
+            var identation = new string('\t', nestingLevel + 1);
+            var sb = new StringBuilder();
+            var type = obj.GetType();
+            sb.Append(type.Name);
+            foreach (var memberInfo in type.GetMembers()
+                .Where(IsFieldOrProperty).Where(x => !IsExcludedMember(x)))
+            {
+                var value = GetValue(obj, memberInfo);
+
+                if (value != null && value.Equals(obj))
+                    continue;
+
+                sb.Append(Environment.NewLine + identation + memberInfo.Name + " = " +
+                          SerializeValue(nestingLevel, memberInfo, value));
+            }
+
+            return sb.ToString();
+        }
+
+        private string SerializeValue(int nestingLevel, MemberInfo memberInfo, object value)
+        {
+            var sb = "";
+
+            if (serializationConfig.MemberPrintingRules.TryGetValue(memberInfo, out var rule))
+                sb = rule(value);
+            else if (serializationConfig.MemberCultures.TryGetValue(memberInfo, out var cultureInfo))
+                sb = ((dynamic) value).ToString(cultureInfo);
+            else
+                sb = (PrintToString(value, nestingLevel + 1));
+
+            sb = serializationConfig.GlobalTrimToLength(sb);
+
+            if (serializationConfig.MemberTrimToLength.TryGetValue(memberInfo, out var trimRule))
+                return trimRule(sb);
+            return sb;
+        }
+
+        private static bool IsFieldOrProperty(MemberInfo memberInfo) =>
+            memberInfo.MemberType == MemberTypes.Field || memberInfo.MemberType == MemberTypes.Property;
+
+
+        private static object GetValue(object obj, MemberInfo memberInfo)
+        {
+            if ((memberInfo.MemberType & MemberTypes.Field) != 0)
+                return (memberInfo as FieldInfo)?.GetValue(obj);
+
+            if ((memberInfo.MemberType & MemberTypes.Property) != 0)
+                return (memberInfo as PropertyInfo)?.GetValue(obj);
+
+            return null;
+        }
+    }
+}