ORM SnapObjects

ORM pour .NET Simple, Puissant et Ultra-Rapide

Avec l'ORM SnapObjects le développement .NET devient un jeu d'enfant !  
Incroyablement simple, sans compromis sur les fonctionnalités, 
il offre un contrôle total
sur le SQL généré et fonctionne de façon similaire à ADO.NET.

Utiliser Gratuitement Commencez
SnapObjects ORM

Avantages

Simple, Minimal Coding

Code simple et minimaliste

Codez facilement des fonctionnalités avancées.
​​​​​​​L’accès aux données est géré par des modèles pour limiter les coûts de maintenance.

Type-Safe Queries

Requêtes Type-Safe

Les objets .NET sont utilisés comme critères pour contrôler les types de données (type-safe queries), et des API de test sont fournies pour vérifier le SQL. 

Flexible SQL Generation

Génération SQL flexible

La génération de SQL est contrôlée par un ensemble complet d'attributs de modèle. Vous pouvez également coder des requêtes SQL brut si vous préférez.

Loose Relationships

Relations Souples

Les relations sont définies pendant le développement (non prédéfinies) et ne persistent que pour une requête particulière.

Transaction-Oriented

Orienté transactions

Les requêtes, les mises à jour et les actions peuvent être tracées, avant d'appliquer automatiquement la gestion des transactions.

Ultra-Fast Performance

Performance Ultra-Rapide

Très peu de ressources sont consommées en plus d’ADO.NET, et les requêtes, mises à jour et actions sont exécutées par lots.

Extraits de code

Generating complex SQL queries is controlled by intuitive attributes applied to the model.

namespace Appeon.SqlModelMapperDemo.Models
{
//Generates the underlying SQL query according to the attributes
    [Top(1000)]
    [SqlParameter("custId", typeof(int))]
    [SqlParameter("stratOrderDate", typeof(DateTime))]
    [SqlParameter("endOrderDate", typeof(DateTime))]
    [Table("SalesOrderHeader",Schema = "Sales")]
    [SqlWhere("(CustomerId = :custId) and (Orderdate Between :stratOrderDate and :endOrderDate)")]
    public class SalesOrder
    {
        [Key]
        [Identity]
        public int SalesOrderID { get; set; }

        [Required]
        public DateTime? OrderDate { get; set; }

        [Required]
        public byte? Status { get; set; }

        [Required]
        public bool? OnlineOrderFlag { get; set; }

        [SqlCompute("(isnull(N'SO'+CONVERT([nvarchar](23),[SalesOrderID]),N'*** ERROR ***'))")]
        public string SalesOrderNumber { get; set; }

        [Required]
        public int? CustomerID { get; set; }

        [SqlCompute("(isnull(([SubTotal]+[TaxAmt])+[Freight],(0)))")]
        public decimal? TotalDue { get; set; }

        public DateTime? ModifiedDate { get; set; }

//Nests a model and applies various attributes
        [JsonIgnore]
        [SetValue("$SalesOrderID", "$SalesOrderID", SetValueStrategy.Always)]
        [ModelEmbedded(typeof(SalesOrderDetail), ParamValue = "$SalesOrderID",
            CascadeCreate =true, CascadeDelete = true)]
        public IList< salesorderdetail> OrderDetails { get; set; }
    }
}

Retrieving data and loading it into the model only requires parameters – no unproductive query language is necessary.

//Retrieves multiple rows of data, loads it into the model, and then puts it into a list
_context.SqlModelMapper.Load< salesorderquery>(startDate, endDate, customerId)
                       .ToList();


//Retrieves a single row of data and loads it into the model
_context.SqlModelMapper.LoadByKey< salesorder>(orderId)
                       .FirstOrDefault();

Deleting data (including data of a master-detail) only requires a key or the model.

//Deletes data corresponding with the specified key – either a single row of data or if a nested model then the cascaded data
_context.SqlModelMapper.TrackDeleteByKey< salesorder>(orderId)
                      .SaveChanges()

// Deletes data corresponding with the specified model – either a single row of data or if a nested model then the cascaded data
_context.SqlModelMapper.TrackDelete(salesOrder)
                      .SaveChanges()

Saving data is controlled by intuitive tracking functions, with granular control whether to save the entire master-detail relationship or portion thereof (by including/excluding the appropriate TrackDetails).

//Saves data with a master-detail-detail relationship
_context.SqlModelMapper.TrackMaster(header)
                       .TrackDetails(o => o.SalesReasons, reasons)
                       .TrackDetails(o => o.Details, details);

_context.SqlModelMapper.SaveChanges();

Managing transactions is made effortless by powerful implicit capability – comprehensive tracking functions (that go way beyond tracking just the model) determine what is included.

//Tracks various models, raw SQL, and actions
_context.SqlModelMapper.TrackCreate(salesOrder)
         .Track((saveContext) =>
{
  //C# code block
  ……
})  //The C# code block will be executed when SaveChanges is called
                       .TrackUpdate(salesPerson)
                       .TrackSqlCUD(rawSql)
                       .SaveChanges()   //Executes all tracked items in one transaction and automatically commits or rolls back
Télécharger l'exemple d'application

Fonctionnalités

Modèle


Le modèle fait correspondre des colonnes à des tables de la base de données et contient le SQL correspondant. Le SQL du modèle est généré en fonction de divers attributs, ce qui permet aux développeurs d'en avoir le contrôle complet.  Le modèle peut représenter des relations complexes, Maître-Détail par exemple - par imbrication de modèles (nesting).

Model

SQLModelMapper


Le SQLModelMapper est un composant de manipulation de données orienté transaction. Il fournit des objets et des méthodes pour simplifier vos opérations CRUD, et applique une gestion automatique des transactions aux éléments trackés. Ceux-ci peuvent être exécutés par lots pour améliorer les performances.

Requête

Exécute les requêtes et charge l'ensemble des résultats dans un objet temporaire pour un traitement ultérieur ou renvoie l'ensemble des résultats calculés.

 Chargement simple

Exécute les requêtes définies dans le modèle et charge l'ensemble des résultats dans un objet généré automatiquement.

 Chargement agrégé et scalaire

Exécute la requête définie dans le modèle et renvoie l'ensemble de résultats avec un calcul agrégé ou scalaire.

Tracking

Trace les changements de modèle, les SQL et les actions pour gérer les transactions.

 Tracking du Modèle

 Suit et met en cache les opérations Insert / Update / Delete de la base de données dans le(s) modèle(s).

 Tracking des SQL CUD

Trace les opérations Insert / Update / Delete des tables de la base de données.

  Tracking des Actions

Permet de tracer des situations plus complexes que de simples opérations CUD. Par exemple, vous pouvez suivre une valeur particulière extraite de la base de données, ou encore, savoir si l'opération "Save" a été annulée.

 Tracking de Master/Detail

Suit et met en cache l'état des données dans le(s) modèle(s) d'une relation Maître-Détail.

Exécuter

Soumettez toutes les opérations de base de données suivies dans les modèles, les SQL ou les actions liées à la base de données pour qu'elles soient exécutées en une fois et laissez ModelMapper gérer la transaction pour vous.

 SaveChanges

Enregistre toutes les modifications apportées à la base de données en exécutant les éléments suivis (modifications du modèle, SQL et actions). Les éléments suivis peuvent être exécutés par lots pour améliorer les performances.

 Validate

Valide toutes les données des modèles qui ont fait l'objet d'un suivi.

Async

Exécute les opérations CRUD de façon  asynchrone.

 Async Queries

Récupère les données de façon asynchrone et charge l'ensemble des résultats bruts ou processés.

 Async Execution

Sauvegarde de façon asynchrone toutes les modifications apportées à la base de données.

SQLExecutor


SQLExecutor est un jeu d'interfaces de manipulation de bases de données qui encapsulent les principaux composants ADO.NET.
Avec SQLExecutor, vous pouvez directement exécuter des instructions SQL dynamiques,  des fonctions d'objet SQLBuilder et des requêtes de modèle.

 Execute

Exécute une commande et renvoie le nombre de lignes affectées.

 Query

Exécute une requête et mappe le résultat.

SQLBuilder


Le SQLBuilder construit des instructions SQL de manière programmatique et indépendante de la base de données.  Plus précisément, il construit la structure syntaxique et travaille avec l'objet DataContext de SnapObjects pour générer des instructions SQL spécifiques à chaque bases de données.

 Build

Construit la structure syntaxique SQL.

 Validate

Valide la chaîne SQL brute générée pour la base de données spécifiée.