Сазонов Александр

ObjectPrinting/Extensions/DictionaryExtensions.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace ObjectPrinting.Extensions;
+
+public static class DictionaryExtensions
+{
+    public static void AddRange<TKey, TValue>(this Dictionary<TKey, TValue> current, Dictionary<TKey, TValue> toAdd)
+        where TKey : notnull
+    {
+        foreach (var item in toAdd)
+            current.Add(item.Key, item.Value);
+    }
+
+    public static void AddMethod<TKey, TValue>(this Dictionary<TKey, TValue> current, TKey key, TValue value)
+        where TKey : notnull
+    {
+        if (!current.TryAdd(key, value))
+            throw new InvalidOperationException($"Type {typeof(TKey).Name} is already registered");
+    }
+}

ObjectPrinting/Extensions/HashsetExtensions.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace ObjectPrinting.Extensions;
+
+public static class HashsetExtensions
+{
+    public static void AddRange<T>(this HashSet<T> current, HashSet<T> toAdd)
+    {
+        foreach (var item in toAdd)
+            current.Add(item);
+    }
+}

ObjectPrinting/Extensions/MemberInfoExtensions.cs

@@ -0,0 +1,30 @@
+using System.Reflection;
+
+namespace ObjectPrinting.Extensions;
+
+public static class MemberInfoExtensions
+{
+    public static object? GetValue(this MemberInfo? memberInfo, object obj) =>
+        memberInfo switch
+        {
+            FieldInfo fieldInfo => fieldInfo.GetValue(obj),
+            PropertyInfo propertyInfo => propertyInfo.GetValue(obj),
+            _ => null
+        };
+
+    public static Type? GetMemberType(this MemberInfo memberInfo) =>
+        memberInfo.MemberType switch
+        {
+            MemberTypes.Constructor => memberInfo.DeclaringType,
+            MemberTypes.Event => ((EventInfo)memberInfo).EventHandlerType,
+            MemberTypes.Field => ((FieldInfo)memberInfo).FieldType,
+            MemberTypes.Method => ((MethodInfo)memberInfo).ReturnType,
+            MemberTypes.Property => ((PropertyInfo)memberInfo).PropertyType,
+            MemberTypes.TypeInfo => ((TypeInfo)memberInfo).BaseType,
+            MemberTypes.Custom => memberInfo.DeclaringType,
+            MemberTypes.NestedType => memberInfo.DeclaringType,
+            MemberTypes.All => memberInfo.DeclaringType,
+            _ => throw new ArgumentOutOfRangeException(nameof(memberInfo), memberInfo,
+                "Unsupported member type.")
+        };
+}

ObjectPrinting/Extensions/ObjectExtensions.cs

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

ObjectPrinting/Extensions/PropertyPrintingConfigExtensions.cs

@@ -0,0 +1,42 @@
+using ObjectPrinting.PropertyPrintingConfig;
+
+namespace ObjectPrinting.Extensions;
+
+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> Using<TOwner, TPropType>(
+        this PropertyPrintingConfig<TOwner, TPropType> propConfig, CultureInfo culture, string? format = null)
+        where TPropType : IFormattable
+    {
+        var parentConfig = ((IPropertyPrintingConfig<TOwner, TPropType>)propConfig).ParentConfig;
+
+        parentConfig.TypeSerializationMethod.AddMethod(typeof(TPropType), (Func<TPropType, string>)FormatFunc);
+
+        return parentConfig;
+
+        string FormatFunc(TPropType obj) => obj.ToString(format, culture);
+    }
+
+    public static PrintingConfig<TOwner> TrimmedToLength<TOwner>(this PropertyPrintingConfig<TOwner, string> propConfig,
+        int maxLength)
+    {
+        if (maxLength < 1)
+            throw new ArgumentException($"{nameof(maxLength)} should be greater than 1");
+
+        var parentConfig = ((IPropertyPrintingConfig<TOwner, string>)propConfig).ParentConfig;
+
+        parentConfig.MemberSerializationMethod.AddMethod(propConfig.PropertyMemberInfo, (Func<string, string>)Function);
+
+        return parentConfig;
+
+        string Function(string str) =>
+            string.IsNullOrEmpty(str) || str.Length <= maxLength
+                ? str
+                : str[..maxLength];
+    }
+}

ObjectPrinting/Extensions/TypeExtensions.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+namespace ObjectPrinting.Extensions;
+
+public static class TypeExtensions
+{
+    private static readonly HashSet<Type> FinalTypes =
+    [
+        typeof(int),
+        typeof(double),
+        typeof(float),
+        typeof(string),
+        typeof(DateTime),
+        typeof(TimeSpan),
+        typeof(Guid),
+        typeof(DateTimeOffset)
+    ];
+
+    public static bool IsFinal(this Type currentType) =>
+        FinalTypes.Contains(currentType);
+}

ObjectPrinting/GlobalUsings.cs

@@ -0,0 +1,2 @@
+global using System;
+global using System.Globalization;

ObjectPrinting/ObjectPrinter.cs

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

ObjectPrinting/ObjectPrinting.csproj

@@ -2,11 +2,6 @@
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
     <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="NUnit" Version="4.2.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
-  </ItemGroup>
 </Project>

ObjectPrinting/PrintingConfig.cs

@@ -1,41 +1,139 @@
-using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
 using System.Text;
+using ObjectPrinting.Extensions;
+using ObjectPrinting.PropertyPrintingConfig;
 
-namespace ObjectPrinting
+namespace ObjectPrinting;
+
+public class PrintingConfig<TOwner>
 {
-    public class PrintingConfig<TOwner>
+    private readonly HashSet<object> seenObjects = [];
+    private readonly HashSet<Type> excludedProperties = [];
+    private readonly HashSet<MemberInfo> excludedMembers = [];
+    internal readonly Dictionary<Type, Delegate> TypeSerializationMethod = new();
+    internal readonly Dictionary<MemberInfo, Delegate> MemberSerializationMethod = new();
+
+    public PrintingConfig(PrintingConfig<TOwner>? parent = null)
+    {
+        if (parent == null)
+            return;
+
+        excludedProperties.AddRange(parent.excludedProperties);
+        excludedMembers.AddRange(parent.excludedMembers);
+        TypeSerializationMethod.AddRange(parent.TypeSerializationMethod);
+        MemberSerializationMethod.AddRange(parent.MemberSerializationMethod);
+    }
+
+    public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>()
+    {
+        var configCopy = new PrintingConfig<TOwner>(this);
+        return new PropertyPrintingConfig<TOwner, TPropType>(configCopy);
+    }
+
+    public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>(
+        Expression<Func<TOwner, TPropType>> memberSelector)
+    {
+        var configCopy = new PrintingConfig<TOwner>(this);
+        var memberInfo = GetMemberInfo(memberSelector);
+        return new PropertyPrintingConfig<TOwner, TPropType>(configCopy, memberInfo);
+    }
+
+    private static MemberInfo? GetMemberInfo<TPropType>(Expression<Func<TOwner, TPropType>> memberSelector) =>
+        (memberSelector.Body as MemberExpression)?.Member;
+
+    public PrintingConfig<TOwner> Excluding<TPropType>(Expression<Func<TOwner, TPropType>> memberSelector)
+    {
+        var configClone = new PrintingConfig<TOwner>(this);
+        var memberInfo = GetMemberInfo(memberSelector);
+        if (memberInfo is null)
+            throw new ArgumentException("Invalid member selector.");
+        configClone.excludedMembers.Add(memberInfo);
+        return configClone;
+    }
+
+    public PrintingConfig<TOwner> Excluding<TPropType>()
+    {
+        var configCopy = new PrintingConfig<TOwner>(this);
+        configCopy.excludedProperties.Add(typeof(TPropType));
+        return configCopy;
+    }
+
+    public string PrintToString(TOwner owner) =>
+        PrintToString(owner, 0);
+
+    private string PrintToString(object? obj, int nestingLevel)
+    {
+        if (obj == null)
+            return "null" + Environment.NewLine;
+
+        if (seenObjects.Contains(obj))
+            return "recursive reference" + Environment.NewLine;
+
+        var type = obj.GetType();
+
+        if (type.IsFinal())
+            return obj + Environment.NewLine;
+
+        var numberOfTabs = new string('\t', nestingLevel + 1);
+        var sb = new StringBuilder();
+        sb.AppendLine(type.Name);
+        if (obj is IEnumerable enumerable)
+            sb.Append(GetCollectionString(enumerable, numberOfTabs, nestingLevel));
+        else
+            sb.Append(GetSingleElementString(obj, numberOfTabs, nestingLevel));
+
+        return sb.ToString();
+    }
+
+    private string GetCollectionString(IEnumerable enumerable, string numberOfTabs, int nestingLevel)
     {
-        public string PrintToString(TOwner obj)
+        var sb = new StringBuilder();
+        sb.AppendLine("[");
+        foreach (var el in enumerable)
         {
-            return PrintToString(obj, 0);
+            var value = PrintToString(el, nestingLevel + 1);
+            sb.Append($"{numberOfTabs}{value}");
         }
 
-        private string PrintToString(object obj, int nestingLevel)
+        seenObjects.Add(enumerable);
+        sb.AppendLine("]");
+        return sb.ToString();
+    }
+
+    private string GetSingleElementString(object obj, string numberOfTabs, int nestingLevel)
+    {
+        var propertiesAndFields = obj
+            .GetType()
+            .GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public)
+            .Where(member => member is PropertyInfo or FieldInfo && !IsMemberExcluded(member));
+        var sb = new StringBuilder();
+        foreach (var memberInfo in propertiesAndFields)
         {
-            //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();
+            sb.Append(numberOfTabs + memberInfo.Name + " = " +
+                      PrintToString(GetValue(obj, memberInfo),
+                          nestingLevel + 1));
         }
+
+        seenObjects.Add(obj);
+        return sb.ToString();
+    }
+
+    private bool IsMemberExcluded(MemberInfo member) =>
+        excludedProperties.Contains(member.GetMemberType()!) ||
+        excludedMembers.Contains(member);
+
+    private object? GetValue(object obj, MemberInfo memberInfo)
+    {
+        var val = memberInfo.GetValue(obj);
+        var memberType = memberInfo.GetMemberType();
+        return MemberSerializationMethod.TryGetValue(memberInfo, out var memberFunc)
+            ? memberFunc.DynamicInvoke(val)
+            : TypeSerializationMethod.TryGetValue(memberType!, out var typeFunc)
+                ? typeFunc.DynamicInvoke(val)
+                : val;
     }
 }

ObjectPrinting/PropertyPrintingConfig/IPropertyPrintingConfig.cs

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

ObjectPrinting/PropertyPrintingConfig/PropertyPrintingConfig.cs

@@ -0,0 +1,25 @@
+using System.Reflection;
+using ObjectPrinting.Extensions;
+
+namespace ObjectPrinting.PropertyPrintingConfig;
+
+public class PropertyPrintingConfig<TOwner, TPropType>(
+    PrintingConfig<TOwner> printingConfig,
+    MemberInfo? memberInfo = null)
+    : IPropertyPrintingConfig<TOwner, TPropType>
+{
+    public MemberInfo PropertyMemberInfo =>
+        memberInfo != null ? memberInfo : throw new InvalidOperationException("MemberInfo is null.");
+
+    public PrintingConfig<TOwner> Using(Func<TPropType, string> print)
+    {
+        if (memberInfo is null)
+            printingConfig.TypeSerializationMethod.AddMethod(typeof(TPropType), print);
+        else
+            printingConfig.MemberSerializationMethod.AddMethod(memberInfo, print);
+
+        return printingConfig;
+    }
+
+    PrintingConfig<TOwner> IPropertyPrintingConfig<TOwner, TPropType>.ParentConfig => printingConfig;
+}