Трофимов Никита

ObjectPrinting/ISerializer.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Linq.Expressions;
+
+namespace ObjectPrinting
+{
+    public interface ISerializer<TOwner>
+    {
+        string PrintToString(TOwner obj);
+        PropertySetting<TOwner> SelectProperty<P>(Expression<Func<TOwner, P>> properties);
+        ISerializer<TOwner> ChangeProperty<T>(Func<object, string> method);
+        ISerializer<TOwner> Exclude<T>();
+    }
+}

ObjectPrinting/ObjectPrinting.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <LangVersion>8</LangVersion>
+    <LangVersion>latest</LangVersion>
     <TargetFramework>netcoreapp3.1</TargetFramework>
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
   </PropertyGroup>

ObjectPrinting/PrintingConfig.cs

@@ -1,40 +1,147 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Text;
 
+
 namespace ObjectPrinting
 {
-    public class PrintingConfig<TOwner>
+    public class PrintingConfig<TOwner> : ISerializer<TOwner>
     {
+        private readonly Dictionary<string, PropertySetting<TOwner>> propertiesOptions = new();
+
+        private readonly Dictionary<string, StringSetting<TOwner>> stringOptions = new();
+
+        private readonly Dictionary<Type, Func<object, string>> optionsTypes = new();
+
+        private readonly HashSet<Type> exceptTypes = new();
+
+        private readonly Type[] types =
+        {
+            typeof(int),
+            typeof(double),
+            typeof(float),
+            typeof(bool),
+            typeof(DateTime),
+            typeof(TimeSpan)
+        };
+
+
         public string PrintToString(TOwner obj)
         {
             return PrintToString(obj, 0);
         }
 
-        private string PrintToString(object obj, int nestingLevel)
+        public PropertySetting<TOwner> SelectProperty<P>(Expression<Func<TOwner, P>> properties)
+        {
+            var memberExpression = (MemberExpression)properties.Body;
+            var propertySetting = new PropertySetting<TOwner>(this);
+            propertiesOptions[memberExpression.Member.Name] = propertySetting;
+
+            return propertySetting;
+        }
+
+        public StringSetting<TOwner> SelectProperty(Expression<Func<TOwner, string>> properties)
+        {
+            var memberExpression = (MemberExpression)properties.Body;
+            var stringSetting = new StringSetting<TOwner>(this);
+            stringOptions[memberExpression.Member.Name] = stringSetting;
+            propertiesOptions[memberExpression.Member.Name] = stringSetting;
+
+            return stringSetting;
+        }
+
+        public ISerializer<TOwner> ChangeProperty<T2>(Func<object, string> method)
+        {
+            optionsTypes.Add(typeof(T2), method);
+            return this;
+        }
+
+        public ISerializer<TOwner> Exclude<T2>()
+        {
+            exceptTypes.Add(typeof(T2));
+            return this;
+        }
+
+        public PrintingConfig<TOwner> Exclude<TP>(Expression<Func<TOwner, TP>> properties)
+        {
+            var memberExpression = (MemberExpression)properties.Body;
+            var propertySetting = new PropertySetting<TOwner>(this, true);
+            propertiesOptions[memberExpression.Member.Name] = propertySetting;
+
+            return this;
+        }
+
+        private string PrintToString(object obj, int id, string name = "")
         {
-            //TODO apply configurations
             if (obj == null)
-                return "null" + Environment.NewLine;
+                return "null";
+
+            if (types.Contains(obj.GetType()) || id > 1)
+            {
+                var cultureInfo = CultureInfo.CurrentCulture;
+                if (propertiesOptions.TryGetValue(name, out var option))
+                    cultureInfo = option.Culture;
+
+                return string.Format(cultureInfo, "{0}", obj);
+            }
 
-            var finalTypes = new[]
+            if (obj is string s)
             {
-                typeof(int), typeof(double), typeof(float), typeof(string),
-                typeof(DateTime), typeof(TimeSpan)
-            };
-            if (finalTypes.Contains(obj.GetType()))
-                return obj + Environment.NewLine;
+                var maxLength = -1;
+                if (stringOptions.TryGetValue(name, out var option))
+                    maxLength = option.MaxLength;
+                if (maxLength < 0)
+                    return obj as string;
+
+                return s[..maxLength];
+            }
 
-            var identation = new string('\t', nestingLevel + 1);
             var sb = new StringBuilder();
             var type = obj.GetType();
-            sb.AppendLine(type.Name);
+            sb.Append(type.Name + ":");
             foreach (var propertyInfo in type.GetProperties())
             {
-                sb.Append(identation + propertyInfo.Name + " = " +
-                          PrintToString(propertyInfo.GetValue(obj),
-                              nestingLevel + 1));
+                var variable = propertyInfo.GetValue(obj);
+                if (exceptTypes.Contains(propertyInfo.PropertyType) ||
+                    propertiesOptions.ContainsKey(propertyInfo.Name) &&
+                    propertiesOptions[propertyInfo.Name].IsExcept)
+                    continue;
+                if (propertiesOptions.ContainsKey(propertyInfo.Name) &&
+                    propertiesOptions[propertyInfo.Name].OutputMethod != null)
+                {
+                    sb.Append(propertyInfo.Name + " = " +
+                              propertiesOptions[propertyInfo.Name].OutputMethod.Invoke(variable));
+                }
+                else if (optionsTypes.TryGetValue(propertyInfo.PropertyType, out var optionsType))
+                {
+                    sb.Append(propertyInfo.Name + " = " +
+                              optionsType.Invoke(variable));
+                }
+                else if (variable is IList list)
+                {
+                    for (var i = 0; i < list.Count; i++)
+                        sb.Append("\n" + i + " = " +
+                                  PrintToString(list[i], id + 1, propertyInfo.Name));
+                }
+                else if (variable is IDictionary dict)
+                {
+                    foreach (var key in dict.Keys)
+                    {
+                        var value = dict[key];
+                        sb.Append($"\n{key} = {PrintToString(value, id + 1, name)}");
+                    }
+                }
+                else
+                {
+                    sb.Append(propertyInfo.Name + " = " +
+                              PrintToString(propertyInfo.GetValue(obj), id + 1, propertyInfo.Name));
+                }
             }
+
             return sb.ToString();
         }
     }

ObjectPrinting/PropertySetting.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Globalization;
+
+namespace ObjectPrinting
+{
+    public class PropertySetting<T>
+    {
+        protected internal bool IsExcept { get; }
+        protected internal Func<object, string> OutputMethod { get; private set; }
+        protected PrintingConfig<T> Config { get; private set; }
+        protected internal CultureInfo Culture { get; private set; }
+
+        public PropertySetting(PrintingConfig<T> config, bool isExcept = false)
+        {
+            IsExcept = isExcept;
+            Config = config;
+            Culture = CultureInfo.CurrentCulture;
+        }
+
+        public PrintingConfig<T> ChangeField(Func<object, string> func)
+        {
+            OutputMethod = func;
+            return Config;
+        }
+
+        public PrintingConfig<T> ChangeCulture(CultureInfo culture)
+        {
+            Culture = culture;
+            return Config;
+        }
+    }
+}

ObjectPrinting/StringSetting.cs

@@ -0,0 +1,18 @@
+namespace ObjectPrinting
+{
+    public class StringSetting<T> : PropertySetting<T>
+    {
+        protected internal int MaxLength { get; private set; }
+
+        public StringSetting(PrintingConfig<T> config, bool isExcept = false) : base(config, isExcept)
+        {
+            MaxLength = -1;
+        }
+
+        public PrintingConfig<T> SetMaxLength(int length)
+        {
+            MaxLength = length;
+            return Config;
+        }
+    }
+}

ObjectPrinting/Tests/ObjectPrinterAcceptanceTests.cs

@@ -1,27 +1,37 @@
-using NUnit.Framework;
-
-namespace ObjectPrinting.Tests
-{
-    [TestFixture]
-    public class ObjectPrinterAcceptanceTests
-    {
-        [Test]
-        public void Demo()
-        {
-            var person = new Person { Name = "Alex", Age = 19 };
-
-            var printer = ObjectPrinter.For<Person>();
-                //1. Исключить из сериализации свойства определенного типа
-                //2. Указать альтернативный способ сериализации для определенного типа
-                //3. Для числовых типов указать культуру
-                //4. Настроить сериализацию конкретного свойства
-                //5. Настроить обрезание строковых свойств (метод должен быть виден только для строковых свойств)
-                //6. Исключить из сериализации конкретного свойства
-
-            string s1 = printer.PrintToString(person);
-
-            //7. Синтаксический сахар в виде метода расширения, сериализующего по-умолчанию        
-            //8. ...с конфигурированием
-        }
-    }
-}
+// using System;
+// using System.Diagnostics.CodeAnalysis;
+// using System.Globalization;
+// using NUnit.Framework;
+// using ObjectPrinting.Solved;
+//
+// namespace ObjectPrinting.Tests
+// {
+//     [TestFixture]
+//     public class ObjectPrinterAcceptanceTests
+//     {
+//         [Test]
+//         public void Demo()
+//         {
+//             var person = new Person { Name = "Alex", Age = 19 };
+//
+//             var printer = ObjectPrinter.For<Person>();
+//             printer
+//                 //1. Исключить из сериализации свойства определенного типа
+//                 .Exluding<int>()
+//                 //2. Указать альтернативный способ сериализации для определенного типа
+//                 //3. Для числовых типов указать культуру
+//                 .Printing<double>().By(CultureInfo.CurrentCulture)
+//                 //4. Настроить сериализацию конкретного свойства
+//                 .Printing<int>().By(s => s.ToString())
+//                 //5. Настроить обрезание строковых свойств (метод должен быть виден только для строковых свойств)
+//                 
+//                 //6. Исключить из сериализации конкретного свойства
+//                 .Exluding(p = p.Age);
+//             
+//             string s1 = printer.PrintToString(person);
+//
+//             //7. Синтаксический сахар в виде метода расширения, сериализующего по-умолчанию        
+//             //8. ...с конфигурированием
+//         }
+//     }
+// }

ObjectPrintingTests/CollectionsTests.cs

@@ -0,0 +1,76 @@
+using ObjectPrinting;
+
+namespace ObjectPrintingTests;
+
+public class CollectionsTests
+{
+    private class TestDictionary
+    {
+        public Dictionary<string, int> DictionaryProperty { get; set; }
+    }
+
+    [Test]
+    public void PrintToString_WithDictionary()
+    {
+        var obj = new TestDictionary
+        {
+            DictionaryProperty = new Dictionary<string, int>
+            {
+                { "One", 1 },
+                { "Two", 2 },
+                { "Three", 3 }
+            }
+        };
+
+        var printer = ObjectPrinter.For<TestDictionary>();
+        var result = printer.PrintToString(obj);
+
+        result.Should().Be("TestDictionary:" +
+                           "\nOne = 1" +
+                           "\nTwo = 2" +
+                           "\nThree = 3");
+    }
+
+    private class TestArray
+    {
+        public int[] ArrayProperty { get; set; }
+    }
+
+    [Test]
+    public void PrintToString_WithArray()
+    {
+        var obj = new TestArray
+        {
+            ArrayProperty = new[] { 10, 20, 30 }
+        };
+        var printingConfig = new PrintingConfig<TestArray>();
+        var result = printingConfig.PrintToString(obj);
+
+        result.Should().Be("TestArray:" +
+                           "\n0 = 10" +
+                           "\n1 = 20" +
+                           "\n2 = 30");
+    }
+
+    private class TestList
+    {
+        public List<string> ListProperty { get; set; }
+    }
+
+    [Test]
+    public void PrintToString_WithList()
+    {
+        var obj = new TestList
+        {
+            ListProperty = new List<string> { "One", "Two", "Three" }
+        };
+
+        var printer = ObjectPrinter.For<TestList>();
+        var result = printer.PrintToString(obj);
+
+        result.Should().Be("TestList:" +
+                           "\n0 = One" +
+                           "\n1 = Two" +
+                           "\n2 = Three");
+    }
+}