Козлов Данил

ObjectPrinting/MemberInfoExtension.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Reflection;
+
+namespace ObjectPrinting
+{
+    public static class MemberInfoExtension
+    {
+        public static object GetMemberValue(this MemberInfo memberInfo, object obj)
+        {
+            return memberInfo switch
+            {
+                PropertyInfo propertyInfo => propertyInfo.GetValue(obj),
+                FieldInfo fieldInfo => fieldInfo.GetValue(obj),
+                _ => throw new InvalidOperationException()
+            };
+        }
+
+        public static Type GetMemberType(this MemberInfo memberInfo)
+        {
+            return memberInfo switch
+            {
+                PropertyInfo propertyInfo => propertyInfo.PropertyType,
+                FieldInfo fieldInfo => fieldInfo.FieldType,
+                _ => throw new InvalidOperationException()
+            };
+        }
+    }
+}

ObjectPrinting/ObjectPrinting.csproj

@@ -1,14 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <LangVersion>8</LangVersion>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
-    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
-  </PropertyGroup>
+    <PropertyGroup>
+        <LangVersion>9.0</LangVersion>
+        <TargetFramework>net8.0</TargetFramework>
+        <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
-    <PackageReference Include="NUnit" Version="3.12.0" />
-  </ItemGroup>
+    <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,190 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Globalization;
 using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
 using System.Text;
 
 namespace ObjectPrinting
 {
     public class PrintingConfig<TOwner>
     {
+        private static readonly HashSet<Type> _finalTypes = new()
+        {
+            typeof(int), typeof(uint), typeof(double), typeof(float), typeof(decimal),
+            typeof(long), typeof(ulong), typeof(short), typeof(ushort),
+            typeof(string), typeof(bool),
+            typeof(DateTime), typeof(TimeSpan), typeof(Guid)
+        };
+
+        private readonly HashSet<MemberInfo> excludedProperties = new();
+        private readonly HashSet<Type> excludedTypes = new();
+        protected readonly Dictionary<MemberInfo, int> propertiesMaxLength = new();
+        protected readonly Dictionary<MemberInfo, Func<object, string>> propertiesSerialization = new();
+        protected readonly Dictionary<Type, CultureInfo> typesCulture = new();
+        protected readonly Dictionary<Type, Func<object, string>> typesSerialization = new();
+        private Func<dynamic> recursivePropertiesSerialization;
+
+        public PrintingConfig()
+        {
+        }
+
+        protected PrintingConfig(PrintingConfig<TOwner> config)
+        {
+            typesCulture = config.typesCulture;
+            propertiesMaxLength = config.propertiesMaxLength;
+            propertiesSerialization = config.propertiesSerialization;
+            typesSerialization = config.typesSerialization;
+        }
+
         public string PrintToString(TOwner obj)
         {
-            return PrintToString(obj, 0);
+            return SerializeObject(obj, ImmutableList<object>.Empty);
+        }
+
+        public PrintingConfig<TOwner> Excluding<TPropType>()
+        {
+            excludedTypes.Add(typeof(TPropType));
+
+            return this;
+        }
+
+        public PrintingConfig<TOwner> Excluding<TPropType>(Expression<Func<TOwner, TPropType>> member)
+        {
+            var memberInfo = GetMember(member);
+
+            excludedProperties.Add(memberInfo);
+
+            return this;
+        }
+
+        public TypePrintingConfig<TOwner, TPropType> Printing<TPropType>()
+        {
+            return new TypePrintingConfig<TOwner, TPropType>(this);
+        }
+
+        public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>(
+            Expression<Func<TOwner, TPropType>> printMember)
+        {
+            var memberInfo = GetMember(printMember);
+
+            return new PropertyPrintingConfig<TOwner, TPropType>(this, memberInfo);
+        }
+
+        public PrintingConfig<TOwner> WithCyclicLinkException()
+        {
+            recursivePropertiesSerialization = () => throw new ArgumentException("recursive property");
+
+            return this;
+        }
+
+        public PrintingConfig<TOwner> WithCyclicLinkMessage(Func<string> printProperty)
+        {
+            recursivePropertiesSerialization = printProperty;
+
+            return this;
+        }
+
+        public PrintingConfig<TOwner> WithCyclicLinkIgnored()
+        {
+            recursivePropertiesSerialization = () => string.Empty;
+
+            return this;
         }
 
-        private string PrintToString(object obj, int nestingLevel)
+        private string SerializeObject(object obj, IImmutableList<object> previousObjects)
         {
-            //TODO apply configurations
             if (obj == null)
-                return "null" + Environment.NewLine;
+                return "null";
 
-            var finalTypes = new[]
+            var type = obj.GetType();
+            if (previousObjects.Any(prev => prev == obj))
             {
-                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();
+                return recursivePropertiesSerialization != null 
+                    ? (string)recursivePropertiesSerialization() : "Recursive property";
+            }
+
+            if (obj is IEnumerable && obj is not string)
+                return SerializeEnumerable(obj, previousObjects);
+
+            if (_finalTypes.Contains(type))
+                return SerializeFinalType(obj);
+
+            var indentation = new string('\t', previousObjects.Count + 1);
+            var objectSerialization = new StringBuilder().AppendLine(type.Name);
+            previousObjects = previousObjects.Add(obj);
+            var members = Array.Empty<MemberInfo>().Concat(type.GetProperties()).Concat(type.GetFields());
+            foreach (var memberInfo in members)
+            {
+                if (excludedProperties.Contains(memberInfo)
+                    || excludedTypes.Contains(memberInfo.GetMemberType()))
+                    continue;
+
+                objectSerialization.Append(indentation);
+                objectSerialization.Append(memberInfo.Name);
+                objectSerialization.Append(" = ");
+                objectSerialization.Append(SerializeMember(memberInfo, obj, previousObjects));
+                objectSerialization.Append(Environment.NewLine);
+            }
+
+            return objectSerialization.ToString();
+        }
+
+        private string SerializeFinalType(object obj)
+        {
             var type = obj.GetType();
-            sb.AppendLine(type.Name);
-            foreach (var propertyInfo in type.GetProperties())
+            if (typesSerialization.TryGetValue(type, out var serialization))
+                return serialization.Invoke(obj);
+
+            var result = obj.ToString();
+            if (typesCulture.ContainsKey(obj.GetType()))
+                result = ((IFormattable)obj).ToString(null, typesCulture[type]);
+
+            return result;
+        }
+
+        private string SerializeMember(MemberInfo memberInfo, object obj, IImmutableList<object> previousObjects)
+        {
+            var value = memberInfo.GetMemberValue(obj);
+            var result = propertiesSerialization.TryGetValue(memberInfo, out var serialization)
+                ? serialization.Invoke(value)
+                : SerializeObject(value, previousObjects).TrimEnd();
+
+            var propertyMaxLength = propertiesMaxLength.TryGetValue(memberInfo, out var length)
+                ? length
+                : result.Length;
+
+            result = result[..propertyMaxLength];
+
+            return result;
+        }
+
+        private string SerializeEnumerable(object obj, IImmutableList<object> previousObjects)
+        {
+            var enumerable = (IEnumerable)obj;
+            var serializedEnumerable = new StringBuilder();
+            var indentation = previousObjects.Count == 0
+                ? string.Empty
+                : Environment.NewLine + new string('\t', previousObjects.Count + 1);
+
+            foreach (var item in enumerable)
             {
-                sb.Append(identation + propertyInfo.Name + " = " +
-                          PrintToString(propertyInfo.GetValue(obj),
-                              nestingLevel + 1));
+                serializedEnumerable.Append(indentation);
+                serializedEnumerable.Append(SerializeObject(item, previousObjects));
             }
-            return sb.ToString();
+
+            return serializedEnumerable.ToString();
+        }
+
+        private static MemberInfo GetMember<TPropType>(Expression<Func<TOwner, TPropType>> expression)
+        {
+            var memberBody = (MemberExpression)expression.Body;
+            var memberInfo = memberBody.Member;
+
+            return memberInfo;
         }
     }
 }

ObjectPrinting/PropertyPrintingConfig.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Reflection;
+
+namespace ObjectPrinting
+{
+    public class PropertyPrintingConfig<TOwner, TPropType> : PrintingConfig<TOwner>
+    {
+        private readonly MemberInfo propertyInfo;
+
+        public PropertyPrintingConfig(PrintingConfig<TOwner> config, MemberInfo propertyInfo) : base(config)
+        {
+            this.propertyInfo = propertyInfo;
+        }
+
+        public PropertyPrintingConfig<TOwner, TPropType> Using(Func<dynamic, string> printProperty)
+        {
+            propertiesSerialization.TryAdd(propertyInfo, printProperty);
+
+            return this;
+        }
+
+        public PropertyPrintingConfig<TOwner, TPropType> TrimToLength(int length)
+        {
+            ArgumentOutOfRangeException.ThrowIfNegative(length);
+
+            propertiesMaxLength.Add(propertyInfo, length);
+
+            return this;
+        }
+    }
+}

ObjectPrinting/Solved/PrintingConfig.cs

@@ -12,7 +12,8 @@ public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>()
             return new PropertyPrintingConfig<TOwner, TPropType>(this);
         }
 
-        public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>(Expression<Func<TOwner, TPropType>> memberSelector)
+        public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>(
+            Expression<Func<TOwner, TPropType>> memberSelector)
         {
             return new PropertyPrintingConfig<TOwner, TPropType>(this);
         }
@@ -51,11 +52,9 @@ private string PrintToString(object obj, int nestingLevel)
             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();
         }
     }

ObjectPrinting/Solved/PropertyPrintingConfig.cs

@@ -12,6 +12,8 @@ public PropertyPrintingConfig(PrintingConfig<TOwner> printingConfig)
             this.printingConfig = printingConfig;
         }
 
+        PrintingConfig<TOwner> IPropertyPrintingConfig<TOwner, TPropType>.ParentConfig => printingConfig;
+
         public PrintingConfig<TOwner> Using(Func<TPropType, string> print)
         {
             return printingConfig;
@@ -21,8 +23,6 @@ public PrintingConfig<TOwner> Using(CultureInfo culture)
         {
             return printingConfig;
         }
-
-        PrintingConfig<TOwner> IPropertyPrintingConfig<TOwner, TPropType>.ParentConfig => printingConfig;
     }
 
     public interface IPropertyPrintingConfig<TOwner, TPropType>

ObjectPrinting/Solved/PropertyPrintingConfigExtensions.cs

@@ -9,10 +9,10 @@ public static string PrintToString<T>(this T obj, Func<PrintingConfig<T>, Printi
             return config(ObjectPrinter.For<T>()).PrintToString(obj);
         }
 
-        public static PrintingConfig<TOwner> TrimmedToLength<TOwner>(this PropertyPrintingConfig<TOwner, string> propConfig, int maxLen)
+        public static PrintingConfig<TOwner> TrimmedToLength<TOwner>(
+            this PropertyPrintingConfig<TOwner, string> propConfig, int maxLen)
         {
             return ((IPropertyPrintingConfig<TOwner, string>)propConfig).ParentConfig;
         }
-
     }
 }

ObjectPrinting/Solved/Tests/ObjectPrinterAcceptanceTests.cs

@@ -25,13 +25,13 @@ public void Demo()
                 //6. Исключить из сериализации конкретного свойства
                 .Excluding(p => p.Age);
 
-            string s1 = printer.PrintToString(person);
-            
+            var s1 = printer.PrintToString(person);
+
             //7. Синтаксический сахар в виде метода расширения, сериализующего по-умолчанию
-            string s2 = person.PrintToString();
-            
+            var s2 = person.PrintToString();
+
             //8. ...с конфигурированием
-            string s3 = person.PrintToString(s => s.Excluding(p => p.Age));
+            var s3 = person.PrintToString(s => s.Excluding(p => p.Age));
             Console.WriteLine(s1);
             Console.WriteLine(s2);
             Console.WriteLine(s3);

ObjectPrinting/Tests/File.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace ObjectPrinting.Tests
+{
+    public class File
+    {
+        public string field;
+        public string Name { get; set; }
+
+        public Dictionary<string, string> Attributes { get; set; }
+
+        public List<string> SimilarNames { get; set; }
+
+        public string[] Copies { get; set; }
+    }
+}