Галичев Артем

ObjectPrinting/ObjectPrinter.cs

@@ -1,10 +1,6 @@
-namespace ObjectPrinting
+namespace ObjectPrinting;
+
+public static class ObjectPrinter
 {
-    public class ObjectPrinter
-    {
-        public static PrintingConfig<T> For<T>()
-        {
-            return new PrintingConfig<T>();
-        }
-    }
+    public static PrintingConfig<T> For<T>() => new();
 }

ObjectPrinting/ObjectPrinting.csproj

@@ -5,6 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="8.0.0-alpha.1" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageReference Include="NUnit" Version="4.2.2" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />

ObjectPrinting/ObjectSerializingExtensions.cs

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

ObjectPrinting/PrintingConfig.cs

@@ -1,41 +1,163 @@
 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;
 
 namespace ObjectPrinting
 {
     public class PrintingConfig<TOwner>
     {
-        public string PrintToString(TOwner obj)
+        public Dictionary<Type, Func<object, string>> TypeSerializers { get; } = [];
+        public Dictionary<Type, CultureInfo> Cultures { get; } = [];
+        public Dictionary<PropertyInfo, Func<object, string>> PropertySerializers { get; } = [];
+        public Dictionary<PropertyInfo, int> PropertiesMaxLength { get; } = [];
+
+        private readonly Type[] primitiveTypes =
+        [
+            typeof(int), 
+            typeof(double), 
+            typeof(float), 
+            typeof(string),
+            typeof(DateTime), 
+            typeof(TimeSpan)
+        ];
+        private readonly HashSet<Type> excludingTypes = [];
+        private readonly HashSet<PropertyInfo> excludingProperties = [];
+
+        public PrintingConfig<TOwner> Excluding<TPropertyType>()
+        {
+            excludingTypes.Add(typeof(TPropertyType));
+
+            return this;
+        }
+
+        public PrintingConfig<TOwner> Excluding<TProperty>(Expression<Func<TOwner, TProperty>> memberSelector)
         {
-            return PrintToString(obj, 0);
+            excludingProperties.Add(GetProperty(memberSelector));
+
+            return this;
         }
 
-        private string PrintToString(object obj, int nestingLevel)
+        public TypePrintingConfig<TOwner, TPropertyType> For<TPropertyType>() => new(this);
+
+        public PropertyPrintingConfig<TOwner, TProperty> For<TProperty>(Expression<Func<TOwner, TProperty>> memberSelector) => 
+            new(this, GetProperty(memberSelector));
+
+        public string PrintToString(TOwner obj) => 
+            PrintToString(obj, 0, []);
+
+        private string PrintToString(object obj, int nestingLevel, Dictionary<object, int> parsedObjects)
         {
-            //TODO apply configurations
             if (obj == null)
                 return "null" + Environment.NewLine;
+
+            var type = obj.GetType();
+
+            if (primitiveTypes.Contains(type))
+                return obj + Environment.NewLine;
+
+            if (parsedObjects.TryGetValue(obj, out var level))
+                return $"cycled {type.Name} in level {level}" + Environment.NewLine;
+            parsedObjects.Add(obj, nestingLevel);
 
-            var finalTypes = new[]
+            return obj switch
             {
-                typeof(int), typeof(double), typeof(float), typeof(string),
-                typeof(DateTime), typeof(TimeSpan)
+                IDictionary dictionary => PrintDictionary(dictionary, nestingLevel, parsedObjects),
+                IEnumerable collection => PrintCollection(collection, nestingLevel, parsedObjects),
+                _ => PrintClassProperties(obj, nestingLevel, parsedObjects)
             };
-            if (finalTypes.Contains(obj.GetType()))
-                return obj + Environment.NewLine;
+        }
+
+        private string PrintDictionary(IDictionary dictionary, int nestingLevel, Dictionary<object,int> parsedObjects)
+        {
+            var sb = new StringBuilder();
+            var nextNestingLevel = nestingLevel + 1;
+            var identation = new string('\t', nextNestingLevel);
+            sb.AppendLine("Dictionary");
+
+            foreach (DictionaryEntry kvp in dictionary)
+            {
+                var key = kvp.Key;
+                var value = kvp.Value!;
+
+                sb.Append(identation + PrintToString(key, nestingLevel, parsedObjects).Trim() + 
+                          " : " +
+                          PrintToString(value, nestingLevel, parsedObjects));
+            }
+
+            return sb.ToString();
+        }
 
-            var identation = new string('\t', nestingLevel + 1);
+        private string PrintCollection(IEnumerable collection, int nestingLevel, Dictionary<object,int> parsedObjects)
+        {
             var sb = new StringBuilder();
+            var nextNestingLevel = nestingLevel + 1;
+            var identation = new string('\t', nextNestingLevel);
+
+            sb.AppendLine("Collection");
+            foreach (var element in collection)
+                sb.Append(identation + PrintToString(element, nextNestingLevel, parsedObjects));
+
+            return sb.ToString();
+        }
+
+        private string PrintClassProperties(object obj, int nestingLevel, Dictionary<object, int> parsedObjects)
+        {
             var type = obj.GetType();
+            var sb = new StringBuilder();
+            var nextNestingLevel = nestingLevel + 1;
+            var identation = new string('\t', nextNestingLevel);
+
             sb.AppendLine(type.Name);
             foreach (var propertyInfo in type.GetProperties())
             {
-                sb.Append(identation + propertyInfo.Name + " = " +
-                          PrintToString(propertyInfo.GetValue(obj),
-                              nestingLevel + 1));
+                if (excludingProperties.Contains(propertyInfo) || excludingTypes.Contains(propertyInfo.PropertyType))
+                    continue;
+                sb.Append(identation + 
+                          propertyInfo.Name + 
+                          " = " + 
+                          PrintProperty(obj, propertyInfo, nextNestingLevel, parsedObjects));
             }
+
             return sb.ToString();
         }
+
+        private PropertyInfo GetProperty<TProperty>(Expression<Func<TOwner, TProperty>> memberSelector)
+        {
+            if (memberSelector.Body is not MemberExpression memberExpression)
+                throw new ArgumentException($"Expression refers to a method, not a property.");
+
+            return (memberExpression.Member as PropertyInfo)!;
+        }
+
+        private string PrintProperty(
+            object obj,
+            PropertyInfo propertyInfo,
+            int nextNestingLevel,
+            Dictionary<object, int> parsedObjects)
+        {
+            string? result = null;
+            var propertyValue = propertyInfo.GetValue(obj)!;
+
+            if (PropertySerializers.TryGetValue(propertyInfo, out var propertySerializer))
+                result = propertySerializer(propertyValue);
+            else if (TypeSerializers.TryGetValue(propertyInfo.PropertyType, out var typeSerializer))
+                result = typeSerializer(propertyValue);
+            else if (PropertiesMaxLength.TryGetValue(propertyInfo, out var maxLength))
+            {
+                var propertyString = (propertyValue as string)!;
+                result = propertyString[..Math.Min(propertyString.Length, maxLength)];
+            }
+            else if (Cultures.TryGetValue(propertyInfo.PropertyType, out var culture))
+                result = string.Format(culture, "{0}", propertyValue);
+
+            return result == null ? 
+                PrintToString(propertyValue, nextNestingLevel, parsedObjects) : 
+                result + Environment.NewLine;
+        }
     }
 }

ObjectPrinting/PropertyPrintingConfig.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Reflection;
+
+namespace ObjectPrinting;
+
+public class PropertyPrintingConfig<TOwner, TProperty>(PrintingConfig<TOwner> headConfig, PropertyInfo propertyInfo)
+{
+    public PrintingConfig<TOwner> HeadConfig => headConfig;
+    public PropertyInfo PropertyInfo => propertyInfo;
+
+    public PrintingConfig<TOwner> Using(Func<TProperty, string> printing)
+    {
+        HeadConfig.PropertySerializers[propertyInfo] = p => printing((TProperty)p);
+
+        return HeadConfig;
+    }
+}

ObjectPrinting/PropertyPrintingConfigExtensions.cs

@@ -0,0 +1,15 @@
+namespace ObjectPrinting;
+
+public static class PropertyPrintingConfigExtensions
+{
+    public static PrintingConfig<TOwner> MaxLength<TOwner>(
+        this PropertyPrintingConfig<TOwner, string> propertyPrintingConfig,
+        int maxLen)
+    {
+        var headConfig = propertyPrintingConfig.HeadConfig;
+
+        headConfig.PropertiesMaxLength[propertyPrintingConfig.PropertyInfo] = maxLen;
+
+        return headConfig;
+    }
+}