SHARE:

Micro ORMs, alternatives to Entity Framework ? Part 2

 

<< Previous article (Part 1)

Introduction of some Micro ORMs: Simple.Data

Scenario Used

In order to show reusable examples, I’m using AdventureWork Database (2014), you can download it here.

I will use the WorkOrder table and the Product table, I will use also a business project named Orders that is a projection on there two tables.

Some Micro ORMs are able to manage relationships between tables and populate objects linked by a navigation property, some not, so we will use the projection instead of entities introduced before.

Simple.Data

  • It’s syntax is fully dynamic syntax, consequence: no IntelliSense
  • Compatible with multiple databases: SQL Server, Oracle, Mysql, SqlLite, PostgreSql, SqlAnyWhere, Informix Microsoft Access
  • Uncomplicated syntax (LINQ-like)
  • Supports transactions
  • Mandatory to create an AdHoc query to populate an object (relationships are not supported)
  • Weird database connection management : « Simple.Data is quite aggressive in closing connections and holds no open connections to a data store by default, so you can keep the Database object returned from the Open*() methods hanging around without worrying.»
  • Not testable unitarily
  • Doesn’t provide Async queries
  • Not compatible with .NET Core
  • Was promising but unfortunately it is no longer updated since 2013

Code samples :

Required entities and business objects for our scenario :

public class Orders
    {
        public Orders() { }

        public int Id { get; set; }
        public string ProductName { get; set; }
        public int? Quantity { get; set; }
        public DateTime? Date { get; set; }
    }

    //Db entity
    public class WorkOrder
    {
        public WorkOrder() { }

        public int WorkOrderId { get; set; }
        public int ProductID { get; set; }
        public int? OrderQty { get; set; }
        public int? StockedQty { get; set; }
        public int? ScrappedQty { get; set; }
        public DateTime? StartDate { get; set; }
        public DateTime? EndDate { get; set; }
        public DateTime? DueDate { get; set; }
        public int? ScrapReasonID { get; set; }
        public DateTime? ModifiedDate { get; set; }
    }

Repository sample :

public class MassiveRepository
public class SimpleDataRepository
    {
        private dynamic _dbConnection;
        private dynamic _workerId;
        private dynamic _productName;
        private dynamic _orderQty;
        private dynamic _dueDate;

        public SimpleDataRepository()
        {
            _dbConnection = Database.OpenNamedConnection("AdventureWorks2014");
            _workerId = _dbConnection.WorkOrder.WorkOrderID;
            _productName = _dbConnection.WorkOrder.Product.Name;
            _orderQty = _dbConnection.WorkOrder.OrderQty;
            _dueDate = _dbConnection.WorkOrder.DueDate;
        }

        public List GetOrders()
        {
            List data = _dbConnection.WorkOrder.Select(_workerId, _productName, _orderQty, _dueDate).Skip(0).Take(500);

            return data.Select(x => new Orders
            {
                Id = x.WorkOrderID,
                ProductName = x.Name,
                Quantity = x.OrderQty,
                Date = x.DueDate
            }).ToList();
        }

        public Orders GetOrderById(int id)
        {
            dynamic data = _dbConnection.WorkOrder.Select(_workerId, _productName, _orderQty, _dueDate).Find(_workerId == id);

            return new Orders
            {
                Id = data.WorkOrderID,
                ProductName = data.Name,
                Quantity = data.OrderQty,
                Date = data.DueDate
            };
        }

        public void Add(WorkOrder workOrder)
        {
            _dbConnection.WorkOrder.Insert(workOrder);
            //dynamic data = _dbConnection.WorkOrder.Insert(ProductId : 1, OrderQty : 10, StockedQty : 50 .......);
        }

        public void Update(WorkOrder workOrder)
        {
            _dbConnection.WorkOrder.UpdateByWorkOrderId(workOrder);
            //_dbConnection.WorkOrder.Update(WorkOrderId: workOrder.WorkOrderId);
        }

        public void Delete(WorkOrder workOrder)
        {
            _dbConnection.WorkOrder.DeleteByWorkOrderId(workOrder.WorkOrderId);
            //_dbConnection.WorkOrder.Delete(WorkOrderId: workOrder.WorkOrderId);
        }
    }

Like it’s name Simple.Data is very simple !

 

Let’s go to see how Massive works

Written by

anthonygiretti

Anthony is a specialist in Web technologies (14 years of experience), in particular Microsoft .NET and learns the Cloud Azure platform. He has received twice the Microsoft MVP award and he is also certified Microsoft MCSD and Azure Fundamentals.
%d bloggers like this: