• Documentation PT-BR
• NuGet

This package was designed based on three fundamental pillars for the application: Controller, Response, Error, and Result between layers.

The main goal in developing the BaseController is to provide a solid and reusable structure for controllers within the application. This component serves as a fundamental foundation for other controllers, offering essential and standardized functionalities that facilitate code development and maintenance.

• Components:
  • BaseResponse
  • BaseController

• This is the standard format for API responses, which includes two main properties:
  • TResponse: Represents the content of the response, which may vary depending on the context of the request.
  • Error: Error displayed on the screen for the user.

The BaseController is an abstract class that serves as a fundamental structure for controllers in the application. It provides standard methods for response return, promoting consistency and code reuse throughout the system.

• Response: This standard method is used to return a generic response from the controller. It is useful when there is no need to specify the type of response.

• Response: This overloaded method is used when it's necessary to return a response with a specific type, identified by the parameter T. This provides flexibility to handle different types of responses in a generic manner.

These methods allow controllers to effectively communicate with the requests received by the API, providing consistent responses tailored to the specific needs of each context.

• Default Application Error: This is an error model that can be used throughout the application to establish a consistent error handling pattern. It includes the following properties:
  • Status Code: The HTTP status code indicating the type of error that occurred.
  • Type: The error type, which can be used to categorize the issue.
  • Message: A descriptive message providing details about the error that occurred.

Communication between different layers of an application is crucial for its efficient operation. The Result between layers component aims to facilitate this communication by providing a cohesive and effective structure for sharing results among various parts of the application. With a solid implementation of the Result between layers, it is possible to ensure efficient and reliable data exchange between different modules and components of the application.

[Route("[controller]")]
public class HomeController : BaseController
{
    private readonly ProductServices _productServices = new ProductServices();

    [HttpGet]
    public ActionResult Get()
    {
        var result = _productServices.GetProduct(Guid.NewGuid());
        return Response(result);
    }
}

public class ProductServices()
{
    public BaseResult<ProductDto> GetProduct(Guid id)
    {
        var validate = Validate(id);
        if (validate.IsFailure)
        {
            return BaseResult.Failure<ProductDto>(validate.Error);
        }

        return BaseResult.Sucess(new ProductDto(id, "Test"));
    }

    private BaseResult Validate(Guid? id)
    {
        if (id is null)
        {
            return BaseResult.Failure("Not Found");
        }

        return BaseResult.Sucess();
    }
}

public record ProductDto(
    Guid Id,
    string Name);