Unit of Work Sample Implementation for ADO.NET

What does IUnitOfWork contain actually? Could you please include code for that also?

Public Interface IUnitOfWork
    Sub Dispose()
    Sub SaveChanges()
End Interface

you have not shown how to use UserRepository........will add some code.

tbhattacharjee

This seems to just be a wrapper for creating transactions. It isn't managing object state so it's not even a basic example of the pattern

When using the UoW pattern for a database you typically use it in conjunction with the Repository pattern. The purpose is to create an abstraction which wraps all persistence specific information. The goal is that you can use the objects as if they are any other .NET object.

You typically isn't, so you could say that the repository pattern is just a wrapper around the ADO.NET commands, right?

The thing is that it's just an implementation detail. When you call the repository.GetYourThing(id); you don't really care what's done underneath, you only care that you get your thing.

It's the same thing with the unit of work. You don't really care what's done when you call SaveChanges(), you just want to get the information persisted into the data storage. And by wrapping the transaction you achieve just that.

You're correct when you say that you should care about the implementation when you call SaveChanges(), but you're just describing encapsulation and/or abstraction but no a Unit of Work. There's no "unit" here to speak of.

When you're working with the collection in a unit of work, all actions against the collection or items in the collection need to be tracked so that they can be executed against the store when you call SaveChanges(). Those are the "units" of work.

So for example, if you add an item to the collection, then the command for the database to do so should be added to an internal list of commands. Then you delete two other items from the collection; 2 delete commands are added to the internal list. Then you change a property on one of the items, and update command should be add to the internal list. When you call SaveChanges(), every command (i.e. every unit of work) that has been collected in the internal list should be executed against the database and committed.

It is a complicated pattern to implement with ADO, so there is no basic example imo. But my point is that this example doesn't even contain a unit let alone implement the pattern.

In addition to that, this example implies than an open connection has been established already and a transaction is started just by instantiating the class. This requires the developer to a) know that and b) remember to dispose the object. This seems ok at first because it's forcing you to keep the operations atomic, but this is a leaky abstraction on top of not being a unit of work.

very basaic

did you want a complex Unit Of Work implementation? Or what where you looking for?

Hi
Not to be nit picky, you do have a good start, however for a 5, I would like to see possible variations, and extendability around the UOW you created, that is possible specifically with ADO.NET. Whats the diff UOW out there, what are the pros and cons.

Below is an example of a UOW I did for EF, for you to look at

XML

namespace Rms.Data
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    public abstract class GenericUnitOfWork<T> : IUnitOfWork<T>
         where T : BaseContext<T>
    {
        private T context;

        /// <summary>
        /// Initializes a new instance of the <see cref="GenericUnitOfWork{T}"/> class.
        /// </summary>
        public GenericUnitOfWork()
        {
            context = Activator.CreateInstance<T>();
            ConfigDefaultBehaviour();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="GenericUnitOfWork{T}"/> class.
        /// </summary>
        /// <param name="context">The context.</param>
        public GenericUnitOfWork(T context)
        {
            this.context = context;
            ConfigDefaultBehaviour();
        }

        private void ConfigDefaultBehaviour()
        {
            context.Configuration.LazyLoadingEnabled = true;
        }

        /// <summary>
        /// Gets the context.
        /// </summary>
        /// <value>
        /// The context.
        /// </value>
        public T Context
        {
            get
            {
                return context;
            }
        }

        /// <summary>
        /// Commits this instance.
        /// </summary>
        public int Commit(string userId = "", int companyId = 0)
        {
            int recordsAffected = 0;

            // The function was successful, so we can save all
            // changes and complete the transaction.
            context.LoggedOnUserId = userId;
            context.CompanyId = companyId;
            recordsAffected = context.SaveChanges();

            return recordsAffected;
        }

        /// <summary>
        /// Gets or sets a value indicating whether lazy loading is enabled.
        /// </summary>
        /// <value>
        /// <c>true</c> if lazy loading is enabled; otherwise, <c>false</c>.
        /// </value>
        public bool LazyLoadingEnabled
        {
            get
            {
                return context.Configuration.LazyLoadingEnabled;
            }
            set
            {
                context.Configuration.LazyLoadingEnabled = value;
            }
        }

        private bool disposed;

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources.
        /// </summary>
        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing && context != null)
                {
                    context.Dispose();
                    context = null;
                }
                disposed = true;
            }
        }

        /// <summary>
        /// Finalizes an instance of the <see cref="GenericUnitOfWork{T}"/> class.
        /// </summary>
        ~GenericUnitOfWork()
        {
            Dispose(false);
        }

    }
}

XML

sing Rms.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Rms.Data.AdminContext
{
    ///// <summary>
    ///// Summary Of Work for Administration Application Function
    ///// </summary>
    public class UnitOfWorkAdmin : GenericUnitOfWork<AdminContext>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="UnitOfWorkAdmin"/> class.
        /// </summary>
        public UnitOfWorkAdmin()
            : base()
        {

        }

        /// <summary>
        /// Initializes a new instance of the <see cref="UnitOfWorkAdmin"/> class.
        /// </summary>
        /// <param name="context">The administration context.</param>
        public UnitOfWorkAdmin(AdminContext context)
            : base(context)
        {

        }

        // --------- Repositories ---------
        private IUserRepository user;

        /// <summary>
        /// Gets the user.
        /// </summary>
        /// <value>
        /// The user.
        /// </value>
        public IUserRepository User
        {
            get { return user ?? (user = new UserRepository(this.Context)); }
        }

        private IEmailRepository email;

        public IEmailRepository Email
        {
            get { return email ?? ( email = new EmailRepository( this.Context ) ); }
        }


        private ITaxClassRepository taxclass;

        public ITaxClassRepository TaxClass
        {
            get { return taxclass ?? ( taxclass = new TaxClassRepository( this.Context ) ); }
        }


    }

}

Sk8tZ

Nice one!

Unit of Work Sample Implementation for ADO.NET

License

Comments and Discussions