App

The Devprime platform provides a modern software architecture strategy, and the App project is the initial design of the application, allowing connectivity with other components of the architecture.

Exploring the Devprime App

The Devprime App project provides some core files, such as App.cs, App.csproj, appsettings.json, and GlobalUsings.cs, as shown in the image.

These files are responsible for the application initialization settings, dependency inversion configuration, initial app.net configurations, Swagger, security and, mainly, the parameters of each adapter, which are treated in detail in the Settings section of the documentation.

Devprime architecture software diagram

Exploring the file App.cs

The file App.cs contains the fundamental implementations for the application initialization and follows a standard ASP.NET processing order criterion. An important point in this context is the creation of the Builder and Run, as well as the dependency injections that connect the entire application architecture project.

the name of the application or microservice is defined at that moment in line 23 DpApp(builder).Run("my-microsservices,(app)) and was automatically defined when the new microservice was created using the command dp new of the Devprime CLI.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Application Builder
var builder = WebApplication.CreateBuilder(args);

// Adding records for dependency injection. 
// This block is modified  when you run the
// dp init command to include new classes.

builder.Services.AddScoped<IPaymentRepository, PaymentRepository>();
builder.Services.AddScoped<IPaymentService, PaymentService>();
builder.Services.AddScoped<IPaymentState, PaymentState>();
builder.Services.AddMvc(o =>
{
    o.EnableEndpointRouting = false;
});

//Registering Devprime Adapters
builder.Services.AddScoped<IExtensions, Extensions>();
builder.Services.AddScoped<IEventStream, EventStream>();
builder.Services.AddScoped<IEventHandler,
Application.EventHandlers.EventHandler>();

// Application Run
await new DpApp(builder).Run("my-microsservices", (app) =>
{

    //The first stage of middleware registration
    app.UseRouting(); //Routes
    app.UseAuthentication(); //Security
    DpApp.UseDevPrimeSwagger(app); //Swagger
    app.UseAuthorization();//Security
    app.MapControllerRoute(name: "default", pattern:
    "{controller=Home}/{action=Index}/{id?}");//Routes

}, (builder) =>
{
    //The second stage of middleware registration
    DpApp.AddDevPrime(builder.Services);//Accelerators
    DpApp.AddDevPrimeSwagger(builder.Services);//Swagger
    DpApp.AddDevPrimeSecurity(builder.Services);//Security
});

Exploring the file App.csproj

The file App.csproj brings the dependencies for the other “Adapters” and “Core” projects that are part of the software architecture, as well as for the component devprime.stack.app of the Devprime Stack, which has intelligent behaviors that meet the context of the “App”.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

<Project Sdk="Microsoft.NET.Sdk.Web">
	<PropertyGroup>
		<TargetFramework>net7.0</TargetFramework>
		<Version>1.0.0.0</Version>
	</PropertyGroup>
	<ItemGroup>
		<ProjectReference Include=
        "..\Adapters\Services\DevPrime.Services.csproj" />
		<ProjectReference Include=
        "..\Adapters\State\DevPrime.State.csproj" />
		<ProjectReference Include=
        "..\Adapters\Extensions\DevPrime.Extensions.csproj" />
		<ProjectReference Include=
        "..\Adapters\Stream\DevPrime.Stream.csproj" />
		<ProjectReference Include=
        "..\Adapters\Web\DevPrime.Web.csproj" />
		<ProjectReference Include=
        "..\Adapters\Observability\DevPrime.Observability.csproj" />
		<ProjectReference Include=
        "..\Adapters\AppCenter\DevPrime.AppCenter.csproj" />
		<ProjectReference Include=
        "..\Adapters\HealthCheck\DevPrime.HealthCheck.csproj" />
		<ProjectReference Include=
        "..\Core\Application\Application.csproj" />
		<ProjectReference Include=
        "..\Core\Domain\Domain.csproj" />
	</ItemGroup>
	<ItemGroup>
    <PackageReference Include=
    "devprime.stack.app" Version="7.0.50" />
	</ItemGroup>
</Project>

This is a default implementation, and there is no need to modify the structure unless you want to adjust the following items:

Topic Description
TargetFramework .NET version and present in all projects
Version Update the release ID via DevOps
PackageReference Devprime Stack Context Reference

The dp stack command, provided by the Devprime CLI, should be used by the developer to automatically update the Devprime reference in all projects.

Exploring the Devprime project GlobalUsings.cs

The C# strategy for globally organizing the namespaces used in the project and allows you to update manually or by using the dp init from the Devprime CLI, if needed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

global using DevPrime.Stream;
global using DevPrime.Stack.Foundation.Stream;
global using DevPrime.Stack.Foundation;
global using DevPrime.Stack.App.Load;
global using Microsoft.AspNetCore.Builder;
global using Microsoft.Extensions.DependencyInjection;
global using DevPrime.Extensions;
global using Application.Interfaces.Adapters.Extensions;
global using Application.Interfaces.Adapters.State;
global using Application.Interfaces.Services;
global using Application.Services.Payment;
global using DevPrime.State.Repositories.Payment;
global using DevPrime.State.States;

Exploring the file appsettings.json

The Devprime platform provides the possibility of customization through the configuration file, which, in the development environment, is in the Devprime APP project and includes items such as: APP, Web, Stream, Observability, Security, State, Services and Custom.

Follow a summary example from the file appsettings.json. You can explore in detail in the settings section and get more details about the customization parameters.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "DevPrime_App": {},
  "DevPrime_Web": {},
  "DevPrime_Stream": {},
  "DevPrime_Observability": {},
  "DevPrime_Security": {},
  "DevPrime_Services": {},
  "DevPrime_State": {},
  "DevPrime_Custom": {}
}
Settings Details
APP Main Application Parameters
Web Adapter Web Parameters
Stream Adapter Stream Parameters
Observability Adapter Observability Parameters
Security Adapter Security Parameters
State Adapter State Parameters
Services Adapter Services Parameters
Custom Customized parameters for the application

Explore other related technologies

Last modified November 20, 2024 (61099f59)