Merge pull request #15 from Crequency/dev=main

[Pull Request] Added `expression` class for building expression tree

Author: Dynesshely

Common.BasicHelper.Test/Math/Calculator_Tests.cs

@@ -0,0 +1,59 @@
+namespace Common.BasicHelper.Math;
+
+[TestClass()]
+public class Calculator_Tests
+{
+    [TestMethod()]
+    public void Test_Calculate()
+    {
+        // 15 = 5 + 10
+        Assert.AreEqual(
+            15,
+            Calculator.Calculate(
+                Expression.FromValue(5),
+                Expression.FromValue(10),
+                CalculationType.Add
+            )
+        );
+
+        // 5 = 10 - 5
+        Assert.AreEqual(
+            5,
+            Calculator.Calculate(
+                Expression.FromValue(10),
+                Expression.FromValue(5),
+                CalculationType.Substraction
+            )
+        );
+
+        // 50 = 5 * 10
+        Assert.AreEqual(
+            50,
+            Calculator.Calculate(
+                Expression.FromValue(5),
+                Expression.FromValue(10),
+                CalculationType.Multiply
+            )
+        );
+
+        // 0.5 = 5 / 10
+        Assert.AreEqual(
+            0.5,
+            Calculator.Calculate(
+                Expression.FromValue(5),
+                Expression.FromValue(10),
+                CalculationType.Division
+            )
+        );
+
+        // 1024 = 2 ^ 10
+        Assert.AreEqual(
+            1024,
+            Calculator.Calculate(
+                Expression.FromValue(2),
+                Expression.FromValue(10),
+                CalculationType.Power
+            )
+        );
+    }
+}

Common.BasicHelper.Test/Math/Expression_Tests.cs

@@ -0,0 +1,50 @@
+namespace Common.BasicHelper.Math;
+
+[TestClass()]
+public class Expression_Tests
+{
+    [TestMethod()]
+    public void Test_Expression()
+    {
+        var expr = (39 / 3) + (16 * 5) - ((24 * 24) + 5 + 7);
+
+        var tree = new Expression()
+        {
+            Type = CalculationType.Add,
+            Left = new()
+            {
+                Type = CalculationType.Division,
+                Left = Expression.FromValue(39),
+                Right = Expression.FromValue(3)
+            },
+            Right = new()
+            {
+                Type = CalculationType.Substraction,
+                Left = new()
+                {
+                    Type = CalculationType.Multiply,
+                    Left = Expression.FromValue(16),
+                    Right = Expression.FromValue(5),
+                },
+                Right = new()
+                {
+                    Type = CalculationType.Add,
+                    Left = new()
+                    {
+                        Type = CalculationType.Power,
+                        Left = Expression.FromValue(24),
+                        Right = Expression.FromValue(2)
+                    },
+                    Right = new()
+                    {
+                        Type = CalculationType.Add,
+                        Left = Expression.FromValue(5),
+                        Right = Expression.FromValue(7)
+                    }
+                }
+            }
+        };
+
+        Assert.AreEqual(expr, tree.Result);
+    }
+}

Common.BasicHelper/Common.BasicHelper.csproj

@@ -5,8 +5,10 @@
         <TargetFramework>netstandard2.1</TargetFramework>
         <ImplicitUsings>disable</ImplicitUsings>
         <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <PropertyGroup>
         <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-        <EnableUnsafeBinaryFormatterSerialization>true</EnableUnsafeBinaryFormatterSerialization>
         <Authors>Dynesshely</Authors>
         <Company>Crequency</Company>
         <PackageLicenseExpression>AGPL-3.0-only</PackageLicenseExpression>
@@ -16,7 +18,9 @@
         <RepositoryUrl>https://github.com/Crequency/Common.BasicHelper/</RepositoryUrl>
         <Copyright>Copyright © Crequency 2022-present</Copyright>
         <PackageIcon>icon.png</PackageIcon>
+    </PropertyGroup>
 
+    <PropertyGroup>
         <AssemblyVersion>$(Version)</AssemblyVersion>
         <FileVersion>$(Version)</FileVersion>
         <Version>1.2.$([System.DateTime]::UtcNow.Date.Subtract($([System.DateTime]::Parse("2005-06-06"))).TotalDays).$([System.Math]::Floor($([System.DateTime]::UtcNow.TimeOfDay.TotalMinutes)))</Version>

Common.BasicHelper/Core/Shell/CommandsExecutor.md

@@ -0,0 +1,98 @@
+# CommandsExecutor
+
+This is a class to help to run commands in system shell.
+
+It provides 2 static methods with each have a extension method.
+
+## Static Methods
+
+### Methods and arguments with description
+
+- `GetExecutionResult` -> `string`
+
+  This method execute command in system shell, and return standard output content.
+  
+  `string` **command** - command name, when **findInPath** is true, file path will find from `Path`.
+  
+  `string` **args** - start up arguments.
+  
+  `[bool]` **findInPath** = false - indecate whether get file path in `Path`.
+  
+  `[Action<ProcessStartInfo>?]` **action** = null - user can user this argument to operate `ProcessStartInfo`.
+
+- `GetExecutionResultAsync` -> `Task<string>`
+
+  This method has same function and 4 same parameters as `GetExecutionResult`, but execute outside program asynchronously, 
+you can await this method.
+  
+  `string`, `string`, `[bool]`, `[Action<ProcessStartInfo>?]`
+
+  `[CancellationToken?]` **token** = null - you can use this object to cancel this task, once **token**!.`IsCancellationRequested` is true, the outside process will be killed.
+
+### Usage
+
+```csharp
+using Common.BasicHelper.Core.Shell;
+
+var output = CommandsExecutor.GetExecutionResult(
+    "help", // command, use `help` for example
+    "",
+    true
+);
+
+var output_async - CommandsExecutor.GetExecutionResultAsync(
+    "help",
+    "",
+    true
+);
+
+Console.WriteLine(output);
+Console.WriteLine(output_async);
+```
+
+## Extension Methods
+
+### Methods and arguments with description
+
+- `ExecuteAsCommand` -> `string`
+
+  This extension method is a wrapping method for `GetExecutionResult`.
+  
+  *this* `string` **command**
+  
+  `[string?]` **args** = null
+  
+  `[bool]` **findInPath** = true
+  
+  `[Action<ProcessStartInfo>?]` **action** = null
+
+- `ExecuteAsCommandAsync` -> `Task<string>`
+  
+  This extension method is a wrapping method for `GetExecutionResultAsync`.
+  
+  *this* `string` **command**
+  
+  `[string?]` **args** = null
+  
+  `[bool]` **findInPath** = true
+  
+  `[Action<ProcessStartInfo>?]` **action** = null
+  
+  `[CancellationToken?]` **token** = default
+
+### Usage
+
+```csharp
+using Common.BasicHelper.Core.Shell;
+
+Console.WriteLine("help".ExecuteAsCommand());
+```
+
+## OOP
+
+This is a static class.
+
+## Examples
+
+- In [KitX Dashboard](https://github.com/Crequency/KitX-Dashboard/blob/03e4d3b127de69a34df00f6ac34db7ec6bd1a0d4/Network/NetworkHelper.cs#L139) project, we use these functions to get system version info.
+

Common.BasicHelper/Graphics/Screen/Resolution.cs

@@ -57,9 +57,9 @@ public class Resolution
     /// </summary>
     public Resolution Integerization()
     {
-        if (Width != null)
+        if (Width is not null)
             Width = System.Math.Round(Width.Value, 0);
-        if (Height != null)
+        if (Height is not null)
             Height = System.Math.Round(Height.Value, 0);
         return this;
     }
@@ -132,7 +132,7 @@ public static Resolution Suggest(Resolution screen, Resolution content, Resoluti
 
         var yy = tararea / content.AspectRatio;
 
-        if (yy != null)
+        if (yy is not null)
         {
             suggest.Height = System.Math.Sqrt((double)yy);
             suggest.Width = content.AspectRatio * suggest.Height;

Common.BasicHelper/Math/Calculator.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace Common.BasicHelper.Math;
+
+public static class Calculator
+{
+    public static double Calculate(Expression? a, Expression? b, CalculationType type)
+    {
+        a = a ?? throw new ArgumentNullException(nameof(a));
+        b = b ?? throw new ArgumentNullException(nameof(b));
+
+        switch (type)
+        {
+            case CalculationType.Unknown:
+                throw new NotImplementedException(
+                    $"Unknown type can't calculate for `{a?.Result} {type} {b?.Result}`."
+                );
+
+            case CalculationType.Add:
+                return a!.Result + b!.Result;
+
+            case CalculationType.Substraction:
+                return a!.Result - b!.Result;
+
+            case CalculationType.Multiply:
+                return a!.Result * b!.Result;
+
+            case CalculationType.Division:
+                return a!.Result / b!.Result; // Here couldn't throw divide by zero exception.
+
+            case CalculationType.Power:
+                return System.Math.Pow(a!.Result, b!.Result);
+
+            default:
+                throw new NotImplementedException(
+                    $"Please provide argument {nameof(type)} ({nameof(CalculationType)})"
+                );
+        }
+    }
+}

Common.BasicHelper/Math/Expression.cs

@@ -0,0 +1,43 @@
+namespace Common.BasicHelper.Math;
+
+public enum CalculationType
+{
+    Unknown = 0,
+    Add = 1,
+    Substraction = 2,
+    Multiply = 3,
+    Division = 4,
+    Power = 5,
+}
+
+public class Expression
+{
+    private CalculationType type = CalculationType.Unknown;
+
+    public CalculationType Type { get => type; set => type = value; }
+
+    public Expression? Left { get; set; }
+
+    public Expression? Right { get; set; }
+
+    private double? givenValue = null;
+
+    public double Result
+    {
+        get => givenValue ?? Calculator.Calculate(Left, Right, type);
+        set
+        {
+            givenValue = value;
+        }
+    }
+
+    public static Expression FromValue(double value)
+    {
+        return new()
+        {
+            Result = value
+        };
+    }
+}
+
+

Common.BasicHelper/Math/Standard.cs

@@ -66,7 +66,7 @@ public static int GetPosition(int number, int bit)
         var pow = 10;
         for (var i = 0; i < bit - 2; ++i)
             pow *= pow;
-        return (number % pow) / (pow / 10);
+        return number % pow / (pow / 10);
     }
 }