Д/з ObjectPrinter

Homework/Homework.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <OutputType>Library</OutputType>
+  </PropertyGroup>
+
+</Project>

Homework/IPrintingConfig.cs

@@ -0,0 +1,14 @@
+using System.Globalization;
+using System.Reflection;
+
+namespace Homework;
+
+public interface IPrintingConfig
+{
+    HashSet<Type> ExcludeTypes { get; }
+    HashSet<MemberInfo> ExcludeMembers { get; }
+    Dictionary<Type, Func<object, string>> AlternativeTypesSerialization { get; }
+    Dictionary<MemberInfo, Func<object, string>> AlternativeMembersSerialization { get; }
+    Dictionary<Type, CultureInfo> TypesCultureInfo { get; }
+    Dictionary<MemberInfo, int> StringsTrim { get; }
+}

Homework/IPropertyPrintingConfig.cs

@@ -0,0 +1,9 @@
+using System.Reflection;
+
+namespace Homework;
+
+public interface IPropertyPrintingConfig<TOwner, TPropType>
+{
+    PrintingConfig<TOwner> ParentConfig { get; }
+    MemberInfo? MemberInfo { get; }
+}

Homework/LastMemberVisitor.cs

@@ -0,0 +1,15 @@
+using System.Linq.Expressions;
+
+namespace Homework;
+
+public class LastMemberVisitor : ExpressionVisitor
+{
+    public MemberExpression? LastMemberExpression { get; private set; }
+
+    protected override Expression VisitMember(MemberExpression node)
+    {
+        LastMemberExpression = node;
+
+        return base.VisitMember(node);
+    }
+}

Homework/ObjectExtensions.cs

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

Homework/ObjectPrinter.cs

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

Homework/ObjectReferenceEqualityComparer.cs

@@ -0,0 +1,16 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Homework;
+
+public class ObjectReferenceEqualityComparer : IEqualityComparer<object>
+{
+    public new bool Equals(object? x, object? y)
+    {
+        return ReferenceEquals(x, y);
+    }
+
+    public int GetHashCode([DisallowNull] object obj)
+    {
+        return obj.GetHashCode();
+    }
+}

Homework/PrintingConfig.cs

@@ -0,0 +1,172 @@
+using System.Collections;
+using System.Globalization;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text;
+
+namespace Homework;
+
+public class PrintingConfig<TOwner> : IPrintingConfig
+{
+    public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>()
+    {
+        return new PropertyPrintingConfig<TOwner, TPropType>(this, null);
+    }
+
+    public PropertyPrintingConfig<TOwner, TPropType> Printing<TPropType>(Expression<Func<TOwner, TPropType>> memberSelector)
+    {
+        var lambda = memberSelector as LambdaExpression;
+        var visitor = new LastMemberVisitor();
+        visitor.Visit(lambda.Body);
+        var memberInfo = visitor.LastMemberExpression?.Member ?? throw new ArgumentException();
+
+        return new PropertyPrintingConfig<TOwner, TPropType>(this, memberInfo);
+    }
+
+    public PrintingConfig<TOwner> Excluding<TPropType>(Expression<Func<TOwner, TPropType>> memberSelector)
+    {
+        var lambda = memberSelector as LambdaExpression;
+        var visitor = new LastMemberVisitor();
+        visitor.Visit(lambda.Body);
+        var memberInfo = visitor.LastMemberExpression?.Member ?? throw new ArgumentException();
+
+        ((IPrintingConfig)this).ExcludeMembers.Add(memberInfo);
+
+        return this;
+    }
+
+    public PrintingConfig<TOwner> Excluding<TPropType>()
+    {
+        ((IPrintingConfig)this).ExcludeTypes.Add(typeof(TPropType));
+
+        return this;
+    }
+
+    public string PrintToString(TOwner obj)
+    {
+        return PrintToString(obj, null, 0, new(new ObjectReferenceEqualityComparer()));
+    }
+
+    private string PrintToString(object? obj, MemberInfo? memberInfo, int nestingLevel, Dictionary<object, int> printedObjects)
+    {
+        if (obj == null)
+            return "null" + Environment.NewLine;
+
+        var type = obj.GetType();
+        if (printedObjects.TryGetValue(obj, out var level))
+            return $"(cycle with object {type.Name} at level {level}){Environment.NewLine}";
+
+        if (DoesTypeOverrideToString(type))
+            return Serialize(obj, memberInfo) + Environment.NewLine;
+
+        if (type.IsClass)
+            printedObjects.Add(obj, nestingLevel);
+
+        var result = obj is ICollection collection
+            ? PrintCollectionToString(collection, nestingLevel, printedObjects)
+            : PrintComplexObjectToString(obj, nestingLevel, printedObjects);
+
+        if (type.IsClass)
+            printedObjects.Remove(obj);
+
+        return result;
+    }
+
+    private string PrintCollectionToString(ICollection collection, int nestingLevel, Dictionary<object, int> printedObjects)
+    {
+        var identation = new string('\t', nestingLevel);
+        var sb = new StringBuilder();
+        sb.Append((nestingLevel > 0 ? Environment.NewLine + identation : "") + '[' + Environment.NewLine);
+        foreach (var item in collection)
+            sb.Append(identation + '\t' +
+                PrintToString(
+                    item,
+                    null,
+                    nestingLevel + 1,
+                    printedObjects));
+
+        sb.Append(identation + ']' + Environment.NewLine);
+
+        return sb.ToString();
+    }
+
+    private string PrintComplexObjectToString(object obj, int nestingLevel, Dictionary<object, int> printedObjects)
+    {
+        var type = obj.GetType();
+        var identation = new string('\t', nestingLevel + 1);
+        var sb = new StringBuilder();
+        sb.AppendLine(type.Name);
+        foreach (var nestedMemberInfo in
+            GetPublicPropertiesAndFields(type).OrderBy(t => t.Name))
+        {
+            if (((IPrintingConfig)this).ExcludeMembers.Contains(nestedMemberInfo))
+                continue;
+
+            var newObj = GetValueFromPropertyOrField(obj, nestedMemberInfo);
+
+            if (newObj is not null
+                && ((IPrintingConfig)this).ExcludeTypes.Contains(newObj.GetType()))
+                continue;
+
+            sb.Append(identation + nestedMemberInfo.Name + " = " +
+                PrintToString(
+                    newObj,
+                    nestedMemberInfo,
+                    nestingLevel + 1,
+                    printedObjects));
+        }
+
+        return sb.ToString();
+    }
+
+    private IEnumerable<MemberInfo> GetPublicPropertiesAndFields(Type type)
+        => type
+            .GetProperties()
+            .Select(t => (MemberInfo)t)
+            .Concat(type.GetFields());
+
+    private object? GetValueFromPropertyOrField(object obj, MemberInfo memberInfo)
+    {
+        if (memberInfo is FieldInfo fieldInfo)
+            return fieldInfo.GetValue(obj);
+
+        return ((PropertyInfo)memberInfo).GetValue(obj);
+    }
+
+    private string Serialize(object obj, MemberInfo? memberInfo)
+    {
+        if (memberInfo is not null
+            && ((IPrintingConfig)this).AlternativeMembersSerialization.TryGetValue(memberInfo, out var serializeMember))
+            return serializeMember(obj);
+
+        if (((IPrintingConfig)this).AlternativeTypesSerialization.TryGetValue(obj.GetType(), out var serializeType))
+            return serializeType(obj);
+
+        string? str;
+        if (((IPrintingConfig)this).TypesCultureInfo.TryGetValue(obj.GetType(), out var culture))
+            str = (string)obj.GetType().GetMethod("ToString", [typeof(IFormatProvider)]).Invoke(obj, [culture]);
+        else
+            str = obj.ToString();
+
+        if (memberInfo is not null
+            && ((IPrintingConfig)this).StringsTrim.TryGetValue(memberInfo, out var maxLength)
+            && str?.Length > maxLength)
+            str = str[..maxLength];
+
+        return str ?? "null";
+    }
+
+    private bool DoesTypeOverrideToString(Type type)
+    {
+        var toStringMethod = type.GetMethod("ToString", Type.EmptyTypes);
+        return toStringMethod?.DeclaringType != typeof(object) &&
+               toStringMethod?.DeclaringType == type;
+    }
+
+    HashSet<Type> IPrintingConfig.ExcludeTypes { get; } = [];
+    HashSet<MemberInfo> IPrintingConfig.ExcludeMembers { get; } = [];
+    Dictionary<Type, Func<object, string>> IPrintingConfig.AlternativeTypesSerialization { get; } = [];
+    Dictionary<MemberInfo, Func<object, string>> IPrintingConfig.AlternativeMembersSerialization { get; } = [];
+    Dictionary<Type, CultureInfo> IPrintingConfig.TypesCultureInfo { get; } = [];
+    Dictionary<MemberInfo, int> IPrintingConfig.StringsTrim { get; } = [];
+}

Homework/PropertyPrintingConfig.cs

@@ -0,0 +1,24 @@
+using System.Reflection;
+
+namespace Homework;
+
+public class PropertyPrintingConfig<TOwner, TPropType>(PrintingConfig<TOwner> printingConfig, MemberInfo? memberInfo)
+    : IPropertyPrintingConfig<TOwner, TPropType>
+{
+    public PrintingConfig<TOwner> Using(Func<TPropType, string> print)
+    {
+        if (memberInfo is not null)
+        {
+            ((IPrintingConfig)printingConfig).AlternativeMembersSerialization[memberInfo] = obj => print((TPropType)obj);
+        }
+        else
+        {
+            ((IPrintingConfig)printingConfig).AlternativeTypesSerialization[typeof(TPropType)] = obj => print((TPropType)obj);
+        }
+
+        return printingConfig;
+    }
+
+    PrintingConfig<TOwner> IPropertyPrintingConfig<TOwner, TPropType>.ParentConfig => printingConfig;
+    MemberInfo? IPropertyPrintingConfig<TOwner, TPropType>.MemberInfo => memberInfo;
+}

Homework/PropertyPrintingConfigExtensions.cs

@@ -0,0 +1,31 @@
+using System.Globalization;
+
+namespace Homework;
+
+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> TrimmedToLength<TOwner>(this PropertyPrintingConfig<TOwner, string?> propConfig, int maxLen)
+    {
+        var configIface = (IPropertyPrintingConfig<TOwner, string>)propConfig;
+        if (configIface.MemberInfo is not null)
+            ((IPrintingConfig)configIface.ParentConfig).StringsTrim[configIface.MemberInfo] = maxLen;
+
+        return configIface.ParentConfig;
+    }
+
+    public static PrintingConfig<TOwner> Using<TOwner, TPropType>(
+        this PropertyPrintingConfig<TOwner, TPropType> propConfig,
+        CultureInfo culture)
+            where TPropType : IFormattable
+    {
+        var configIface = (IPropertyPrintingConfig<TOwner, TPropType>)propConfig;
+        ((IPrintingConfig)configIface.ParentConfig).TypesCultureInfo[typeof(TPropType)] = culture;
+
+        return configIface.ParentConfig;
+    }
+}

HomeworkTests/HomeworkTests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="FluentAssertions" Version="8.8.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.9.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Homework\Homework.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="NUnit.Framework" />
+  </ItemGroup>
+
+</Project>