URF.Core

URF.Core

^{Unité de travail et cadre de référentiel | Équipe officielle URF, entités traçables et Design Factory}

Documents : URF.Core.Sample | Abonnez-vous aux mises à jour URF : @lelong37 | NuGet : goo.gl/WEn7Jm

Exemple et démo en direct avec code source : URF.Core.Sample (le site de démonstration est en panne en raison du trafic important et des coûts Azure.)

URF.Core RTM est terminé !

URF.Core est doté de fonctionnalités complètes et a désormais une parité totale avec URF.NET (ancien .NET). URF.Core a subi une réécriture complète avec un accent laser sur l'architecture, la conception et la mise en œuvre ainsi que la mise en œuvre de la principale demande pour vNext, vous pouvez jeter un œil à notre URF.Core.Sample avec l'API Web ASP.NET Core, OData, avec des échantillons CRUD complets avec Angular et Kendo UI.

Pris en charge ajouté pour MongoDb

Depuis la version 3.1.1, la prise en charge a été ajoutée pour les bases de données NoSQL Document avec une implémentation pour MongoDb.

Exemples pour EF Core 3.x et MongoDb

Des exemples ont été fournis pour EF Core 3.x et MongoDb.

Léger, empreinte nanométrique

Rester fidèle à (l'ancien) URF.NET d'avoir une petite empreinte. URF.Core URF.Core ( 7 classes au total ) contre URF.NET ( 12 classes au total ).

100% extensible

Nous avons rendu chaque implémentation virtuelle, donc remplaçable pour tous les cas d'utilisation des équipes/projets/développeurs ainsi que pour les cas extrêmes.

IQuerable vs IEnumerable

Comme toujours, il s'agit d'un débat religieux entre les équipes et au sein de la communauté. Comme avec (ancien) URF.NET, nous avons donné aux équipes la possibilité d'opter pour IQueryable ou IEnumerable, et même les deux en fonction de l'architecture, de la conception, de la mise en œuvre et du style de vos équipes. En tant qu'URF.NET et pour les équipes qui estiment que les modèles de référentiel exposent IQueryable comme une abstraction qui fuit, utilisez simplement l'API IQuery d'URF, qui vous donnera toutes les fonctionnalités Fluent d'IQueryable, mais renverra cependant une entité pure ou IEnumerable plutôt que d'utiliser IQueryable, encore une fois URF. .Core et URF.NET sont tous deux pris en charge, les équipes ont donc la liberté totale de choisir laquelle des 3 voies/options est la plus logique pour leur équipe/projet.

Exemple d'URF.Core et utilisation dans l'API Web et OData 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 ) ;
    }
} 

Performance

URF.Core a été complètement réécrit, et tout est désormais entièrement task , async , await dès la sortie de la boîte. De cette façon, les équipes bénéficieront automatiquement de la meilleure gestion des threads sur les améliorations de performances asynchrones.

URF propulsé et sponsorisé par :

© 2017 URF.NET Tous droits réservés.