URF.Core

URF.Core

^{Estrutura de unidade de trabalho e repositório | URF oficial , entidades rastreáveis ​​e equipe de fábrica de design}

Documentos: URF.Core.Sample | Assine as atualizações do URF: @lelong37 | NuGet: goo.gl/WEn7Jm

Amostra e demonstração ao vivo com código-fonte: URF.Core.Sample (o site de demonstração está fora do ar devido ao tráfego intenso e aos custos do Azure.)

URF.Core RTM está completo!

URF.Core está completo com recursos e agora tem paridade total com URF.NET (.NET legado). URF.Core passou por uma reescrita completa com foco em arquitetura, design e implementação, bem como implementando a solicitação principal para vNext, você pode dar uma olhada em nosso URF.Core.Sample com API Web ASP.NET Core, OData, com amostras CRUD completas com Angular e Kendo UI.

Adicionado suporte para MongoDb

A partir da versão 3.1.1, foi adicionado suporte para bancos de dados NoSQL Document com implementação para MongoDb.

Amostras para EF Core 3.x e MongoDb

Foram fornecidas amostras para EF Core 3.x e MongoDb.

Leve, Nano-Pegada

Permanecer fiel ao (legado) URF.NET de ter uma pegada pequena. URF.Core URF.Core ( 7 classes no total ) vs. URF.NET ( 12 classes no total ).

100% extensível

Tornamos cada implementação virtual, portanto, substituível para quaisquer equipes/projetos/casos de uso de desenvolvedor, bem como casos extremos.

IQuerable vs. IEnumerable

Como sempre, este é um debate religioso entre as equipes e a comunidade. Assim como acontece com o URF.NET (legado), demos às equipes a opção de optar por IQueryable ou IEnumerable, e até mesmo ambos, dependendo da arquitetura, design, implementação e estilo de sua equipe. Como URF.NET e para equipes que sentem Repository Patterns que expõem IQueryable como uma abstração com vazamento, basta usar a API IQuery do URF, que fornecerá todos os recursos Fluent de IQueryable, porém retornará Entidade pura ou IEnumerable em vez de usar IQueryable, novamente URF .Core e URF.NET suportam, então as equipes têm total liberdade para escolher qual dos 3 caminhos/opções faz mais sentido para sua equipe/projeto.

Amostra e uso de URF.Core na API Web e OData do ASP.NET Core

 public class ProductsController : ODataController
{
    private readonly IProductService _productService ;
    private readonly IUnitOfWork _unitOfWork ;

    public ProductsController (
        IProductService productService ,
        IUnitOfWork unitOfWork )
    {
        _productService = productService ;
        _unitOfWork = unitOfWork ;
    }

    // e.g. GET odata/Products?$skip=2&$top=10
    [ EnableQuery ]
    public IQueryable < Products > Get ( ) => _productService . Queryable ( ) ;

    // e.g.  GET odata/Products(37)
    public async Task < IActionResult > Get ( [ FromODataUri ] int key )
    {
        if ( ! ModelState . IsValid )
            return BadRequest ( ModelState ) ;

        var product = await _productService . FindAsync ( key ) ;

        if ( product == null )
            return NotFound ( ) ;

        return Ok ( product ) ;
    }

    // e.g. PUT odata/Products(37)
    public async Task < IActionResult > Put ( [ FromODataUri ] int key , [ FromBody ] Products products )
    {
        if ( ! ModelState . IsValid )
            return BadRequest ( ModelState ) ;

        if ( key != products . ProductId )
            return BadRequest ( ) ;

        _productService . Update ( products ) ;

        try
        {
            await _unitOfWork . SaveChangesAsync ( ) ;
        }
        catch ( DbUpdateConcurrencyException )
        {
            if ( ! await _productService . ExistsAsync ( key ) )
                return NotFound ( ) ;
            throw ;
        }

        return NoContent ( ) ;
    }

    // e.g. PUT odata/Products
    public async Task < IActionResult > Post ( [ FromBody ] Products products )
    {
        if ( ! ModelState . IsValid )
            return BadRequest ( ModelState ) ;

        _productService . Insert ( products ) ;
        await _unitOfWork . SaveChangesAsync ( ) ;

        return Created ( products ) ;
    }

    // e.g. PATCH, MERGE odata/Products(37)
    [ AcceptVerbs ( " PATCH " , " MERGE " ) ]
    public async Task < IActionResult > Patch ( [ FromODataUri ] int key , [ FromBody ] Delta < Products > product )
    {
        if ( ! ModelState . IsValid )
            return BadRequest ( ModelState ) ;

        var entity = await _productService . FindAsync ( key ) ;
        if ( entity == null )
            return NotFound ( ) ;

        product . Patch ( entity ) ;
        _productService . Update ( entity ) ;

        try
        {
            await _unitOfWork . SaveChangesAsync ( ) ;
        }
        catch ( DbUpdateConcurrencyException )
        {
            if ( ! await _productService . ExistsAsync ( key ) )
                return NotFound ( ) ;
            throw ;
        }
        return Updated ( entity ) ;
    }

    // e.g. DELETE odata/Products(37)
    public async Task < IActionResult > Delete ( [ FromODataUri ] int key )
    {
        if ( ! ModelState . IsValid )
            return BadRequest ( ModelState ) ;

        var result = await _productService . DeleteAsync ( key ) ;

        if ( ! result )
            return NotFound ( ) ;

        await _unitOfWork . SaveChangesAsync ( ) ;

        return StatusCode ( ( int ) HttpStatusCode . NoContent ) ;
    }
} 

Desempenho

URF.Core foi completamente reescrito e agora tudo é completamente task , async , await pronto para uso. Dessa forma, as equipes obterão automaticamente o melhor gerenciamento de threads em melhorias de desempenho assíncronas.

URF desenvolvido e patrocinado por:

© 2017 URF.NET Todos os direitos reservados.