Овечкин Илья

ObjectPrinting/Config.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System;
+
+namespace ObjectPrinting
+{
+    public class Config
+    {
+        public HashSet<object> serializedObjects;
+        public HashSet<Type> excludedTypes;
+        public HashSet<PropertyInfo> excludedProperties;
+        public Dictionary<Type, CultureInfo> cultures;
+        public Dictionary<Type, Delegate> typeSerialization;
+        public Dictionary<PropertyInfo, Delegate> propertiesSerialization;
+
+        public Config() 
+        {
+            serializedObjects = new HashSet<object>();
+            excludedTypes = new HashSet<Type>();
+            excludedProperties = new HashSet<PropertyInfo>();
+            cultures = new Dictionary<Type, CultureInfo>();
+            typeSerialization = new Dictionary<Type, Delegate>();
+            propertiesSerialization = new Dictionary<PropertyInfo, Delegate>();
+
+        }
+
+    }
+}

ObjectPrinting/ObjectPrinting.csproj

@@ -7,8 +7,10 @@
   </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" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
   </ItemGroup>
 
 </Project>

ObjectPrinting/PrintingConfig.cs

@@ -1,41 +1,125 @@
+using NUnit.Framework;
 using System;
 using System.Linq;
 using System.Text;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Globalization;
+using System.Linq.Expressions;
+using System.Collections;
 
 namespace ObjectPrinting
 {
     public class PrintingConfig<TOwner>
     {
+        private readonly Config configuration;
+        private readonly Type[] finalTypes;
+
+        public PrintingConfig() 
+        { 
+            configuration = new Config();
+            finalTypes = new[]
+            {
+                typeof(int), typeof(double), typeof(float), typeof(string),
+                typeof(DateTime), typeof(TimeSpan), typeof(Guid)
+            };
+        }
+
+        public PrintingConfig<TOwner> Excluding<Type>()
+        {
+            configuration.excludedTypes.Add(typeof(Type));
+            return this;
+        }
+
+        public PrintingConfig<TOwner> Excluding<Property>(Expression<Func<TOwner, Property>> memberSelector)
+        {
+            var propInfo = ((MemberExpression)memberSelector.Body).Member as PropertyInfo;
+            configuration.excludedProperties.Add(propInfo);
+            return this;
+        }
+
+        public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>()
+        {
+            return new PropertyPrintingConfig<TOwner, TPropType>(this, configuration);
+        }
+
+        public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>(Expression<Func<TOwner, TPropType>> memberSelector)
+        {
+            var propInfo = ((MemberExpression)memberSelector.Body).Member as PropertyInfo;
+            return new PropertyPrintingConfig<TOwner, TPropType>(this, configuration, propInfo);
+        }
+
         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[]
+            var type = obj.GetType();
+
+            if (finalTypes.Contains(type))
             {
-                typeof(int), typeof(double), typeof(float), typeof(string),
-                typeof(DateTime), typeof(TimeSpan)
-            };
-            if (finalTypes.Contains(obj.GetType()))
+                if(configuration.cultures.TryGetValue(type, out var culture))
+                    return Convert.ToString(obj, culture) + Environment.NewLine;
                 return obj + Environment.NewLine;
+            }
 
+            if (obj is ICollection collection)
+                return SerializeCollection(collection, nestingLevel);
+
+            configuration.serializedObjects.Add(obj);
             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())
+            var sb = new StringBuilder().Append(type.Name + Environment.NewLine);
+            var properties = type.GetProperties().Where(propInfo => 
+                !configuration.excludedProperties.Contains(propInfo) && 
+                !configuration.excludedTypes.Contains(propInfo.PropertyType));
+
+            foreach (var propertyInfo in properties)
             {
-                sb.Append(identation + propertyInfo.Name + " = " +
-                          PrintToString(propertyInfo.GetValue(obj),
-                              nestingLevel + 1));
+                var propertyValue = propertyInfo.GetValue(obj);
+                if (configuration.serializedObjects.Contains(propertyValue))
+                    continue;
+                if (configuration.typeSerialization.TryGetValue(propertyInfo.PropertyType, out var typeSerializer))
+                    sb.Append(identation + propertyInfo.Name + " = " + typeSerializer.DynamicInvoke(propertyValue) + Environment.NewLine);
+                else if (configuration.propertiesSerialization.TryGetValue(propertyInfo, out var propSerializer))
+                    sb.Append(identation + propertyInfo.Name + " = " + propSerializer.DynamicInvoke(propertyValue) + Environment.NewLine);
+                else
+                    sb.Append(identation + propertyInfo.Name + " = " + PrintToString(propertyValue, nestingLevel + 1));
             }
             return sb.ToString();
         }
+
+        private string SerializeCollection(ICollection collection, int nestingLevel)
+        {
+            if (collection is IDictionary dictionary)
+                return SerializeDictionary(dictionary, nestingLevel);
+
+            var sb = new StringBuilder();
+            foreach (var item in collection)
+                sb.Append(PrintToString(item, nestingLevel + 1).Trim() + " ");
+
+            return $"[ {sb}]" + Environment.NewLine;
+        }
+
+        private string SerializeDictionary(IDictionary dictionary, int nestingLevel)
+        {
+            var sb = new StringBuilder();
+            var identation = new string('\t', nestingLevel);
+            sb.Append(identation + "{" + Environment.NewLine);
+            foreach (DictionaryEntry keyValuePair in dictionary)
+            {
+                identation = new string('\t', nestingLevel + 1);
+                sb.Append(identation + "[" + PrintToString(keyValuePair.Key, nestingLevel + 1).Trim() + " - ");
+                sb.Append(PrintToString(keyValuePair.Value, 0).Trim());
+                sb.Append("],");
+                sb.Append(Environment.NewLine);
+            }
+
+            return sb + "}" + Environment.NewLine;
+        }
     }
 }

ObjectPrinting/PropertyPrintingConfig.cs

@@ -0,0 +1,57 @@
+using NUnit.Framework;
+using System;
+using System.Linq;
+using System.Text;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Globalization;
+using System.Linq.Expressions;
+using Newtonsoft.Json.Linq;
+using System.Text.RegularExpressions;
+
+namespace ObjectPrinting
+{
+    public class PropertyPrintingConfig<TOwner, TPropType>
+    {
+        private readonly PrintingConfig<TOwner> printingConfig;
+        private readonly Config configuration;
+        private readonly PropertyInfo propertyInfo;
+
+
+        public PropertyPrintingConfig(PrintingConfig<TOwner> printingConfig, Config configuration,  PropertyInfo propertyInfo = null)
+        {
+            this.printingConfig = printingConfig;
+            this.configuration = configuration;
+            this.propertyInfo = propertyInfo;
+        }
+
+        public PrintingConfig<TOwner> Using(Func<TPropType, string> print)
+        {
+            if (propertyInfo == null)
+            {
+                if (!configuration.typeSerialization.ContainsKey(typeof(TPropType)))
+                    configuration.typeSerialization.Add(typeof(TPropType), print);
+                else
+                    configuration.typeSerialization[typeof(TPropType)] = print;
+            }
+            else
+            {
+                if (!configuration.propertiesSerialization.ContainsKey(propertyInfo))
+                    configuration.propertiesSerialization.Add(propertyInfo, print);
+                else
+                    configuration.propertiesSerialization[propertyInfo] = print;
+            }
+            configuration.typeSerialization[typeof(TPropType)] = print;
+            return printingConfig;
+        }
+
+        public PrintingConfig<TOwner> Using(CultureInfo culture)
+        {
+            configuration.cultures.Add(typeof(TPropType), culture);
+            return printingConfig;
+        }
+
+        public PrintingConfig<TOwner> ParentConfig => printingConfig;
+
+    }
+}

ObjectPrinting/PropertyPrintingConfigExtensions.cs

@@ -0,0 +1,23 @@
+using NUnit.Framework;
+using System;
+using System.Linq;
+using System.Text;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Globalization;
+using System.Linq.Expressions;
+using Newtonsoft.Json.Linq;
+using System.Text.RegularExpressions;
+
+namespace ObjectPrinting
+{
+    public static class PropertyPrintingConfigExtensions
+    {
+        public static PrintingConfig<TOwner> TrimmedToLength<TOwner>(this PropertyPrintingConfig<TOwner, string> propConfig, int maxLen)
+        {
+            propConfig.Using(property => property.Substring(0,Math.Min(maxLen, property.Length)).ToString());
+            return propConfig.ParentConfig;
+        }
+
+    }
+}