Merge pull request #8 from Z3roTech/feature/core-features-of-library

add core features of library

Author: Z3roTech

ZeroCode.Core/AssemblyInfo.cs

@@ -0,0 +1,18 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// In SDK-style projects such as this one, several assembly attributes that were historically
+// defined in this file are now automatically added during build and populated with
+// values defined in project properties. For details of which attributes are included
+// and how to customise this process see: https://aka.ms/assembly-info-properties
+
+// Setting ComVisible to false makes the types in this assembly not visible to COM
+// components.  If you need to access a type in this assembly from COM, set the ComVisible
+// attribute to true on that type.
+
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM.
+
+[assembly: Guid("6c2d97cd-45cc-4a52-8210-6fef9c11d080")]
+[assembly: InternalsVisibleTo("ZeroCode.Tests")]

ZeroCode.Core/ConcurrentExecutor.cs

@@ -0,0 +1,184 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ZeroCode
+{
+    /// <summary>
+    ///     Helper class for invoking methods in concurrent mode. It may help to queue requests to database on application
+    ///     layer instead of database layer.
+    /// </summary>
+    public class ConcurrentExecutor
+    {
+        /// <summary>
+        ///     Synchronization primitive that will be control concurrent methods invoke
+        /// </summary>
+        private readonly SemaphoreSlim _semaphore;
+
+        /// <summary>
+        ///     Count of maximum tasks of invoking methods that can be executed in meantime
+        /// </summary>
+        private int _maxParallelTasks;
+
+        public ConcurrentExecutor(int maxParallelTasks)
+        {
+            if (maxParallelTasks <= 0)
+                throw new ArgumentOutOfRangeException(nameof(maxParallelTasks),
+                    "Value of maximum parallel executing tasks must be more then 0");
+
+            _maxParallelTasks = maxParallelTasks;
+            _semaphore = new SemaphoreSlim(_maxParallelTasks);
+        }
+
+        /// <summary>
+        ///     Change count of maximum methods that will be invoking in meantime. This method can be executing too long when
+        ///     lowering count of maximum parallel tasks.
+        /// </summary>
+        /// <param name="maxParallelTasks"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentOutOfRangeException"></exception>
+        public ConcurrentExecutor ChangeMaxParallelTaskCount(int maxParallelTasks)
+        {
+            if (maxParallelTasks <= 0)
+                throw new ArgumentOutOfRangeException(nameof(maxParallelTasks),
+                    "Value of maximum parallel executing tasks must be more then 0");
+
+            var oldValue = Interlocked.Exchange(ref _maxParallelTasks, maxParallelTasks);
+            var diff = maxParallelTasks - oldValue;
+
+            // If value of max parallel now more than previous, we must release new slots in semaphore
+            if (diff > 0) _semaphore.Release(diff);
+
+            // If value of max parallel tasks now less than previous, we must use semaphore slots
+            if (diff < 0)
+                for (var i = 0; i < Math.Abs(diff); i++)
+                    _semaphore.Wait();
+
+            return this;
+        }
+
+        /// <summary>
+        ///     Execute in concurrent mode <paramref name="wrapped" />
+        /// </summary>
+        /// <typeparam name="TResult">Any result type</typeparam>
+        /// <param name="wrapped">Method that must be invoked in concurrent mode</param>
+        /// <param name="timeout">Timeout of waiting invoking in concurrent queue</param>
+        /// <param name="token"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        /// <exception cref="TimeoutException">If execution was timed out</exception>
+        public TResult Execute<TResult>(Func<TResult> wrapped, TimeSpan timeout = default,
+            CancellationToken token = default)
+        {
+            if (wrapped == null) throw new ArgumentNullException(nameof(wrapped));
+
+            try
+            {
+                if (timeout == TimeSpan.Zero)
+                    _semaphore.Wait(token);
+                else if (!_semaphore.Wait(timeout, token)) throw new TimeoutException();
+
+                return wrapped();
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        /// <inheritdoc cref="Execute{TResult}" />
+        public void Execute(Action wrapped, TimeSpan timeout = default,
+            CancellationToken token = default)
+        {
+            if (wrapped == null) throw new ArgumentNullException(nameof(wrapped));
+
+            try
+            {
+                if (timeout == TimeSpan.Zero)
+                    _semaphore.Wait(token);
+                else if (!_semaphore.Wait(timeout, token)) throw new TimeoutException();
+
+                wrapped();
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        /// <inheritdoc cref="Execute{TResult}" />
+        public async Task<TResult> ExecuteAsync<TResult>(Func<Task<TResult>> wrapped, TimeSpan timeout = default,
+            CancellationToken token = default)
+        {
+            if (wrapped == null) throw new ArgumentNullException(nameof(wrapped));
+
+            try
+            {
+                if (timeout == TimeSpan.Zero)
+                    await _semaphore.WaitAsync(token);
+                else if (!await _semaphore.WaitAsync(timeout, token)) throw new TimeoutException();
+
+                return await wrapped();
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        /// <inheritdoc cref="Execute{TResult}" />
+        public async Task ExecuteAsync(Func<Task> wrapped, TimeSpan timeout = default,
+            CancellationToken token = default)
+        {
+            if (wrapped == null) throw new ArgumentNullException(nameof(wrapped));
+
+            try
+            {
+                if (timeout == TimeSpan.Zero)
+                    await _semaphore.WaitAsync(token);
+                else if (!await _semaphore.WaitAsync(timeout, token)) throw new TimeoutException();
+
+                await wrapped();
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Static cache of <see cref="ConcurrentExecutor" />
+    /// </summary>
+    public static class ConcurrentExecutorCache
+    {
+        /// <summary>
+        ///     Cache of all created named executors
+        /// </summary>
+        private static readonly ConcurrentDictionary<string, ConcurrentExecutor> Executors =
+            new ConcurrentDictionary<string, ConcurrentExecutor>();
+
+        /// <summary>
+        ///     Returns existing or created new named executor
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="maxParallelTasks"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        public static ConcurrentExecutor GetOrCreate(string name, int maxParallelTasks)
+        {
+            if (name == null) throw new ArgumentNullException(nameof(name));
+
+            return Executors.GetOrAdd(name, new ConcurrentExecutor(maxParallelTasks));
+        }
+
+        /// <summary>
+        ///     Clear cache of named executors
+        /// </summary>
+        public static void ClearExecutors()
+        {
+            Executors.Clear();
+        }
+    }
+}

ZeroCode.Core/GenericDisposable.cs

@@ -0,0 +1,62 @@
+using System;
+
+namespace ZeroCode
+{
+    /// <summary>
+    ///     Class implemented <see cref="IDisposable" />, that can be set to invoke custom action on
+    ///     <see cref="IDisposable.Dispose" />. Useful for making custom unsubscribes.
+    /// </summary>
+    public class GenericDisposable : IDisposable
+    {
+        /// <summary>
+        ///     Empty instance of generic disposable
+        /// </summary>
+        public static readonly GenericDisposable Empty = new GenericDisposable();
+
+        /// <summary>
+        ///     Action that must be invoked on dispose of this object. Provide state as argument.
+        /// </summary>
+        private readonly Action<object?>? _actionOnDispose;
+
+        /// <summary>
+        ///     Action that must be invoked on dispose of this object.
+        /// </summary>
+        private readonly Action? _actionOnDisposeWithoutState;
+
+        /// <summary>
+        ///     Custom state value that will be provided into action method on dispose.
+        /// </summary>
+        private readonly object? _state;
+
+        public GenericDisposable() { }
+
+        /// <param name="actionOnDispose">
+        ///     <inheritdoc cref="_actionOnDisposeWithoutState" />
+        /// </param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public GenericDisposable(Action actionOnDispose)
+        {
+            _actionOnDisposeWithoutState = actionOnDispose ?? throw new ArgumentNullException(nameof(actionOnDispose));
+        }
+
+        /// <param name="actionOnDispose">
+        ///     <inheritdoc cref="_actionOnDispose" />
+        /// </param>
+        /// <param name="state">
+        ///     <inheritdoc cref="_state" />
+        /// </param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public GenericDisposable(Action<object?> actionOnDispose, object? state)
+        {
+            _state = state;
+            _actionOnDispose = actionOnDispose ?? throw new ArgumentNullException(nameof(actionOnDispose));
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            _actionOnDispose?.Invoke(_state);
+            _actionOnDisposeWithoutState?.Invoke();
+        }
+    }
+}

ZeroCode.Core/GenericEqualityComparer.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ZeroCode
+{
+    /// <summary>
+    ///     Generic implementation of <see cref="IEqualityComparer{T}" /> that can be used for transforming equality comparer
+    ///     function into implementation of <see cref="IEqualityComparer{T}" />
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class GenericEqualityComparer<T> : IEqualityComparer<T>
+    {
+        /// <summary>
+        ///     Equality comparer function
+        /// </summary>
+        private readonly Func<T, T, bool> _comparer;
+
+        /// <summary>
+        ///     Functions that returns all candidates for calculating object hash code. Its important because LINQ uses hash codes
+        ///     often for equality compare.
+        /// </summary>
+        private readonly Func<T, object?[]> _hashCodeCandidatesFactory;
+
+        /// <param name="comparer">
+        ///     <inheritdoc cref="_comparer" />
+        /// </param>
+        /// <param name="hashCodeCandidatesFactory">
+        ///     <inheritdoc cref="_hashCodeCandidatesFactory" />
+        /// </param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public GenericEqualityComparer(Func<T, T, bool> comparer, Func<T, object?[]> hashCodeCandidatesFactory)
+        {
+            _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
+            _hashCodeCandidatesFactory = hashCodeCandidatesFactory ??
+                                         throw new ArgumentNullException(nameof(hashCodeCandidatesFactory));
+        }
+
+        /// <inheritdoc />
+        public bool Equals(T x, T y)
+        {
+            return (x, y) switch
+            {
+                (null, null) => true,
+                (null, _) => false,
+                (_, null) => false,
+                (_, _) when ReferenceEquals(x, y) => true,
+                _ => _comparer(x, y)
+            };
+        }
+
+        /// <inheritdoc />
+        public int GetHashCode(T obj)
+        {
+            unchecked
+            {
+                return _hashCodeCandidatesFactory(obj)
+                    .Aggregate(0, (current, candidate) =>
+                        (current * 397) ^ (candidate != null ? candidate.GetHashCode() : 0)
+                    );
+            }
+        }
+    }
+}

ZeroCode.Core/OneTimeDisposingHelper.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Threading;
+
+namespace ZeroCode
+{
+    /// <summary>
+    ///     Helper that can be used to prevent repeated invoke <see cref="IDisposable.Dispose" />
+    /// </summary>
+    public class OneTimeDisposingHelper
+    {
+        private int _disposingFlag;
+
+        /// <summary>
+        ///     Dependent object is already tried to dispose
+        /// </summary>
+        public bool IsDisposed => _disposingFlag != 0;
+
+        /// <summary>
+        ///     Check this trying to dispose is first time or repeat
+        /// </summary>
+        /// <returns></returns>
+        public bool TryDispose()
+        {
+            return Interlocked.CompareExchange(ref _disposingFlag, 1, 0) == 0;
+        }
+    }
+}