20211111

anbs_cp/FileSizeFormatter.cs

@@ -1,78 +1,56 @@
-using System;
+namespace anbs_cp
-namespace anbs_cp
 {
     /// <summary>
     /// Форматирует размер файла/папки в понятную строку
     /// </summary>
-    public static class FileSizeFormatter
+    public class FileSizeFormatter : IValueFormatter
     {
+        #region Cвойства класса
         /// <summary>
         /// Имена размеров (байт, килобайт, мегабайт, гигабайт и террабайт)
         /// </summary>
-        public static string[] SizeNames { get; set; } = { "Байт", "Кб", "Мб", "Гб", "Тб" };
+        public string[] SizeNames { get; set; } = { "Байт", "Кб", "Мб", "Гб", "Тб" };
         /// <summary>
         /// Знаков после запятой
         /// </summary>
-        public static byte DecimalPlaces { get; set; } = 2;
+        public byte DecimalPlaces { get; set; } = 2;
         /// <summary>
         /// Максимально байт (далее идут Кбайты)
         /// </summary>
-        public static long ByteMax { get; set; } = 1024;
+        public long ByteMax { get; set; } = 1024;
         /// <summary>
         /// Максимально Кбайт (далее идут Мбайты)
         /// </summary>
-        public static long KByteMax { get; set; } = 1048576;
+        public long KByteMax { get; set; } = 1048576;
         /// <summary>
         /// Максимально Мбайт (далее идут Гбайты)
         /// </summary>
-        public static long MByteMax { get; set; } = 1073741824;
+        public long MByteMax { get; set; } = 1073741824;
         /// <summary>
         /// Максимально Гбайт (далее идут Тбайты)
         /// </summary>
-        public static long GByteMax { get; set; } = 1099511627776;
+        public long GByteMax { get; set; } = 1099511627776;
-        /// <summary>
+        #endregion
-        /// Форматирование размера файла
-        /// </summary>
-        /// <param name="value">Размер файла в Байтах</param>
-        /// <returns>Форматированный размер файла (например, 20 Мб)</returns>
-        public static string Format(long value)
-        {
-            //Bytes
-            if (value < ByteMax)
-                return $"{value} {SizeNames[0]}";
-            //KiloBytes
-            if ((value >= ByteMax) && (value < KByteMax))
-                return $"{FrmtSize(value, ByteMax)} {SizeNames[1]}";
-            //MegaBytes
-            if ((value >= KByteMax) && (value < MByteMax))
-                return $"{FrmtSize(value, KByteMax)} {SizeNames[2]}";
-            //GigaBytes
-            if ((value >= MByteMax) && (value < GByteMax))
-                return $"{FrmtSize(value, MByteMax)} {SizeNames[3]}";
-            //TeraBytes
-            if (value >= GByteMax)
-                return $"{FrmtSize(value, GByteMax)} {SizeNames[4]}";
-            //Не определён
-            return $"{value} {SizeNames[0]}";
-        }
-        /// <summary>
-        /// Деление числа на число с DecimalPlaces знаками после запятой
-        /// </summary>
-        /// <param name="dividend">Делимое число</param>
-        /// <param name="divider">Число-делитель</param>
-        /// <returns>Частное (с DecimalPlaces знаками после запятой)</returns>
-        private static string FrmtSize(long dividend, long divider)
-        {
-            long delim = 1;
 
-            for (int i = 0; i <= DecimalPlaces; i++)
+        #region Реализация интерфейса
+        /// <summary>
+        /// Реализация интерфейса
+        /// </summary>
+        public string[] ValueNames { get => SizeNames; set => SizeNames = value; }
+        /// <summary>
+        /// Реализация интерфейса
+        /// </summary>
+        public long[] MaxSizes
+        {
+            get => new long[] { ByteMax, KByteMax, MByteMax, GByteMax };
+            set
             {
-                delim *= 10;
+                ByteMax = value[0];
+                KByteMax = value[1];
+                MByteMax = value[2];
+                GByteMax = value[3];
             }
-
-            decimal value = Math.Round((decimal)(dividend * delim / divider)) / delim;
-
-            return $"{value}";
         }
+        #endregion
     }
 }

anbs_cp/IValueFormatter.cs

@@ -0,0 +1,71 @@
+namespace anbs_cp
+{
+    /// <summary>
+    /// Форматирует размерности в понятную строку
+    /// </summary>
+    public interface IValueFormatter
+    {
+
+        #region Определения интерфейса
+        /// <summary>
+        /// Имена размерностей
+        /// </summary>
+        public string[] ValueNames { get; set; }
+        /// <summary>
+        /// Знаков после запятой
+        /// </summary>
+        public byte DecimalPlaces { get; set; }
+        /// <summary>
+        /// Максимальные размеры (массив ulong[4])
+        /// </summary>
+        public long[] MaxSizes { get; set; }
+        #endregion
+
+        #region Методы интерфейса
+        /// <summary>
+        /// Форматирование размерности
+        /// </summary>
+        /// <param name="value">Размерность, требующая форматирования</param>
+        /// <returns>Форматированная размерность (например, 20 Мб)</returns>
+        public string Format(long value)
+        {
+            //Bytes
+            if (value < MaxSizes[0])
+                return $"{value} {ValueNames[0]}";
+            //KiloBytes
+            if ((value >= MaxSizes[0]) && (value < MaxSizes[1]))
+                return $"{FrmtSize(value, MaxSizes[0])} {ValueNames[1]}";
+            //MegaBytes
+            if ((value >= MaxSizes[1]) && (value < MaxSizes[2]))
+                return $"{FrmtSize(value, MaxSizes[1])} {ValueNames[2]}";
+            //GigaBytes
+            if ((value >= MaxSizes[2]) && (value < MaxSizes[3]))
+                return $"{FrmtSize(value, MaxSizes[2])} {ValueNames[3]}";
+            //TeraBytes
+            if (value >= MaxSizes[3])
+                return $"{FrmtSize(value, MaxSizes[3])} {ValueNames[4]}";
+            //Не определён
+            return $"{value} {ValueNames[0]}";
+        }
+        /// <summary>
+        /// Деление числа на число с DecimalPlaces знаками после запятой
+        /// </summary>
+        /// <param name="dividend">Делимое число</param>
+        /// <param name="divider">Число-делитель</param>
+        /// <returns>Частное (с DecimalPlaces знаками после запятой)</returns>
+        private string FrmtSize(long dividend, long divider)
+        {
+            long delim = 1;
+
+            for (int i = 0; i <= DecimalPlaces; i++)
+            {
+                delim *= 10;
+            }
+
+            decimal value = Math.Round((decimal)(dividend * delim / divider)) / delim;
+
+            return $"{value}";
+        }
+        #endregion
+    }
+}

anbs_cp/LikeDelphi.cs

@@ -1,39 +1,47 @@
 using System.Collections.Generic;
-
 namespace anbs_cp
 {
+    /// <summary>
+    /// Класс, добавляющий реализацию некоторых методов Delphi, которые упрощают работу в C#.
+    /// </summary>
     public static class LikeDelphi
     {
-        /*
+        /// <summary>
-         * Аналог функции "IncludeTrailingBackslash
+        /// Аналог функции IncludeTrailingBackslash
-         */
+        /// </summary>
-        public static string IncludeTrailingBackslash(string Path)
+        /// <param name="path">Путь, к которому нужно добавить slash</param>
+        /// <returns>Путь со slash в конце</returns>
+        public static string IncludeTrailingBackslash(string path)
         {
-            string result = Path;
+            string result = path;
-            int Index = Path.Length - 1;
+            int Index = path.Length - 1;
-            if (Path[Index] != '\\')
+            if (path[Index] != '\\')
             {
-                result = $"{Path}\\";
+                result = $"{path}\\";
             }
             return result;
         }
-        public static List<string> ParseString(string AString, char ADelim)
+        /// <summary>
+        /// Парсер строки в множество строк
+        /// </summary>
+        /// <param name="astring">Строка, которую нужно разбить</param>
+        /// <param name="delim">Символ-делитель строки</param>
+        /// <returns>Массив строк</returns>
+        public static List<string> ParseString(string astring, char delim)
         {
             int from = -1;
-            int to = AString.Length;
+            int to;
-            List<string> result = new List<string>();
+            List<string> result = new();
             do
             {
                 from++;
-                to = AString.IndexOf(ADelim, from);
+                to = astring.IndexOf(delim, from);
                 if (to <= 0)
-                {
+                    to = astring.Length;
-                    to = AString.Length;
-                }
                 if (from != to)
-                    result.Add(AString.Substring(from, to - from));
+                    result.Add(astring[from..(to-from)]);
                 from = to;
-            } while (to != AString.Length);
+            } while (to != astring.Length);
             return result;
         }
     }

anbs_cp/TStringList.cs

@@ -1,164 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-namespace anbs_componentspack
-{
-    public enum TStringListType
-    {
-        sltStringsOnly,     //Только строки -- сортировка по строкам включена, имеющиеся объекты удалит
-        sltObjectsOnly,     //Только объекты -- сортировка по объектам включена
-        sltBoth             //И строки, и объекты -- сортировка отключена
-    }
-    public class TStringList
-    {
-        private List<string> FLines;
-        private List<object> FObjects;
-        private TStringListType type = TStringListType.sltBoth;
-        public TStringListType Type { get => type; set => type = value; }
-        public int Count => FLines.Count;
-        public override bool Equals(object obj)
-        {
-            return obj is TStringList list &&
-                   Count == list.Count;
-        }
-        public override int GetHashCode()
-        {
-            return HashCode.Combine(Count);
-        }
-        public void Add(string AString)
-        {
-            if (!(type == TStringListType.sltObjectsOnly))
-            {
-                FLines.Add(AString);
-                if (!(type == TStringListType.sltStringsOnly))
-                {
-                    FObjects.Add(AString);
-                }
-            }
-        }
-        public void Add(object AObject)
-        {
-            if (!(type == TStringListType.sltStringsOnly))
-            {
-                if (!(type == TStringListType.sltObjectsOnly))
-                {
-                    FLines.Add(AObject.ToString());
-
-                }
-                FObjects.Add(AObject);
-            }
-        }
-        public void Add(string AString, object AObject)
-        {
-            if (!(type == TStringListType.sltStringsOnly) && !(type == TStringListType.sltObjectsOnly))
-            {
-                FLines.Add(AString);
-                FObjects.Add(AObject);
-            }
-        }
-        public (string, object) Get(int Index) => (FLines[Index], FObjects[Index]);
-        public string GetString(int Index)
-        {
-            string result = "";
-            if (!(type == TStringListType.sltObjectsOnly))
-            {
-                result = FLines[Index];
-            }
-            return result;
-        }
-        public object GetObject(int Index)
-        {
-            object result = null;
-            if (!(type == TStringListType.sltStringsOnly))
-            {
-                result = FObjects[Index];
-            }
-            return result;
-        }
-        public void Delete(int Index)
-        {
-            if (!(type == TStringListType.sltObjectsOnly))
-            {
-                FLines.RemoveAt(Index);
-            }
-            if (!(type == TStringListType.sltStringsOnly))
-            {
-                FObjects.RemoveAt(Index);
-            }
-        }
-        public int IndexOf(string AString) => FLines.IndexOf(AString);
-        public int IndexOf(object AObject) => FObjects.IndexOf(AObject);
-        public void Sort()
-        {
-            switch (type)
-            {
-                case TStringListType.sltStringsOnly:
-                    FLines.Sort();
-                    break;
-                case TStringListType.sltObjectsOnly:
-                    FObjects.Sort();
-                    break;
-                case TStringListType.sltBoth:
-                    break;
-                default:
-                    break;
-            }
-        }
-        public void Clear()
-        {
-            FLines.Clear();
-            FObjects.Clear();
-        }
-        public void Assign(List<string> ALines)
-        {
-            if (!(type == TStringListType.sltStringsOnly))
-            {
-                throw new ArgumentException("Assign method works in TStringList only for the sltStringsOnly type. Your changes are not applied!");
-            }
-            Clear();
-            FLines.AddRange(ALines);
-        }
-        public string DelimetedText(char Delimeter)
-        {
-            string result = "";
-            if (!(type == TStringListType.sltObjectsOnly))
-            {
-                for (int i = 0; i < FLines.Count; i++)
-                {
-                    result = $"{result}{Delimeter}{FLines[i]}";
-                }
-            }
-            return result;
-        }
-        public string Text()
-        {
-            char Delim = '\n';
-            return DelimetedText(Delim);
-        }
-        public void LoadFromFile(string FileName)
-        {
-            if (!File.Exists(FileName))
-            {
-                throw new FileNotFoundException();
-            }
-            StreamReader sr = new StreamReader(FileName);
-            string line = sr.ReadLine();
-            while (line != null)
-            {
-                FLines.Add(line);
-                line = sr.ReadLine();
-            }
-            sr.Close();
-        }
-        public void SaveToFile(string FileName)
-        {
-            StreamWriter sw = new StreamWriter(FileName);
-            for (int i = 0; i < FLines.Count; i++)
-            {
-                sw.WriteLine(FLines[i]);
-            }
-            sw.Close();
-        }
-    }
-}

anbs_cp/TypeConverter.cs

@@ -1,9 +1,50 @@
-namespace anbs_componentspack
+namespace anbs_cp
 {
+    /// <summary>
+    /// Конвертер типов на манер Delphi
+    /// </summary>
     public static class TypeConverter
     {
+        #region Конвертация числа в строку
+        /// <summary>
+        /// Преобразование int в string
+        /// </summary>
+        /// <param name="AInt">Число</param>
+        /// <returns>Строка</returns>
         public static string IntToStr(int AInt) => AInt.ToString();
+        /// <summary>
+        /// Преобразование uint в string
+        /// </summary>
+        /// <param name="AInt">Число</param>
+        /// <returns>Строка</returns>
+        public static string IntToStr(uint AInt) => AInt.ToString();
+        /// <summary>
+        /// Преобразование long в string
+        /// </summary>
+        /// <param name="AInt">Число</param>
+        /// <returns>Строка</returns>
         public static string IntToStr(long AInt) => AInt.ToString();
+        /// <summary>
+        /// Преобразование ulong в string
+        /// </summary>
+        /// <param name="AInt">Число</param>
+        /// <returns>Строка</returns>
+        public static string IntToStr(ulong AInt) => AInt.ToString();
+        /// <summary>
+        /// Преобразование byte в string
+        /// </summary>
+        /// <param name="AInt">Число</param>
+        /// <returns>Строка</returns>
+        public static string IntToStr(byte AInt) => AInt.ToString();
+        #endregion
+
+        #region Конвертация строки в число
+        /// <summary>
+        /// Преобразование строки в число
+        /// </summary>
+        /// <param name="AStr">Строка</param>
+        /// <param name="ADefault">Значение по умолчанию (по умолчанию, 0)</param>
+        /// <returns>Число</returns>
         public static int StrToInt(string AStr, int ADefault = 0)
         {
             if (!int.TryParse(AStr, out int result))
@@ -12,6 +53,26 @@
             }
             return result;
         }
+        /// <summary>
+        /// Преобразование строки в число
+        /// </summary>
+        /// <param name="AStr">Строка</param>
+        /// <param name="ADefault">Значение по умолчанию (по умолчанию, 0)</param>
+        /// <returns>Число</returns>
+        public static uint StrToUInt(string AStr, uint ADefault = 0)
+        {
+            if (!uint.TryParse(AStr, out uint result))
+            {
+                result = ADefault;
+            }
+            return result;
+        }
+        /// <summary>
+        /// Преобразование строки в число
+        /// </summary>
+        /// <param name="AStr">Строка</param>
+        /// <param name="ADefault">Значение по умолчанию (по умолчанию, 0)</param>
+        /// <returns>Число</returns>
         public static long StrToInt64(string AStr, long ADefault = 0)
         {
             if (!long.TryParse(AStr, out long result))
@@ -20,5 +81,34 @@
             }
             return result;
         }
+        /// <summary>
+        /// Преобразование строки в число
+        /// </summary>
+        /// <param name="AStr">Строка</param>
+        /// <param name="ADefault">Значение по умолчанию (по умолчанию, 0)</param>
+        /// <returns>Число</returns>
+        public static ulong StrToUInt64(string AStr, ulong ADefault = 0)
+        {
+            if (!ulong.TryParse(AStr, out ulong result))
+            {
+                result = ADefault;
+            }
+            return result;
+        }
+        /// <summary>
+        /// Преобразование строки в число
+        /// </summary>
+        /// <param name="AStr">Строка</param>
+        /// <param name="ADefault">Значение по умолчанию (по умолчанию, 0)</param>
+        /// <returns>Число</returns>
+        public static byte StrToByte(string AStr, byte ADefault = 0)
+        {
+            if (!byte.TryParse(AStr, out byte result))
+            {
+                result = ADefault;
+            }
+            return result;
+        }
+        #endregion
     }
-}
+}

anbs_cp/anbs_cp.csproj

@@ -1,12 +1,32 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net6.0-windows</TargetFramework>
-    <Version>0.1.0</Version>
+    <Version>1.20211111.0</Version>
     <Authors>Alexander Babaev</Authors>
     <Product>ANB Software Components Pack</Product>
     <Description>Library of some useful functions in C# language.</Description>
-    <Copyright />
+    <Copyright>Alexander Babaev</Copyright>
+    <AssemblyName>anbs_cp</AssemblyName>
+    <RootNamespace>anbs_cp</RootNamespace>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
+    <SignAssembly>False</SignAssembly>
+    <PackageProjectUrl>https://github.com/GoodBoyAlex/anbsoftware_componentspack</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/GoodBoyAlex/anbsoftware_componentspack</RepositoryUrl>
+    <AssemblyVersion>1.2021.1111</AssemblyVersion>
+    <FileVersion>1.2021.1111</FileVersion>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <WarningLevel>2</WarningLevel>
+    <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <WarningLevel>2</WarningLevel>
+    <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
   </PropertyGroup>
 
 </Project>