DEV Community: Antonio Falcão Jr.

Reactive DDD

Antonio Falcão Jr. — Thu, 23 Feb 2023 01:23:29 +0000

There are two ways to decompose and integrate distributed systems. One is easy, and the other one is better. The easy way to do things is orchestrated or declarative. The basic idea of an orchestrated system is that one entity tells another entity what to do. The other way to organize your services is through choreography and/or reactivity. Choreography solves the problems we face in declarative systems, like high coupling and low cohesion.

"Changes in downstream services may not disrupt upstream services."

Reactive DDD (Domain-Driven Design) is an approach to software development that combines principles from Domain-Driven Design and Reactive Programming to build highly extensible, scalable, and resilient systems. Reactive DDD focuses on modeling the domain's behavior in distributed, event-driven, inherently reactive systems.

Subdomain decomposition is an essential part of DDD, and in Reactive DDD, the subdomains are decomposed to support Choreographed event-driven architectures. Each subdomain is responsible for managing its own state, and changes to that state are communicated through events.

Event-Sourcing is the most efficient/appropriate persistence strategy here, given the eventual nature of the design. But it's subject to another post.

In an eventual and unpredictable environment about when an event occurs, how often the broker will deliver it, and in what order the subscriber will process it, Reactive DDD can help ensure that the system remains responsive and resilient by modeling such "uncertainties."

By modeling the domain as a set of reactive components that communicate through events, the system can be designed to handle large volumes of requests, maintain consistency and reliability, and gracefully recover from failures.

Reactive DDD is a modern and trendy approach becoming increasingly popular for building complex distributed systems. It provides a way to decompose a domain into smaller, more manageable pieces and design them to support a reactive architecture. This can lead to more responsive, scalable, and resilient systems and can better handle the demands of an eventual environment.

If you're interested in modeling uncertainty with Reactive Domain-Driven Design (DDD), here are a few resources that might be helpful:

"Modeling Uncertainty with Reactive DDD" (article) by InfoQ: https://lnkd.in/dC7rS3WW
"Reactive DDD—When Concurrent Waxes Fluent" (presentation) by InfoQ: https://lnkd.in/d-QNA6-d
"Vaughn Vernon Uses Reactive DDD to Model Uncertainty in Microservices" (news article) by InfoQ: https://lnkd.in/dNJj7qkP
"Vaughn Vernon: Reactive Domain-Driven Design" (news article) by InfoQ: https://lnkd.in/dhdiHdHE

[Best practice] C# 9 Records as DDD Value Objects with EF Core 6

Antonio Falcão Jr. — Thu, 17 Jun 2021 13:25:22 +0000

AntonioFalcaoJr / Dotnet6.EFCore6.Record.ValueObjects

This project aims to demonstrate the configuration and use of Records as Value Objects with EF Core 6

Value Objects

A value object is a small object that represents a simple entity whose equality is not based on identity. Two value objects are equal when they have the same value, not necessarily being the same object

Main characteristics:

They have no identity.
They are immutable.

Records

Defines a reference type that provides built-in functionality for encapsulating data. Is possible to create record types with immutable properties.

Immutability

A record type is not necessarily immutable. Is possible to declare properties with set accessors and fields that aren't readonly. But while records can be mutable, they make it easier to create immutable data models.

Equality

Value equality means that two variables of a record type are equal if the types match and all property and field values match. For other reference types, equality means identity. That is, two variables of a reference type are equal if they refer to the same object.

For value objects as record types, the synthesized equality members by default would be something like:



class R1 : IEquatable<R1>
{
    public T1 P1 { get; init; }

    protected virtual Type EqualityContract => typeof(R1);

    public override bool Equals(object? obj) => Equals(obj as R1);

    public virtual bool Equals(R1? other)
    {
        return !(other is null) &&
            EqualityContract == other.EqualityContract &&
            EqualityComparer<T1>.Default.Equals(P1, other.P1);
    }

    public static bool operator==(R1? left, R1? right)
        => (object)left == right || (left?.Equals(right) ?? false);

    public static bool operator!=(R1? left, R1? right)
        => !(left == right);

    public override int GetHashCode()
    {
        return Combine(EqualityComparer<Type>.Default.GetHashCode(EqualityContract),
            EqualityComparer<T1>.Default.GetHashCode(P1));
    }
}

Persist value objects as owned entity types in EF Core

Even with some gaps between the canonical value object pattern in DDD and the owned entity type in EF Core, it's currently the best way to persist value objects with EF Core.

An owned entity type allows you to map types that do not have their own identity explicitly defined in the domain model and are used as properties, such as a value object.

The identity of instances of owned types is not completely their own. It consists of three components:

The identity of the owner
The navigation property pointing to them
In the case of collections of owned types, an independent component.

Entity



public class Person : Entity<Guid>
{
    public Person(string name, int age) 
        => (Name, Age) = (name, age);

    public string Name { get; }
    public int Age { get; }
    public Address Address { get; private set; }

    public void DefineAddress(Address address)
    {
        if (address is null) throw new BusinessException("Home address must be informed");
        // Benefit of the record Equality Contract
        if(address.Equals(Address)) return;
        Address = address;
    }
}

Value object



public record Address : Abstractions.ValueObject
{
    // Empty constructor in this case is required by EF Core,
    // because has a complex type as a parameter in the default constructor.
    private Address() { }

    public Address(Street street, string zipCode)
        => (Street, ZipCode) = (street, zipCode);

    public Street Street { get; private init; }
    public string ZipCode { get; private init; }
}

Configuring

To solve the relationship required for the relational database, the identifier has to be defined as a shadow property.



public class PersonConfiguration : IEntityTypeConfiguration<Person>
{
    public void Configure(EntityTypeBuilder<Person> builder)
    {
        builder.HasKey(user => user.Id);

        ...

        // Configures a relationship where the Address is owned by (or part of) Person.
        builder.OwnsOne(
            person => person.Address,
            addressNavigationBuilder =>
            {
                // Configures a different table that the entity type maps to when targeting a relational database.
                addressNavigationBuilder
                    .ToTable("Addresses");

                // Configures the relationship to the owner, and indicates the Foreign Key.
                addressNavigationBuilder
                    .WithOwner()
                    .HasForeignKey("PersonId"); // Shadow Foreign Key

                // Configure a property of the owned entity type, in this case the to be used as Primary Key
                addressNavigationBuilder
                    .Property<Guid>("Id"); // Shadow property

                // Sets the properties that make up the primary key for this owned entity type.
                addressNavigationBuilder
                    .HasKey("Id"); // Shadow Primary Key

                // Configures a relationship where the Street is owned by (or part of) Addresses.
                // In this case, is not used "ToTable();" to maintain the owned and owner in the same table. 
                addressNavigationBuilder.OwnsOne(
                    address => address.Street,
                    streetNavigationBuilder =>
                    {
                        ...

                        // Configures a relationship where the City is owned by (or part of) Street.
                        // In this case, is not used "ToTable();" to maintain the owned and owner in the same table. 
                        streetNavigationBuilder.OwnsOne(
                            street => street.City,
                            cityNavigationBuilder =>
                            {
                                ...
                            });
                    });
            });
    }
}

Script produced



CREATE TABLE [Persons]
(
    [Id]   uniqueidentifier NOT NULL,
    [Name] varchar(128)     NOT NULL,
    [Age]  int              NOT NULL,
    CONSTRAINT [PK_Persons] PRIMARY KEY ([Id])
);

CREATE TABLE [Addresses]
(
    [Id]                                 uniqueidentifier NOT NULL,
    [Street_City_Name]                   varchar(128)     NULL,
    [Street_City_State_Country_Initials] varchar(8)       NULL,
    [Street_City_State_Country_Name]     varchar(128)     NULL,
    [Street_City_State_Initials]         varchar(8)       NULL,
    [Street_City_State_Name]             varchar(128)     NULL,
    [Street_Name]                        varchar(128)     NULL,
    [Street_Number]                      int              NULL,
    [ZipCode]                            varchar(32)      NULL,
    [PersonId]                           uniqueidentifier NOT NULL,
    CONSTRAINT [PK_Addresses] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_Addresses_Persons_PersonId] FOREIGN KEY ([PersonId]) REFERENCES [Persons] ([Id]) ON DELETE CASCADE
);

CREATE UNIQUE INDEX [IX_Addresses_PersonId] ON [Addresses] ([PersonId]);

Deleting orphans Value Objects with EF Core

The relationship between parent and child entities may be required or optional. A required relationship means that the child cannot exist without a parent, and if the parent is deleted or the relationship between the child and the parent is severed, then the child becomes orphaned. In this case, EF Core will perform a automatically child deletion.

AntonioFalcaoJr / Dotnet6.EFCore6.Record.ValueObjects

This project aims to demonstrate the configuration and use of Records as Value Objects with EF Core 6

[Quick Tip] Dump the configuration easily and improve the developer experience.

Antonio Falcão Jr. — Sun, 30 May 2021 16:13:18 +0000

Always knowing the state of the application is a sign that the system is under control, but sometimes this is not trivial.

Depending on the environment, it is not a simple task to access the application settings, and making this information available in the wrong location can expose vulnerabilities.

With this simple approach is possible to define a complete and safely dump for configuration settings.

Route approache

Create an IEndpointRouteBuilder extensions method to encapsulate details and guarantee the right environment:

public static class EndpointRouteBuilderExtensions
{
    public static void MapDumpConfig(this IEndpointRouteBuilder endpoints, string pattern, 
        IConfigurationRoot configurationRoot, bool isProduction)
    {
        if (isProduction) return;

        endpoints.MapGet(
            pattern: pattern,
            requestDelegate: context 
                => context.Response.WriteAsync(
                    text: configurationRoot.GetDebugView(), 
                    cancellationToken: context.RequestAborted));
    }
}

As we can see, if the environment is the Production one, the configuration will be skipped.

Now, specify the middleware configuration details in Startup.cs, Adding a RouteEndpoint to the IEndpointRouteBuilder with /dump-config pattern:

public void Configure(IApplicationBuilder app)
{
    app.UseEndpoints(
            endpoints =>
                {
                    endpoints.MapDumpConfig(
                        pattern: "/dump-config",
                        configurationRoot: _configuration as IConfigurationRoot,
                        isProduction: _env.IsProduction());
                }
}

The resource will respond in http://localhost/dump-config.

Log approache

If prefer, is it possible to deliver the dump for a log service. In this case, is not necessary the skip statement:

public static void MapDumpConfig(this IEndpointRouteBuilder endpoints, string pattern, 
    IConfigurationRoot configurationRoot, ILogger logger)
{
    endpoints.MapGet(
        pattern: pattern,
        requestDelegate: context =>
            {
                logger.LogInformation("{Settings}", configurationRoot.GetDebugView());

                return context.Response.WriteAsync(
                    text: "Configuration dumped successfully.", 
                    cancellationToken: context.RequestAborted);
            });
}

And then, propagate the log resource:

public void Configure(IApplicationBuilder app , ILoggerFactory loggerFactory)
{
        app.UseEndpoints(
            endpoints =>
                {
                    endpoints.MapDumpConfig(
                        pattern: "/dump-config",
                        configurationRoot: _configuration as IConfigurationRoot,
                        logger: loggerFactory.CreateLogger<Startup>());
                }
}

Multiple strategy approache

public static void MapDumpConfig(this IEndpointRouteBuilder endpoints, string pattern, 
    IConfigurationRoot configurationRoot, bool isProduction, ILogger logger)
{
    endpoints.MapGet(
        pattern: pattern, 
        requestDelegate: context 
            => isProduction ? DumpToLogAsync(context) : DumpToResponseAsync(context));

    Task DumpToResponseAsync(HttpContext context)
        => context.Response.WriteAsync(
            text: configurationRoot.GetDebugView(), 
            cancellationToken: context.RequestAborted);

    Task DumpToLogAsync(HttpContext context)
    {
        logger.LogInformation("{Settings}", configurationRoot.GetDebugView());

        return context.Response.WriteAsync(
            text: "Configuration dumped successfully", 
            cancellationToken: context.RequestAborted);
    }
}

Conclusion

In this way, we can improve the developer experience given a simple way to check the actual state of the system.

[Quick Tip] Improving developer experience with Options Pattern validation on start.

Antonio Falcão Jr. — Thu, 27 May 2021 18:53:49 +0000

When we're new or have less contact with some project is hard to understand all configuration possibilities.

Option pattern is the most appropriate way to inject environment settings options into the application. isolating the options by scenario is adhering to important software engineering principles, such as Principle of Interface Segregation (ISP) and Separation of Concerns.

Validate the options is a good way to indicate what or how the definitions are out of the expectations, But until .NET 5 the interruption provided from validation just was thrown in run time.

From .NET 6 it is possible to enforce options validation check on start rather than in runtime, with the ValidatiOnStart() extension method from OptionsBuilder<TOptions>.

Below a simple example using ValidateDataAnnotations() and ValidateOnStart():

public static class ServiceCollectionExtensions
{
    public static OptionsBuilder<ApplicationOptions> ConfigureApplicationOptions(
        this IServiceCollection services, IConfigurationSection section)
        => services
            .AddOptions<ApplicationOptions>()
            .Bind(section)
            .ValidateDataAnnotations()
            .ValidateOnStart();
}

And the usage in StartUp:

services.ConfigureApplicationOptions(
    _configuration.GetSection(nameof(ApplicationOptions)));

ApplicationOptions defining property as Required and URL:

public class ApplicationOptions
{
    [Required, Url]
    public string HttpClientAddress { get; init; }
}

AppSettings setting the address wrongly on purpose:

{
  "ApplicationOptions": {
    "HttpClientAddress" : "localhost"
    }
}

And then, when running the application, the interruption throws the error:

Microsoft.Extensions.Options.OptionsValidationException:
DataAnnotation validation failed for members: 'HttpClientAddress'
with the error: 'The HttpClientAddress field is not a valid
fully-qualified http, https, or ftp URL.'.

As we can see, the error is pretty clear and indicates what way we can take to solve the problem.

Another validation approache

Data Annotations is not the only way to validate the options. The Validate() method provides a delegate Func<TOptions, bool> that allows any kind of validation strategy.

This sample uses the library Fluent Validation with InlineValidator<T> just to exemplify:

=> services
    .AddOptions<ApplicationOptions>()
    .Bind(section)
    .Validate(options =>
        {
            var validator = new InlineValidator<ApplicationOptions>();

            validator
                .RuleFor(applicationOptions => applicationOptions.HttpClientAddress)
                .NotNull()
                .NotEmpty()
                .WithMessage("HttpClientAddress must be informed");

            return validator
                .Validate(options, strategy => strategy.ThrowOnFailures())
                .IsValid;
        })
    .ValidateOnStart();

Conclusion

This tool as simple as powerful to help to have a better development environment.

Benchmark: Check to Skip

Antonio Falcão Jr. — Wed, 10 Feb 2021 18:23:29 +0000

Sometimes, you just need to check whether a collection is empty or null to skip execution. But how expensive is that?

This very simple benchmark tested some ways to do this:

AntonioFalcaoJr / Benchmark

Sometimes, you just need to check whether a collection is empty or null to skip execution. But how expensive is that?

Scenarios

// SCENARIO 1
    var list = Ids?.ToList() ?? new List<Guid>();
    if (list.Any() is false) { }

// SCENARIO 2
    var list = Ids?.ToArray() ?? Array.Empty<Guid>();
    if (list.Any() is false) { }

// SCENARIO 3
    // toList(); 
    var list = _ids?.ToList();
    if (list is null || list.Any() is false) { }
    // toArray();
    var list = _ids?.ToArray();
    if (list is null || list.Any() is false) { }

// SCENARIO 4
    // toList();
    var list = Ids?.ToList();
    if (list is {Count: > 0} is false) { }
    // toArray();
    var list = _ids?.ToArray();
    if (list is {Length: > 0} is false) { }

// SCENARIO 5
    // toList();
    var list = Ids?.ToList();
    if (list?.Count <= 0) { }
    // toArray();
    var list = _ids?.ToArray();
    if (list?.Length <= 0) { }

Result


BenchmarkDotNet=v0.12.1, OS=Windows 10.0.18363.1198 (1909/November2018Update/19H2)
Intel Core i7-9700 CPU 3.00GHz, 1 CPU, 8 logical and 8 physical cores
.NET Core SDK=5.0.101
  [Host]        : .NET Core 5.0.1 (CoreCLR 5.0.120.57516, CoreFX 5.0.120.57516), X64 RyuJIT
  .NET Core 3.1 : .NET Core 3.1.10 (CoreCLR 4.700.20.51601, CoreFX 4.700.20.51901), X64 RyuJIT
  .NET Core 5.0 : .NET Core 5.0.1 (CoreCLR 5.0.120.57516, CoreFX 5.0.120.57516), X64 RyuJIT

Method	Runtime	Mean	Error	StdDev	Ratio	RatioSD
Scenario1	Core 3.1	25.0384ns	0.5082ns	0.5649ns	2.64	0.06
Scenario1	.NET Core 5.0	9.5186ns	0.1186ns	0.1109ns	1.00	0.00


Scenario2	Core 3.1	7.0908ns	0.0687ns	0.0537ns	0.63	0.00
Scenario2	.NET 5	11.2512ns	0.0510ns	0.0426ns	1.00	0.00


Scenario3 toList	Core 3.1	0.4756ns	0.0099ns	0.0093ns	0.85	0.04
Scenario3 toList	.NET 5	0.5622ns	0.0278ns	0.0246ns	1.00	0.00


Scenario3 toArray	Core 3.1	0.4801ns	0.0074ns	0.0069ns	0.99	0.02
Scenario3 toArray	.NET 5	0.4854ns	0.0108ns	0.0101ns	1.00	0.00


Scenario4 toList	Core 3.1	0.2452ns	0.0024ns	0.0022ns	1.14	0.03
Scenario4 toList	.NET 5	0.2164ns	0.0058ns	0.0045ns	1.00	0.00


Scenario4 toArray	Core 3.1	0.4812ns	0.0082ns	0.0064ns	0.99	0.03
Scenario4 toArray	.NET 5	0.4856ns	0.0119ns	0.0111ns	1.00	0.00


Scenario5 toList	Core 3.1	0.2381ns	0.0060ns	0.0050ns	1.06	0.06
Scenario5 toList	.NET 5	0.2255ns	0.0166ns	0.0129ns	1.00	0.00


Scenario5 toArray	Core 3.1	0.6015ns	0.0365ns	0.0391ns	1.26	0.10
Scenario5 toArray	.NET 5	0.4802ns	0.0115ns	0.0107ns	1.00	0.00

Hints

Outliers

Scenarios.Scenario1: .NET Core 3.1         -> 1 outlier  was  removed (29.51 ns)
Scenarios.Scenario2: .NET Core 3.1         -> 3 outliers were removed (8.72 ns..8.88 ns)
Scenarios.Scenario2: .NET Core 5.0         -> 2 outliers were removed (12.83 ns, 13.51 ns)
Scenarios.Scenario3_toList: .NET Core 5.0  -> 1 outlier  was  removed (2.01 ns)
Scenarios.Scenario4_toList: .NET Core 5.0  -> 3 outliers were removed (1.65 ns..1.67 ns)
Scenarios.Scenario4_toArray: .NET Core 3.1 -> 3 outliers were removed (1.87 ns..1.93 ns)
Scenarios.Scenario5_toList: .NET Core 3.1  -> 2 outliers were removed (1.64 ns, 1.65 ns)
Scenarios.Scenario5_toList: .NET Core 5.0  -> 3 outliers were removed (1.65 ns..1.68 ns)
Scenarios.Scenario5_toArray: .NET Core 3.1 -> 1 outlier  was  removed (2.08 ns)

Legends

Mean    : Arithmetic mean of all measurements
Error   : Half of 99.9% confidence interval
StdDev  : Standard deviation of all measurements
Ratio   : Mean of the ratio distribution ([Current]/[Baseline])
RatioSD : Standard deviation of the ratio distribution ([Current]/[Baseline])
1 ns    : 1 Nanosecond (0.000000001 sec)

GitHub dark mode, isn't it amazing?

Antonio Falcão Jr. — Tue, 08 Dec 2020 18:14:34 +0000

Now, you can choose between Defaul to system, Light and Dark themes:

Did you discover the dark mode too?

About a .NET 5 (RC1) Web application with GraphQL 3

Antonio Falcão Jr. — Tue, 15 Sep 2020 17:28:54 +0000

Yesterday (09/14) was released the first version (RC1) from .NET 5, ASP.NET, EF Core and C# 9.

Still talking about releases, since last week is available the version 3 from GraphQL for .NET.

On occasion, this project exemplify the implementation and Dockerization of a simple Razor Web MVC Core consuming an GraphQL 3 Web API, build in a .NET 5 multilayer project, considering development best practices, like SOLID and DRY, applying Domain-Driven concepts in a Hexagonal Architecture.

AntonioFalcaoJr / Dotnet6.GraphQL4.WebApplication

This project exemplifies the implementation and dockerization of a simple Razor Web MVC Core consuming a full GraphQL 4 Web API, build in a .NET 6 multi-layer project, considering development best practices, like SOLID and DRY, applying Domain-Driven concepts in a Onion Architecture.

Highlights

Notifications (pattern/context)

To avoid handle exceptions, was implemented a NotificationContext that's allow all layers add business notifications through the request, with support to receive Domain notifications, that by other side, implement validators from Fluent Validation and return a ValidationResult.

protected bool OnValidate<TEntity>(TEntity entity, AbstractValidator<TEntity> validator)
{
    ValidationResult = validator.Validate(entity);
    return IsValid;
}

protected void AddError(string errorMessage, ValidationResult validationResult = default)
{
    ValidationResult.Errors.Add(new ValidationFailure(default, errorMessage));
    validationResult?.Errors.ToList().ForEach(failure => ValidationResult.Errors.Add(failure));
}

To GraphQL the notification context delivers a ExecutionErrors that is propagated to result from execution by a personalized Executer:

var result = await base.ExecuteAsync(operationName, query, variables, context, cancellationToken);
var notificationContext = _serviceProvider.GetRequiredService<INotificationContext>();

if (notificationContext.HasNotifications)
{
    result.Errors = notificationContext.ExecutionErrors;
    result.Data = default;
}

Resolving `Scoped` dependencies with `Singleton` Schema.

Is necessary, in the same personalized Executer to define the service provider that will be used for resolvers on fields:

var options = base.GetOptions(operationName, query, variables, context, cancellationToken);
options.RequestServices = _serviceProvider;

Abstractions

With abstract designs, it is possible to reduce coupling in addition to applying DRY concepts, providing resources for the main behaviors:

...Domain.Abstractions

public abstract class Entity<TId>
    where TId : struct

public abstract class Builder<TBuilder, TEntity, TId> : IBuilder<TEntity, TId>
    where TBuilder : Builder<TBuilder, TEntity, TId>
    where TEntity : Entity<TId>
    where TId : struct

...Repositories.Abstractions

public abstract class Repository<TEntity, TId> : IRepository<TEntity, TId>
    where TEntity : Entity<TId>
    where TId : struct
{
    private readonly DbSet<TEntity> _dbSet;

    protected Repository(DbContext dbDbContext)
    {
        _dbSet = dbDbContext.Set<TEntity>();
    }

...Services.Abstractions

public abstract class Service<TEntity, TModel, TId> : IService<TEntity, TModel, TId>
    where TEntity : Entity<TId>
    where TModel : Model<TId>
    where TId : struct
{
    protected readonly IMapper Mapper;
    protected readonly INotificationContext NotificationContext;
    protected readonly IRepository<TEntity, TId> Repository;
    protected readonly IUnitOfWork UnitOfWork;

    protected Service(
        IUnitOfWork unitOfWork,
        IRepository<TEntity, TId> repository,
        IMapper mapper,
        INotificationContext notificationContext)
    {
        UnitOfWork = unitOfWork;
        Repository = repository;
        Mapper = mapper;
        NotificationContext = notificationContext;
    }

public abstract class MessageService<TMessage, TModel, TId> : IMessageService<TMessage, TModel, TId>
    where TMessage : class
    where TModel : Model<TId>
    where TId : struct
{
    private readonly IMapper _mapper;
    private readonly ISubject<TMessage> _subject;

    protected MessageService(IMapper mapper, ISubject<TMessage> subject)
    {
        _mapper = mapper;
        _subject = subject;
    }

From `EF TPH` to `GraphQL Interface`

GraphQL interfaces provide a very interesting way to represent types derived from entities. In turn, in EF Core we can structure with TPH.

ENTITY

public class ProductConfig : IEntityTypeConfiguration<Product>
{
    public void Configure(EntityTypeBuilder<Product> builder)
    {
        builder
            .HasDiscriminator()
            .HasValue<Boot>(nameof(Boot))
            .HasValue<Kayak>(nameof(Kayak))
            .HasValue<Backpack>(nameof(Backpack));
    }
}

INHERITOR

public class KayakConfig : IEntityTypeConfiguration<Kayak>
{
    public void Configure(EntityTypeBuilder<Kayak> builder)
    {
        builder
            .HasBaseType<Product>();
    }
}

INTERFACE

public sealed class ProductInterfaceGraphType : InterfaceGraphType<Product>
{
    public ProductInterfaceGraphType(BootGraphType bootGraphType, BackpackGraphType backpackGraphType, KayakGraphType kayakGraphType)
    {
        Name = "product";

        ResolveType = @object =>
        {
            return @object switch
            {
                Boot _ => bootGraphType,
                Backpack _ => backpackGraphType,
                Kayak _ => kayakGraphType,
                _ => default
            };
        };
    }
}

OBJECT

public sealed class KayakGraphType : ObjectGraphType<Kayak>
{
    public KayakGraphType()
    {
        Name = "kayak";
        Interface<ProductInterfaceGraphType>();
        IsTypeOf = o => o is Product;
    }
}

Environment configuration

Development

Secrets

To configure database resource, init secrets in https://github.com/AntonioFalcao/Dotnet5.GraphQL3.WebApplication/tree/master/src/Dotnet5.GraphQL3.Store.WebAPI, and then define the DefaultConnection:

dotnet user-secrets init
dotnet user-secrets set "ConnectionStrings:DefaultConnection" "Server=localhost,1433;Database=Store;User=sa;Password=!MyComplexPassword"

After this, to configure the HTTP client, init secrets in https://github.com/AntonioFalcao/Dotnet5.GraphQL3.WebApplication/tree/master/src/Dotnet5.GraphQL3.Store.WebMVC and define Store client host:

dotnet user-secrets init
dotnet user-secrets set "HttpClient:Store" "http://localhost:5000/graphql"

AppSettings

If you prefer, is possible to define it on WebAPI appsettings.Development.json and WebMVC appsettings.Development.json files:

WebAPI

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost,1433;Database=Store;User=sa;Password=!MyComplexPassword"
  }
}

WebMCV

{
  "HttpClient": {
    "Store": "http://localhost:5000/graphql"
  }
}

Production

Considering use Docker for CD (Continuous Deployment). On respective compose both web applications and sql server are in the same network, and then we can use named hosts. Already defined on WebAPI appsettings.json and WebMVC appsettings.json files:

AppSettings

WebAPI

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=mssql;Database=Store;User=sa;Password=!MyComplexPassword"
  }
}

WebMCV

{
  "HttpClient": {
    "Store": "http://webapi:5000/graphql"
  }
}

Running

The ./docker-compose.yml provide the WebAPI, WebMVC and MS SQL Server applications:

docker-compose up -d

GraphQL Playground

By default Playground respond at http://localhost:5000/ui/playground but is possible configure the host and many others details in ../...WebAPI/GraphQL/DependencyInjection/Configure.cs

app.UseGraphQLPlayground(
    new GraphQLPlaygroundOptions
    {
        Path = "/ui/playground",
        BetaUpdates = true,
        RequestCredentials = RequestCredentials.Omit,
        HideTracingResponse = false,

        EditorCursorShape = EditorCursorShape.Line,
        EditorTheme = EditorTheme.Dark,
        EditorFontSize = 14,
        EditorReuseHeaders = true,
        EditorFontFamily = "JetBrains Mono"
    });

Queries

Fragment for comparison and Arguments

QUERY

{
  First: product(id: "2c05b59b-8fb3-4cba-8698-01d55a0284e5") {
    ...comparisonFields
  }
  Second: product(id: "65af82e8-27f6-44f3-af4a-029b73f14530") {
    ...comparisonFields
  }
}

fragment comparisonFields on Product {
  id
  name
  rating
  description
}

RESULT

{
  "data": {
    "First": {
      "id": "2c05b59b-8fb3-4cba-8698-01d55a0284e5",
      "name": "libero",
      "rating": 5,
      "description": "Deleniti voluptas quidem accusamus est debitis quisquam enim."
    },
    "Second": {
      "id": "65af82e8-27f6-44f3-af4a-029b73f14530",
      "name": "debitis",
      "rating": 10,
      "description": "Est veniam unde."
    }
  }
}

Query named's and Variables

QUERY

query all {
  products {
    id
    name
  }
}

query byid($productId: ID!) {
  product(id: $productId) {
    id
    name
  }
}

VARIABLES

{
  "productId": "2c05b59b-8fb3-4cba-8698-01d55a0284e5"
}

HTTP BODY

{
    "operationName": "byid",
    "variables": {
        "productId": "2c05b59b-8fb3-4cba-8698-01d55a0284e5"
    },
    "query": "query all {
        products {
          id
          name
        }
    }
    query byid($productId: ID!) {
        product(id: $productId) {
          id
          name
        }
    }"
}

PLAYGROUND

Variables with include, skip and default value

QUERY

query all($showPrice: Boolean = false) {
  products {
    id
    name
    price @include(if: $showPrice)
    rating @skip(if: $showPrice)
  }
}

VARIABLES

{
  "showPrice": true
}

HTTP BODY

{
    "operationName": "all",
    "variables": {
        "showPrice": false
    },
    "query": "query all($showPrice: Boolean = false) {
          products {
            id
            name
            price @include(if: $showPrice)
            rating @skip(if: $showPrice)
          }
    }"
}

Mutations

MUTATION

Creating / adding a new Review to the respective product.

mutation($review: reviewInput!) {
  createReview(review: $review) {
    id
  }
}

VARIABLES

{
  "review": {
    "title": "some title",
    "comment": "some comment",
    "productId": "0fb8ec7e-7af1-4fe3-a2e2-000996ffd20f"
  }
}

RESULT

{
  "data": {
    "createReview": {
      "title": "some title"
    }
  }
}

Subscriptions

SUBSCRIPTION

The Mutation stay listening if a new review is added.

subscription {
  reviewAdded {
    title
  }
}

RESULT

{
  "data": {
    "reviewAdded": {
      "title": "Some title"
    }
  }
}

Built With

Microsoft Stack - v5.0 (RC 1)

.NET 5.0 - Base framework;
ASP.NET 5.0 - Web framework;
Entity Framework Core 5.0 - ORM;
Microsoft SQL Server on Linux for Docker - Database.

GraphQL Stack - v3.0 (preview/alpha)

GraphQL - GraphQL is a query language for APIs and a runtime for fulfilling those queries with data;
GraphQL for .NET - This is an implementation of GraphQL in .NET;
GraphQL.Client - A GraphQL Client for .NET over HTTP;
GraphQL Playground - GraphQL IDE for better development workflows.

Community Stack

AutoMapper - A convention-based object-object mapper;
FluentValidation - A popular .NET library for building strongly-typed validation rules;
Bogus - A simple and sane fake data generator for C#, F#, and VB.NET;
Bootstrap - The most popular HTML, CSS, and JS library in the world.

AntonioFalcaoJr / Dotnet6.GraphQL4.WebApplication

This project exemplifies the implementation and dockerization of a simple Razor Web MVC Core consuming a full GraphQL 4 Web API, build in a .NET 6 multi-layer project, considering development best practices, like SOLID and DRY, applying Domain-Driven concepts in a Onion Architecture.

Using .NET Core in AWS Lambda with SAM and building an Auto-Scaling Manager

Antonio Falcão Jr. — Sun, 19 Jul 2020 18:57:31 +0000

This project demonstrates the integration with AWS Auto-Scaling service and .NET Core, using SAM for building and test.

You can find the full source project here.

AntonioFalcaoJr / Dotnet.AWSLambda.AutoScaling

This project demonstrates the integration with AWS Auto Scaling service and .NET Core, using SAM for building and test.

This sample contains source code and supporting files for a serverless application that you can deploy with the SAM CLI.

./src - Multilayer .NET Core project for the application's Lambda function.
./.events - Invocation events that you can use to invoke the function.
./test - Unit tests for the application code with XUnit.
template.yaml - A template that defines the application's AWS resources.

How its works

Using a JSON as input is possible to suspend or resume processes from a specific auto-scaling by tag name.

Use case: SUSPEND the Terminate and Launch processes as the initial stage from Blue-Green Deploy on Code Pipeline and then, RESUME in the final stage.

JSON sample for use at AWS or in this project.

{
    "Scalings": [
        {
            "Tag": "tag-name-here",
            "Suspend": false
        }
    ]
}

Many scalings:

{
    "Scalings": [
        {
            "Tag": "tag-name-here",
            "Suspend": false
        },
        {
            "Tag": "tag-name-here",
            "Suspend": true
        }
    ]
}

About Processes is possible to specify, but if not it will use the default list.

{
    "Scalings": [
        {
            "Tag": "tag-name-here",
            "Suspend": false,
            "Processes": [
                "Terminate",
                "Launch"
            ]
        }
    ]
}

Default values are defined on file ProcessService.cs:

public class ProcessService : IProcessService
{
    private static ProcessType LaunchProcessType => new ProcessType {ProcessName = "Launch"};
    private static ProcessType ScheduledActionsProcessType => new ProcessType {ProcessName = "ScheduledActions"};
    private static ProcessType TerminateProcessType => new ProcessType {ProcessName = "Terminate"};

// comment for brevity
}

Function Project

This project consists of:

Dotnet.AWSLambda.AutoScaling.Application.Function.cs - class file containing a class with a single function handler method;
aws-lambda-tools-defaults.json - default argument settings for use with Rider or Visual Studio and command line deployment tools for AWS.

Amazon.Lambda.Tools:

Install Amazon.Lambda.Tools Global Tools if not already installed.

dotnet tool install -g Amazon.Lambda.Tools

If already installed check if a new version is available.

dotnet tool update -g Amazon.Lambda.Tools

About SAM

The Serverless Application Model Command Line Interface (SAM CLI) is an extension of the AWS CLI that adds functionality for building and testing Lambda applications. It uses Docker to run your functions in an Amazon Linux environment that matches Lambda. It can also emulate your application's build environment and API.

To use the SAM CLI, you need the following tools.

SAM CLI - Install the SAM CLI
.NET Core - Install .NET Core
Docker - Install Docker community edition

Use the SAM CLI to build and test locally

Build application with the sam build command.

sam build

The SAM CLI installs dependencies defined in ./src/Dotnet.AWSLambda.AutoScaling.Application/Dotnet.AWSLambda.AutoScaling.Application.csproj, creates a deployment package, and saves it in the .aws-sam/build folder.

Events

Test a single function by invoking it directly with a test event. An event is a JSON document that represents the input that the function receives from the event source. Test events are included in the ./.events folder in this project.

json-event.json represents a simple json input.

request-event.json represents a request json input.

Run functions locally and invoke them with the sam local invoke command.

sam local invoke -e json-event.json

sam local invoke -e request-event.json

API Request

The SAM CLI can also emulate the application's as API. Use the sam local start-api to run the API locally on port 3000.

sam local start-api

Then, is possible to request using cURL or REST Client:

cURL

curl --header "Content-Type: application/json" -X POST -d "{ 'Scalings': [ { 'Tag': 'your-tag-name-here', 'Suspend': false }, { 'Tag': 'your-tag-name-h', 'Suspend': true } ] }" http://127.0.0.1:3000/api

REST Client

POST http://127.0.0.1:3000/api/
content-type: application/json

{
    "Scalings": [
        {
            "Tag": "tag-name-here",
            "Suspend": false
        },
        {
            "Tag": "tag-name-here",
            "Suspend": true
        }
    ]
}

API settings

The SAM CLI reads the application template to determine the API's routes and the functions that they invoke.

  Events:
    AutoScalingManager:
      Type: Api
      Properties:
        Path: '/api'
        Method: post

Credentials

You can set credentials in the AWS credentials file on your local system. This file must be located in one of the following locations:

~/.aws/credentials on Linux or macOS
C:\Users\USERNAME\.aws\credentials on Windows

This file should contain lines in the following format:

[default]
aws_access_key_id = your_access_key_id
aws_secret_access_key = your_secret_access_key

Environment variables – You can set the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables.

To set these variables on Linux or macOS, use the export command:

export AWS_ACCESS_KEY_ID=your_access_key_id
export AWS_SECRET_ACCESS_KEY=your_secret_access_key

To set these variables on Windows, use the set command:

set AWS_ACCESS_KEY_ID=your_access_key_id
set AWS_SECRET_ACCESS_KEY=your_secret_access_key

If you are testing this lambda project with SAM, is necessary to inform the credentials on template.yaml:

  Environment:
    Variables:
      AWS_ACCESS_KEY_ID: VALUE
      AWS_SECRET_ACCESS_KEY: VALUE
      AWS_DEFAULT_REGION: VALUE

Unit tests

Tests are defined in the test folder in this project.

dotnet test

You can find the full source project here.

AntonioFalcaoJr / Dotnet.AWSLambda.AutoScaling

This project demonstrates the integration with AWS Auto Scaling service and .NET Core, using SAM for building and test.

Enjoy!

Using .NET 5 with VS Code on Linux.

Antonio Falcão Jr. — Thu, 25 Jun 2020 15:21:57 +0000

A simple and quick approach to use .NET 5 Preview with VS Code on Linux.

Before install, it's important to check .NET 5 - Supported OS versions

Installing

1 - Create a directory to use for the download location and change it into that directory, for example:

mkdir $HOME/dotnet_install && cd $HOME/dotnet_install

2 - Download the shell script with instructions:

curl -H 'Cache-Control: no-cache' -L https://aka.ms/install-dotnet-preview 
-o install-dotnet-preview.sh

3 - Run the script to begin the install:

sudo bash install-dotnet-preview.sh

The last step will download and unzip all packages and dependencies into dotnet_packages/ and then start the installation.

But if the environment is not "clean", it is possible that packages conflicts happen. In this case, the script will stop the execution, then we can do the installations manually, solving or replacing dependencies with conflicts.

cd dotnet_install

ls -l
  dotnet-5.0.0-preview.5-rpm.tar.gz  
  dotnet_packages/  
  install-dotnet-preview.sh

Use a package manager of your preference, and install all the SDKs, Runtimes, and dependencies packages. In this example, we decided to replace files:

cd dotnet_packages

ls -l
  aspnetcore-runtime-5.0.0-preview.5.20279.2-x64.rpm
  aspnetcore-targeting-pack-5.0.0-preview.5.20279.2.rpm
  dotnet-apphost-pack-5.0.0-preview.5.20278.1-x64.rpm
  dotnet-host-5.0.0-preview.5.20278.1-x64.rpm
  dotnet-hostfxr-5.0.0-preview.5.20278.1-x64.rpm
  dotnet-runtime-5.0.0-preview.5.20278.1-x64.rpm
  dotnet-runtime-deps.rpm
  dotnet-sdk-5.0.100-preview.5.20279.10-x64.rpm
  dotnet-targeting-pack-5.0.0-preview.5.20278.1-x64.rpm
  netstandard-targeting-pack-2.1.0-x64.rpm

sudo rpm -i --replacefiles netstandard-targeting-pack-2.1.0-x64.rpm

It's important to maintain the default CLI alias like dotnet because VS Code will use this way to create and run applications.

OR

If you prefer a more simple setup, you can install it using Snap. But, after install, is necessary to change alias from CLI:

sudo snap alias dotnet-sdk.dotnet dotnet

[IMPORTANT] If the dotnet CLI already installed, it's not recommended to use Snap installation, because it's occurrence in an isolated environment and it's not possible to have double alias like dotnet.

For more instructions or ways to install SDK/Runtime, use this documentation.

VS Code settings

To enjoy new features from C# 9 is necessary to install or update VS Code for version 1.46.

Some recommended extensions: C# and C# Extensions.

Projects settings

Now, we can build applications using preview version from .NET 5 just indicating on C Sharp Project (*.CSPROJ) file the respective versions from framework and language:

<Project Sdk="Microsoft.NET.Sdk.Web">

    <PropertyGroup>
        <TargetFramework>net5.0</TargetFramework>
        <LangVersion>preview</LangVersion>
    </PropertyGroup>

</Project>

Enjoy!

AntonioFalcaoJr / AntonioFalcaoJr

Antônio Falcão Jr. 👋

B.Sc & M.Sc student in Computer Science,
Software Architecture Specialist,
Staff Software Engineer.

View on GitHub

Using .NET 5 with Rider on Linux

Antonio Falcão Jr. — Sun, 21 Jun 2020 20:05:59 +0000

A simple and quick approach to use .NET 5 Preview with JetBrains Rider on Linux.

Before install is important to check .NET 5 - Supported OS versions

Installing

1 - Create a directory to use for the download location and change into that directory, for example:

mkdir $HOME/dotnet_install && cd $HOME/dotnet_install

2 - Download the shell script with instructions:

curl -H 'Cache-Control: no-cache' -L https://aka.ms/install-dotnet-preview 
-o install-dotnet-preview.sh

3 - Run the script to begin the install:

sudo bash install-dotnet-preview.sh

The last step will download and unzip all packages and dependencies into dotnet_packages/ and then start the installation.

cd dotnet_install

ls -l
  dotnet-5.0.0-preview.5-rpm.tar.gz  
  dotnet_packages/  
  install-dotnet-preview.sh

Use package manager of your preference, and install all the SDK's, Runtimes, and dependencies packages. In this example, we decided to replace files:

cd dotnet_packages

ls -l
  aspnetcore-runtime-5.0.0-preview.5.20279.2-x64.rpm
  aspnetcore-targeting-pack-5.0.0-preview.5.20279.2.rpm
  dotnet-apphost-pack-5.0.0-preview.5.20278.1-x64.rpm
  dotnet-host-5.0.0-preview.5.20278.1-x64.rpm
  dotnet-hostfxr-5.0.0-preview.5.20278.1-x64.rpm
  dotnet-runtime-5.0.0-preview.5.20278.1-x64.rpm
  dotnet-runtime-deps.rpm
  dotnet-sdk-5.0.100-preview.5.20279.10-x64.rpm
  dotnet-targeting-pack-5.0.0-preview.5.20278.1-x64.rpm
  netstandard-targeting-pack-2.1.0-x64.rpm

sudo rpm -i --replacefiles netstandard-targeting-pack-2.1.0-x64.rpm

OR

If you prefer an isolated environment and a more simple setup, you can install it using Snap.

If the dotnet CLI already installed, it's recommended to use an alias to differentiate the versions:

sudo snap alias dotnet-sdk.dotnet dotnet5

And then you can use it this way:

dotnet5 restore

dotnet5 build

...

For more instructions or ways to install SDK/Runtime, use this documentation.

Rider settings

If .NET 5 was installed into the default path, then Rider will detect the MSBuild version 16.0 automatically.

But, if it was in a different folder, as Snap installation, for example, it's necessary to inform .NET Core CLI executable and MSBuild version 16.0 on Rider settings, like this:

If other versions are installed, it may be necessary to change the SDK version in global.json to 5, allowing Rider to automatically detect MS Build 16.

{
  "sdk": {
    "version": "5.0.100-preview.5.20279.10"
  }
}

Projects settings

Now, we can build applications using preview version from .NET 5 just indicating on C Sharp Project (*.CSPROJ) file the respective versions from framework and language:

<Project Sdk="Microsoft.NET.Sdk.Web">

    <PropertyGroup>
        <TargetFramework>net5.0</TargetFramework>
        <LangVersion>preview</LangVersion>
    </PropertyGroup>

</Project>

Until this moment, Rider's version 2020.1 does not give support for C# 9 syntax and code inspections, so to use new features is necessary flexibility the code inspections.

Enjoy!

AntonioFalcaoJr / AntonioFalcaoJr

Antônio Falcão Jr. 👋

B.Sc & M.Sc student in Computer Science,
Software Architecture Specialist,
Staff Software Engineer.

View on GitHub

DEV Community: Antonio Falcão Jr.

Reactive DDD

[Best practice] C# 9 Records as DDD Value Objects with EF Core 6

AntonioFalcaoJr / Dotnet6.EFCore6.Record.ValueObjects

This project aims to demonstrate the configuration and use of Records as Value Objects with EF Core 6

Value Objects

Records

Immutability

Equality

Persist value objects as owned entity types in EF Core

Entity

Value object

Configuring

Script produced

Deleting orphans Value Objects with EF Core

AntonioFalcaoJr / Dotnet6.EFCore6.Record.ValueObjects

This project aims to demonstrate the configuration and use of Records as Value Objects with EF Core 6

[Quick Tip] Dump the configuration easily and improve the developer experience.

Route approache

Log approache

Multiple strategy approache

Conclusion

[Quick Tip] Improving developer experience with Options Pattern validation on start.

Another validation approache

Conclusion

Benchmark: Check to Skip

AntonioFalcaoJr / Benchmark

Sometimes, you just need to check whether a collection is empty or null to skip execution. But how expensive is that?

Scenarios

Result

Hints

Outliers

Legends

GitHub dark mode, isn't it amazing?

About a .NET 5 (RC1) Web application with GraphQL 3

AntonioFalcaoJr / Dotnet6.GraphQL4.WebApplication

This project exemplifies the implementation and dockerization of a simple Razor Web MVC Core consuming a full GraphQL 4 Web API, build in a .NET 6 multi-layer project, considering development best practices, like SOLID and DRY, applying Domain-Driven concepts in a Onion Architecture.

Highlights

Notifications (pattern/context)

Resolving Scoped dependencies with Singleton Schema.

Abstractions

From EF TPH to GraphQL Interface

Environment configuration

Development

Secrets

AppSettings

Production

AppSettings

Running

GraphQL Playground

Queries

Fragment for comparison and Arguments

Query named's and Variables

Variables with include, skip and default value

Mutations

Subscriptions

Built With

Microsoft Stack - v5.0 (RC 1)

GraphQL Stack - v3.0 (preview/alpha)

Community Stack

AntonioFalcaoJr / Dotnet6.GraphQL4.WebApplication

This project exemplifies the implementation and dockerization of a simple Razor Web MVC Core consuming a full GraphQL 4 Web API, build in a .NET 6 multi-layer project, considering development best practices, like SOLID and DRY, applying Domain-Driven concepts in a Onion Architecture.

Using .NET Core in AWS Lambda with SAM and building an Auto-Scaling Manager

AntonioFalcaoJr / Dotnet.AWSLambda.AutoScaling

This project demonstrates the integration with AWS Auto Scaling service and .NET Core, using SAM for building and test.

How its works

Function Project

Amazon.Lambda.Tools:

About SAM

Use the SAM CLI to build and test locally

Events

API Request

API settings

Credentials

Unit tests

You can find the full source project here.

AntonioFalcaoJr / Dotnet.AWSLambda.AutoScaling

This project demonstrates the integration with AWS Auto Scaling service and .NET Core, using SAM for building and test.

Enjoy!

Using .NET 5 with VS Code on Linux.

Resolving `Scoped` dependencies with `Singleton` Schema.

From `EF TPH` to `GraphQL Interface`