URF.Core

Núcleo URF

^{Marco de unidad de trabajo y repositorio | Equipo oficial de URF, entidades rastreables y fábrica de diseño}

Documentos: URF.Core.Sample | Suscríbete Actualizaciones de URF: @lelong37 | NuGet: goo.gl/WEn7Jm

Muestra y demostración en vivo con código fuente: URF.Core.Sample (el sitio de demostración no funciona debido al intenso tráfico y los costos de Azure).

¡URF.Core RTM está completo!

URF.Core tiene funciones completas y ahora tiene paridad total con URF.NET (.NET heredado). URF.Core ha pasado por una reescritura completa con un enfoque láser en la arquitectura, el diseño y la implementación, además de implementar la solicitud principal para vNext. Puede echar un vistazo a nuestro URF.Core.Sample con ASP.NET Core Web API, OData, con muestras CRUD completas con Angular y Kendo UI.

Compatible agregado para MongoDb

A partir de la versión 3.1.1 se agregó soporte para bases de datos de documentos NoSQL con implementación para MongoDb.

Ejemplos para EF Core 3.x y MongoDb

Se han proporcionado ejemplos para EF Core 3.x y MongoDb.

Ligero, nanohuella

Mantenerse fiel a URF.NET (heredado) de tener una huella pequeña. URF.Core URF.Core ( 7 clases en total ) frente a URF.NET ( 12 clases en total ).

100% Extensible

Hemos hecho que cada implementación sea virtual, por lo que se puede anular para cualquier caso de uso de equipo/proyecto/desarrollador, así como para casos extremos.

IQuerable frente a IEnumerable

Como siempre, este es un debate religioso entre equipos y dentro de la comunidad. Al igual que con URF.NET (heredado), les dimos a los equipos la opción de optar por IQueryable o IEnumerable, e incluso ambos dependiendo de la arquitectura, diseño e implementación y el estilo de su equipo. Como URF.NET y para equipos que sienten patrones de repositorio que exponen IQueryable como una abstracción con fugas, simplemente use la API IQuery de URF, que le brindará todas las características fluidas de IQueryable, sin embargo, devolverá Entidad pura o IEnumerable versus usar IQueryable, nuevamente URF. .Core y URF.NET son compatibles, por lo que los equipos tienen total libertad para elegir cuál de las 3 rutas/opciones tiene más sentido para su equipo/proyecto.

Muestra y uso de URF.Core en ASP.NET Core Web API y OData

 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 ) ;
    }
} 

Actuación

URF.Core se ha reescrito por completo y ahora todo es completamente task , async , await nada más sacarlo de la caja. De esta manera, los equipos obtendrán automáticamente la mejor gestión de subprocesos mediante mejoras de rendimiento asincrónicas.

URF Desarrollado y patrocinado por:

© 2017 URF.NET Todos los derechos reservados.