Refactoring

- Remove MediatR
- Update .Net9

Author: niko-olas

Modular.Monolithic.Architecture.Helper.sln

@@ -10,6 +10,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Elementi di soluzione", "El
 		.editorconfig = .editorconfig
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Modular.Monolithic.Architecture.Helper.Domain.Test", "test\Modular.Monolithic.Architecture.Helper.Domain.Test\Modular.Monolithic.Architecture.Helper.Domain.Test.csproj", "{2EEB3EA9-A09D-41DF-B700-16281D2CBA2B}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -20,6 +22,10 @@ Global
 		{08BAB259-27D2-4221-9689-7FF3158CB3E4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{08BAB259-27D2-4221-9689-7FF3158CB3E4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{08BAB259-27D2-4221-9689-7FF3158CB3E4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2EEB3EA9-A09D-41DF-B700-16281D2CBA2B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2EEB3EA9-A09D-41DF-B700-16281D2CBA2B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2EEB3EA9-A09D-41DF-B700-16281D2CBA2B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2EEB3EA9-A09D-41DF-B700-16281D2CBA2B}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

src/Modular.Monolithic.Architecture.Helper.Domain/Core/AggregateRoot.cs

@@ -1,6 +1,12 @@
-namespace Modular.Monolithic.Architecture.Helper.Domain.Core;
+
+namespace Modular.Monolithic.Architecture.Helper.Domain.Core;
 
 /// <summary>
-/// 
+/// Represents the base class that rappresent AggregateRoot.
 /// </summary>
-public abstract class AggregateRoot : Entity { }
+public abstract class AggregateRoot : Entity
+{
+    protected AggregateRoot(Guid id) : base(id)
+    {
+    }
+}

src/Modular.Monolithic.Architecture.Helper.Domain/Core/Entity.cs

@@ -1,4 +1,5 @@
-using Modular.Monolithic.Architecture.Helper.Domain.BusinessRules;
+using Modular.Monolithic.Architecture.Helper.Domain.Abstractions;
+using Modular.Monolithic.Architecture.Helper.Domain.BusinessRules;
 using Modular.Monolithic.Architecture.Helper.Domain.Events;
 using Modular.Monolithic.Architecture.Helper.Domain.Exceptions;
 
@@ -7,7 +8,7 @@ namespace Modular.Monolithic.Architecture.Helper.Domain.Core;
 /// <summary>
 /// Represents the base class that all entities derive from.
 /// </summary>
-public abstract class Entity
+public abstract class Entity : TypedIdValueBase
 {
 
     private List<IDomainEvent> _domainEvents;
@@ -16,14 +17,16 @@ public abstract class Entity
     /// Domain events occurred.
     /// </summary>
     public IReadOnlyCollection<IDomainEvent>? DomainEvents => _domainEvents?.AsReadOnly();
+
     /// <summary>
     /// Initializes a new instance of the <see cref="Entity"/> class.
     /// </summary>
     /// <remarks>
     /// Required by EF Core.
     /// </remarks>
-    protected Entity()
+    protected Entity(Guid id) : base(id)
     {
+
     }
     /// <summary>
     /// 

src/Modular.Monolithic.Architecture.Helper.Domain/Core/Enumeration.cs

@@ -0,0 +1,156 @@
+using System.Reflection;
+using Modular.Monolithic.Architecture.Helper.Domain.Maybe;
+
+namespace Modular.Monolithic.Architecture.Helper.Domain.Core;
+/// <summary>
+/// Represents an enumeration type.
+/// </summary>
+/// <typeparam name="TEnum">The type of the enumeration.</typeparam>
+public abstract class Enumeration<TEnum> : IEquatable<Enumeration<TEnum>>, IComparable<Enumeration<TEnum>>
+    where TEnum : Enumeration<TEnum>
+{
+    private static readonly Lazy<Dictionary<int, TEnum>> EnumerationsDictionary =
+        new Lazy<Dictionary<int, TEnum>>(() => GetAllEnumerationOptions().ToDictionary(item => item.Value));
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Enumeration{TEnum}"/> class.
+    /// </summary>
+    /// <param name="value">The value.</param>
+    /// <param name="name">The name.</param>
+    protected Enumeration(int value, string name)
+    {
+        Value = value;
+        Name = name;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Enumeration{TEnum}"/> class.
+    /// </summary>
+    /// <remarks>
+    /// Required by EF Core.
+    /// </remarks>
+    protected Enumeration()
+    {
+        Value = default;
+        Name = string.Empty;
+    }
+
+    /// <summary>
+    /// Gets the enumeration values.
+    /// </summary>
+    /// <returns>The read-only collection of enumeration values.</returns>
+    public static IReadOnlyCollection<TEnum> List => EnumerationsDictionary.Value.Values.ToList();
+
+    /// <summary>
+    /// Gets the value.
+    /// </summary>
+    public int Value { get; private set; }
+
+    /// <summary>
+    /// Gets the name.
+    /// </summary>
+    public string Name { get; private set; }
+
+    /// <summary>
+    /// Creates an enumeration of the specified type based on the specified value.
+    /// </summary>
+    /// <param name="value">The enumeration value.</param>
+    /// <returns>The enumeration instance that matches the specified value.</returns>
+    public static Maybe<TEnum> FromValue(int value) => EnumerationsDictionary.Value.TryGetValue(value, out TEnum enumeration)
+            ? Maybe<TEnum>.From(enumeration)
+            : Maybe<TEnum>.None;
+
+    /// <summary>
+    /// Checks if the there is an enumeration with the specified value.
+    /// </summary>
+    /// <param name="value">The value.</param>
+    /// <returns>True if there is an enumeration with the specified value, otherwise false.</returns>
+    public static bool ContainsValue(int value) => EnumerationsDictionary.Value.ContainsKey(value);
+
+    public static bool operator ==(Enumeration<TEnum> a, Enumeration<TEnum> b)
+    {
+        if (a is null && b is null)
+        {
+            return true;
+        }
+
+        if (a is null || b is null)
+        {
+            return false;
+        }
+
+        return a.Equals(b);
+    }
+
+    public static bool operator !=(Enumeration<TEnum> a, Enumeration<TEnum> b) => !(a == b);
+
+    /// <inheritdoc />
+    public bool Equals(Enumeration<TEnum> other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+
+        return GetType() == other.GetType() && other.Value.Equals(Value);
+    }
+
+    /// <inheritdoc />
+    public override bool Equals(object obj)
+    {
+        if (obj is null)
+        {
+            return false;
+        }
+
+        if (!(obj is Enumeration<TEnum> otherValue))
+        {
+            return false;
+        }
+
+        return GetType() == obj.GetType() && otherValue.Value.Equals(Value);
+    }
+
+    /// <inheritdoc />
+    public int CompareTo(Enumeration<TEnum> other) => other is null ? 1 : Value.CompareTo(other.Value);
+
+    /// <inheritdoc />
+    public override int GetHashCode() => Value.GetHashCode();
+
+    /// <summary>
+    /// Gets all of the defined enumeration options.
+    /// </summary>
+    /// <returns>The enumerable collection of enumerations.</returns>
+    private static IEnumerable<TEnum> GetAllEnumerationOptions()
+    {
+        Type enumType = typeof(TEnum);
+
+        IEnumerable<Type> enumerationTypes = Assembly
+            .GetAssembly(enumType)!
+            .GetTypes()
+            .Where(type => enumType.IsAssignableFrom(type));
+
+        var enumerations = new List<TEnum>();
+
+        foreach (Type enumerationType in enumerationTypes)
+        {
+            List<TEnum> enumerationTypeOptions = GetFieldsOfType<TEnum>(enumerationType);
+
+            enumerations.AddRange(enumerationTypeOptions);
+        }
+
+        return enumerations;
+    }
+
+    /// <summary>
+    /// Gets the fields of the specified type for the specified type.
+    /// </summary>
+    /// <typeparam name="TFieldType">The field type.</typeparam>
+    /// <param name="type">The type whose fields are being retrieved.</param>
+    /// <returns>The fields of the specified type for the specified type.</returns>
+    private static List<TFieldType> GetFieldsOfType<TFieldType>(Type type) =>
+        type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
+            .Where(fieldInfo => type.IsAssignableFrom(fieldInfo.FieldType))
+            .Select(fieldInfo => (TFieldType)fieldInfo.GetValue(null))
+            .ToList();
+}

src/Modular.Monolithic.Architecture.Helper.Domain/Events/IDomainEvent.cs

@@ -1,11 +1,10 @@
-using MediatR;
-
+
 namespace Modular.Monolithic.Architecture.Helper.Domain.Events;
 
 /// <summary>
 /// Represents the interface for an event that is raised within the domain.
 /// </summary>
-public interface IDomainEvent : INotification
+public interface IDomainEvent
 {
     Guid Id { get; }
 

src/Modular.Monolithic.Architecture.Helper.Domain/Maybe/Maybe.cs

@@ -0,0 +1,82 @@
+namespace Modular.Monolithic.Architecture.Helper.Domain.Maybe;
+/// <summary>
+/// Represents a wrapper around a value that may or may not be null.
+/// </summary>
+/// <typeparam name="T">The value type.</typeparam>
+public sealed class Maybe<T> : IEquatable<Maybe<T>>
+{
+    private readonly T _value;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Maybe{T}"/> class.
+    /// </summary>
+    /// <param name="value">The value.</param>
+    private Maybe(T value) => _value = value;
+
+    /// <summary>
+    /// Gets a value indicating whether or not the value exists.
+    /// </summary>
+    public bool HasValue => !HasNoValue;
+
+    /// <summary>
+    /// Gets a value indicating whether or not the value does not exist.
+    /// </summary>
+    public bool HasNoValue => _value is null;
+
+    /// <summary>
+    /// Gets the value.
+    /// </summary>
+    public T Value => HasValue
+        ? _value
+        : throw new InvalidOperationException("The value can not be accessed because it does not exist.");
+
+    /// <summary>
+    /// Gets the default empty instance.
+    /// </summary>
+    public static Maybe<T> None => new Maybe<T>(default);
+
+    /// <summary>
+    /// Creates a new <see cref="Maybe{T}"/> instance based on the specified value.
+    /// </summary>
+    /// <param name="value">The value.</param>
+    /// <returns>The new <see cref="Maybe{T}"/> instance.</returns>
+    public static Maybe<T> From(T value) => new Maybe<T>(value);
+
+    public static implicit operator Maybe<T>(T value) => From(value);
+
+    public static implicit operator T(Maybe<T> maybe) => maybe.Value;
+
+    /// <inheritdoc />
+    public bool Equals(Maybe<T> other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+
+        if (HasNoValue && other.HasNoValue)
+        {
+            return true;
+        }
+
+        if (HasNoValue || other.HasNoValue)
+        {
+            return false;
+        }
+
+        return Value.Equals(other.Value);
+    }
+
+    /// <inheritdoc />
+    public override bool Equals(object obj) =>
+        obj switch
+        {
+            null => false,
+            T value => Equals(new Maybe<T>(value)),
+            Maybe<T> maybe => Equals(maybe),
+            _ => false
+        };
+
+    /// <inheritdoc />
+    public override int GetHashCode() => HasValue ? Value.GetHashCode() : 0;
+}

src/Modular.Monolithic.Architecture.Helper.Domain/Maybe/MaybeExtensions.cs

@@ -0,0 +1,41 @@
+namespace Modular.Monolithic.Architecture.Helper.Domain.Maybe;
+
+/// <summary>
+/// Contains extension methods for the maybe class.
+/// </summary>
+public static class MaybeExtensions
+{
+    /// <summary>
+    /// Binds to the result of the function and returns it.
+    /// </summary>
+    /// <typeparam name="TIn">The result type.</typeparam>
+    /// <typeparam name="TOut">The output result type.</typeparam>
+    /// <param name="maybe">The result.</param>
+    /// <param name="func">The bind function.</param>
+    /// <returns>
+    /// The success result with the bound value if the current result is a success result, otherwise a failure result.
+    /// </returns>
+    public static async Task<Maybe<TOut>> Bind<TIn, TOut>(this Maybe<TIn> maybe, Func<TIn, Task<Maybe<TOut>>> func) =>
+        maybe.HasValue ? await func(maybe.Value) : Maybe<TOut>.None;
+
+    /// <summary>
+    /// Matches to the corresponding functions based on existence of the value.
+    /// </summary>
+    /// <typeparam name="TIn">The input type.</typeparam>
+    /// <typeparam name="TOut">The output type.</typeparam>
+    /// <param name="resultTask">The maybe task.</param>
+    /// <param name="onSuccess">The on-success function.</param>
+    /// <param name="onFailure">The on-failure function.</param>
+    /// <returns>
+    /// The result of the on-success function if the maybe has a value, otherwise the result of the failure result.
+    /// </returns>
+    public static async Task<TOut> Match<TIn, TOut>(
+        this Task<Maybe<TIn>> resultTask,
+        Func<TIn, TOut> onSuccess,
+        Func<TOut> onFailure)
+    {
+        var maybe = await resultTask;
+
+        return maybe.HasValue ? onSuccess(maybe.Value) : onFailure();
+    }
+}

src/Modular.Monolithic.Architecture.Helper.Domain/Modular.Monolithic.Architecture.Helper.Domain.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-      <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
+      <TargetFrameworks>net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
       <ImplicitUsings>enable</ImplicitUsings>
       <Nullable>enable</Nullable>
       <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
@@ -23,7 +23,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="MediatR" Version="12.3.0" />
     <PackageReference Include="Nerdbank.GitVersioning" Version="3.6.133">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>