Якшибаев Данил

ObjectPrinting/HomeWork/Extensions/ObjectPrinterExtensions.cs

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

ObjectPrinting/HomeWork/Extensions/PrintingConfigExtensions.cs

@@ -0,0 +1,11 @@
+using ObjectPrinting.HomeWork.PrintUtils;
+
+namespace ObjectPrinting.HomeWork.Extensions;
+
+public static class PrintingConfigExtensions
+{
+    public static string PrintToString<T>(this T obj, Func<PrintingConfig<T>, PrintingConfig<T>> config)
+    {
+        return config(ObjectPrinter.For<T>()).PrintToString(obj);
+    }
+}

ObjectPrinting/HomeWork/ObjectPrinter.cs

@@ -0,0 +1,24 @@
+using ObjectPrinting.HomeWork.PrintUtils;
+using ObjectPrinting.HomeWork.PrintUtils.Implementations;
+using ObjectPrinting.HomeWork.PrintUtils.Strategies.Implementations;
+using ObjectPrinting.HomeWork.PrintUtils.Strategies.Interfaces;
+using ObjectPrinting.HomeWork.RuleUtils.Implementations;
+
+namespace ObjectPrinting.HomeWork;
+
+public class ObjectPrinter
+{
+    public static PrintingConfig<T> For<T>()
+    {
+        var ruleProcessor = new RuleProcessor();
+        var renderProperty = new PropertyRenderer();
+        var strategies = new List<IPrintStrategy>
+        {
+            new EnumerablePrinterStrategy(),
+            new SimplePrinterStrategy(ruleProcessor),
+            new ObjectPrinterStrategy(renderProperty, ruleProcessor),
+            new CycleFormatterStrategy()
+        };
+        return new PrintingConfig<T>(ruleProcessor, new PrintingProcessor(strategies));
+    }
+}

ObjectPrinting/HomeWork/PrintUtils/Helpers/SimpleTypeHelper.cs

@@ -0,0 +1,15 @@
+namespace ObjectPrinting.HomeWork.PrintUtils.Helpers;
+
+public static class SimpleTypeHelper
+{
+    public static bool IsSimple(Type type)
+    {
+        return type.IsPrimitive
+               || type == typeof(string)
+               || type == typeof(decimal)
+               || type == typeof(DateTime)
+               || type == typeof(Guid)
+               || (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) &&
+                   IsSimple(type.GetGenericArguments()[0]));
+    }
+}

ObjectPrinting/HomeWork/PrintUtils/Implementations/PrintingProcessor.cs

@@ -0,0 +1,35 @@
+using System.Text;
+using ObjectPrinting.HomeWork.PrintUtils.Interfaces;
+using ObjectPrinting.HomeWork.PrintUtils.Strategies.Implementations;
+using ObjectPrinting.HomeWork.PrintUtils.Strategies.Interfaces;
+
+namespace ObjectPrinting.HomeWork.PrintUtils.Implementations;
+
+public class PrintingProcessor(
+    IEnumerable<IPrintStrategy> strategies)
+    : IPrintingProcessor
+{
+    private readonly List<IPrintStrategy> strategies = strategies.ToList();
+
+    public string Print(object? obj, int nestingLevel, HashSet<object> visited)
+    {
+        if (obj == null) return "null";
+
+        var type = obj.GetType();
+
+        var sb = new StringBuilder();
+        foreach (var strategy in strategies.OrderByDescending(strategy => strategy is CycleFormatterStrategy))
+        {
+            if (!strategy.CanHandle(type)) continue;
+
+            var result = strategy.Print(obj, nestingLevel, visited, Print, sb);
+            if (result != null)
+            {
+                return result;
+            }
+        }
+
+        throw new InvalidOperationException($"No strategy could print object of type {type.Name}");
+    }
+
+}

ObjectPrinting/HomeWork/PrintUtils/Implementations/PropertyRenderer.cs

@@ -0,0 +1,37 @@
+using System.Collections;
+using System.Reflection;
+using ObjectPrinting.HomeWork.PrintUtils.Helpers;
+using ObjectPrinting.HomeWork.PrintUtils.Interfaces;
+using ObjectPrinting.HomeWork.RuleUtils.Dto;
+using ObjectPrinting.HomeWork.RuleUtils.Interfaces;
+
+namespace ObjectPrinting.HomeWork.PrintUtils.Implementations;
+
+public class PropertyRenderer : IPropertyRenderer
+{
+    public string? RenderProperty(
+        object target,
+        PropertyInfo prop,
+        int nestingLevel,
+        HashSet<object> visited,
+        IRuleProcessor ruleProcessor, 
+        Func<object?, int, HashSet<object>, string> recursivePrinter)
+    {
+        var value = prop.GetValue(target);
+        if (value == null) return null;
+
+        var ruleOutcome = ruleProcessor.ApplyRule(value, prop);
+        if (ruleOutcome.Action == RuleResult.Skip) return null;
+
+        var type = value.GetType();
+
+        if (typeof(IEnumerable).IsAssignableFrom(type) && type != typeof(string) || !SimpleTypeHelper.IsSimple(type))
+        {
+            var printed = recursivePrinter(value, nestingLevel + 1, visited);
+            return $"{prop.Name} =\n{printed}";
+        }
+
+        var formatted = ruleOutcome.Value ?? value.ToString();
+        return $"{prop.Name} = {formatted}";
+    }
+}

ObjectPrinting/HomeWork/PrintUtils/Interfaces/IPrintingProcessor.cs

@@ -0,0 +1,6 @@
+namespace ObjectPrinting.HomeWork.PrintUtils.Interfaces;
+
+public interface IPrintingProcessor
+{
+    string Print(object? obj, int nestingLevel, HashSet<object> visited);
+}

ObjectPrinting/HomeWork/PrintUtils/Interfaces/IPropertyRenderer.cs

@@ -0,0 +1,15 @@
+using System.Reflection;
+using ObjectPrinting.HomeWork.RuleUtils.Interfaces;
+
+namespace ObjectPrinting.HomeWork.PrintUtils.Interfaces;
+
+public interface IPropertyRenderer
+{
+    public string? RenderProperty(
+        object target,
+        PropertyInfo prop,
+        int nestingLevel,
+        HashSet<object> visited,
+        IRuleProcessor ruleProcessor,
+        Func<object?, int, HashSet<object>, string> recursivePrinter);
+}

ObjectPrinting/HomeWork/PrintUtils/PrintingConfig.cs

@@ -0,0 +1,60 @@
+using System.Globalization;
+using System.Linq.Expressions;
+using System.Reflection;
+using ObjectPrinting.HomeWork.PrintUtils.Interfaces;
+using ObjectPrinting.HomeWork.RuleUtils.Interfaces;
+using ObjectPrinting.HomeWork.RuleUtils.Strategies.Implementations;
+
+namespace ObjectPrinting.HomeWork.PrintUtils;
+
+public class PrintingConfig<TOwner>(IRuleProcessor rp, IPrintingProcessor pr)
+{
+    public string PrintToString(TOwner obj) => pr.Print(obj, 0, []);
+
+    public TypePrintingConfig<TOwner, TType> For<TType>() => new(rp, this);
+    public PropertyPrintingConfig<TOwner, TProp> For<TProp>(Expression<Func<TOwner, TProp>> selector)
+        => new(rp, this, selector);
+
+    public PrintingConfig<TOwner> Exclude<T>()
+    {
+        rp.AddRule(new ExcludeRule(typeof(T)));
+        return this;
+    }
+
+    public PrintingConfig<TOwner> Exclude<TProp>(Expression<Func<TOwner, TProp>> selector)
+    {
+        var prop = GetProperty(selector);
+        rp.AddRule(new ExcludeRule(prop));
+        return this;
+    }
+
+    public PrintingConfig<TOwner> Trim(Expression<Func<TOwner, string>> selector, int length)
+    {
+        var prop = GetProperty(selector);
+        rp.AddRule(new TrimStringRule(prop, length));
+        return this;
+    }
+
+    public PrintingConfig<TOwner> Serialize<TType>(Func<TType, string> serializer)
+    {
+        rp.AddRule(new SerializationRule<TType>(serializer));
+        return this;
+    }
+
+    public PrintingConfig<TOwner> Serialize<TProp>(Expression<Func<TOwner, TProp>> selector, 
+        Func<TProp, string> serializer)
+    {
+        var prop = GetProperty(selector);
+        rp.AddRule(new SerializationRule<TProp>(serializer, prop));
+        return this;
+    }
+
+    public PrintingConfig<TOwner> SetFormattingCulture(CultureInfo culture)
+    {
+        rp.AddRule(new CultureRule(culture));
+        return this;
+    }
+
+    private static PropertyInfo GetProperty<T>(Expression<Func<TOwner, T>> expr) 
+        => (PropertyInfo)((MemberExpression)expr.Body).Member;
+}

ObjectPrinting/HomeWork/PrintUtils/PropertyPrintingConfig.cs

@@ -0,0 +1,40 @@
+using System.Linq.Expressions;
+using System.Reflection;
+using ObjectPrinting.HomeWork.RuleUtils.Interfaces;
+using ObjectPrinting.HomeWork.RuleUtils.Strategies.Implementations;
+
+namespace ObjectPrinting.HomeWork.PrintUtils;
+
+public class PropertyPrintingConfig<TOwner, TProp>(
+    IRuleProcessor rules,
+    PrintingConfig<TOwner> parent,
+    Expression<Func<TOwner, TProp>> selector)
+{
+    private readonly PropertyInfo property = GetProperty(selector);
+
+    public PropertyPrintingConfig<TOwner, TProp> Serialize(Func<TProp, string> serializer)
+    {
+        rules.AddRule(new SerializationRule<TProp>(serializer, property));
+        return this;
+    }
+
+    public PropertyPrintingConfig<TOwner, string> Trim(int length)
+    {
+        if (typeof(TProp) != typeof(string))
+            throw new InvalidOperationException("Trim доступен только для строк.");
+
+        rules.AddRule(new TrimStringRule(property, length));
+        return (PropertyPrintingConfig<TOwner, string>)(object)this;
+    }
+
+    public PropertyPrintingConfig<TOwner, TProp> Exclude()
+    {
+        rules.AddRule(new ExcludeRule(property));
+        return this;
+    }
+
+    public PrintingConfig<TOwner> Apply() => parent;
+
+    private static PropertyInfo GetProperty<T>(Expression<Func<TOwner, T>> exp) =>
+        (PropertyInfo)((MemberExpression)exp.Body).Member;
+}

ObjectPrinting/HomeWork/PrintUtils/Strategies/Implementations/CycleFormatterStrategy.cs

@@ -0,0 +1,30 @@
+using System.Text;
+using ObjectPrinting.HomeWork.PrintUtils.Strategies.Interfaces;
+
+namespace ObjectPrinting.HomeWork.PrintUtils.Strategies.Implementations;
+
+public class CycleFormatterStrategy : IPrintStrategy
+{
+    private readonly Dictionary<object, int> visited = new();
+    public bool CanHandle(Type type) => !type.IsValueType && type != typeof(string);
+
+
+    public string Print(object obj, int nestingLevel, HashSet<object> ignoredVisited,
+        Func<object?, int, HashSet<object>, string> ignoredRecursivePrinter, StringBuilder sb)
+    {
+        if (visited.TryGetValue(obj, out var originalLevel))
+        {
+            return FormatReference(obj, originalLevel);
+        }
+
+        visited[obj] = nestingLevel;
+
+        return null;
+    }
+
+    private string FormatReference(object obj, int nestingLevel)
+    {
+        var type = obj.GetType();
+        return $"<see {type.Name} level={nestingLevel}>";
+    }
+}

ObjectPrinting/HomeWork/PrintUtils/Strategies/Implementations/EnumerablePrinterStrategy.cs

@@ -0,0 +1,38 @@
+using System.Collections;
+using System.Text;
+using ObjectPrinting.HomeWork.PrintUtils.Strategies.Interfaces;
+
+namespace ObjectPrinting.HomeWork.PrintUtils.Strategies.Implementations;
+
+public class EnumerablePrinterStrategy : IPrintStrategy
+{
+    public bool CanHandle(Type type) => typeof(IEnumerable).IsAssignableFrom(type) && type != typeof(string);
+
+    public string Print(object obj, int nestingLevel, HashSet<object> visited,
+        Func<object?, int, HashSet<object>, string> recursivePrinter, StringBuilder sb)
+    {
+        return PrintEnumerable((IEnumerable)obj, nestingLevel, visited, recursivePrinter, sb);
+    }
+
+    private string PrintEnumerable(IEnumerable enumerable, int nestingLevel, HashSet<object> visited,
+        Func<object?, int, HashSet<object>, string> recursivePrinter, StringBuilder sb)
+    {
+        var indent = new string('\t', nestingLevel);
+
+        sb.AppendLine(indent + enumerable.GetType().Name + " [");
+
+        foreach (var item in enumerable)
+        {
+            var itemText = recursivePrinter(item, nestingLevel, visited);
+
+            var itemLines = itemText.Split(Environment.NewLine);
+            foreach (var line in itemLines)
+            {
+                sb.AppendLine(new string('\t', nestingLevel + 1) + line);
+            }
+        }
+
+        sb.AppendLine(indent + "]");
+        return sb.ToString();
+    }
+}

ObjectPrinting/HomeWork/PrintUtils/Strategies/Implementations/ObjectPrinterStrategy.cs

@@ -0,0 +1,49 @@
+using System.Collections;
+using System.Reflection;
+using System.Text;
+using ObjectPrinting.HomeWork.PrintUtils.Helpers;
+using ObjectPrinting.HomeWork.PrintUtils.Interfaces;
+using ObjectPrinting.HomeWork.PrintUtils.Strategies.Interfaces;
+using ObjectPrinting.HomeWork.RuleUtils.Interfaces;
+
+namespace ObjectPrinting.HomeWork.PrintUtils.Strategies.Implementations;
+
+public class ObjectPrinterStrategy(IPropertyRenderer propertyRenderer, IRuleProcessor ruleProcessor) : IPrintStrategy
+{
+    public bool CanHandle(Type type) => !typeof(IEnumerable).IsAssignableFrom(type) && !SimpleTypeHelper.IsSimple(type);
+
+    public string Print(object obj, int nestingLevel, HashSet<object> visited,
+        Func<object?, int, HashSet<object>, string> recursivePrinter, StringBuilder sb)
+    {
+        return PrintObject(obj, nestingLevel, visited, recursivePrinter, ruleProcessor, propertyRenderer, sb);
+    }
+
+    private string PrintObject(
+        object obj,
+        int nestingLevel,
+        HashSet<object> visited,
+        Func<object?, int, HashSet<object>, string> recursivePrinter,
+        IRuleProcessor ruleProcessor,
+        IPropertyRenderer propertyRenderer,
+        StringBuilder sb)
+    {
+        var type = obj.GetType();
+        sb.AppendLine(type.Name);
+        var indent = new string('\t', nestingLevel + 1);
+
+        foreach (var prop in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
+        {
+            var propLine = propertyRenderer.RenderProperty(
+                obj, prop, nestingLevel, visited,
+                ruleProcessor, recursivePrinter
+            );
+
+            if (!string.IsNullOrEmpty(propLine))
+            {
+                sb.AppendLine(indent + propLine);
+            }
+        }
+
+        return sb.ToString().TrimEnd();
+    }
+}