URF.Core

URF.Core

^{Unit-of-Work- und Repository-Framework | Offizielles Team von URF, Trackable Entities und Design Factory}

Dokumente: URF.Core.Sample | URF-Updates abonnieren: @lelong37 | NuGet: goo.gl/WEn7Jm

Beispiel und Live-Demo mit Quellcode: URF.Core.Sample (Demo-Site ist aufgrund von starkem Datenverkehr und Azure-Kosten nicht verfügbar.)

URF.Core RTM ist fertig!

URF.Core ist funktionsvollständig und verfügt nun über volle Parität mit URF.NET (altes .NET). URF.Core wurde komplett neu geschrieben, mit besonderem Fokus auf Architektur, Design und Implementierung sowie der Implementierung der Top-Anfrage für vNext. Schauen Sie sich unser URF.Core.Sample mit ASP.NET Core-Web-API, OData, an. mit vollständigen CRUD-Beispielen mit Angular und Kendo UI.

Unterstützt Für MongoDb hinzugefügt

Ab Version 3.1.1 wurde Unterstützung für NoSQL-Dokumentdatenbanken mit einer Implementierung für MongoDb hinzugefügt.

Beispiele für EF Core 3.x und MongoDb

Für EF Core 3.x und MongoDb wurden Beispiele bereitgestellt.

Leicht, Nano-Footprint

Wir bleiben dem (alten) URF.NET treu und haben einen geringen Platzbedarf. URF.Core URF.Core ( insgesamt 7 Klassen ) vs. URF.NET ( insgesamt 12 Klassen ).

100 % erweiterbar

Wir haben jede Implementierung virtuell gemacht und sind daher für alle Teams/Projekte/Entwickler-Anwendungsfälle und Edge-Cases überschreibbar.

IQuerable vs. IEnumerable

Wie immer ist dies eine religiöse Debatte zwischen Teams und innerhalb der Gemeinschaft. Wie bei (altem) URF.NET haben wir den Teams die Möglichkeit gegeben, sich für IQueryable oder IEnumerable zu entscheiden, und sogar für beide, abhängig von der Architektur, dem Design und der Implementierung sowie dem Stil Ihres Teams. Als URF.NET und für Teams, die der Meinung sind, dass Repository-Muster IQueryable als undichte Abstraktion offenlegen, verwenden Sie einfach die IQuery API von URF, die Ihnen alle Fluent-Funktionen von IQueryable bietet, jedoch reine Entity oder IEnumerable zurückgibt, anstatt IQueryable, wiederum URF, zu verwenden .Core und URF.NET unterstützen beide, sodass Teams völlig frei wählen können, welcher der drei Pfade/Optionen für ihr Team/Projekt am sinnvollsten ist.

URF.Core-Beispiel und Verwendung in der ASP.NET Core-Web-API und 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 ) ;
    }
} 

Leistung

URF.Core wurde komplett neu geschrieben und alles ist jetzt sofort nach dem Auspacken komplett task , async und await . Auf diese Weise erhalten Teams automatisch das beste Thread-Management für asynchrone Leistungsverbesserungen.

URF Unterstützt und gesponsert von:

© 2017 URF.NET Alle Rechte vorbehalten.