The document discusses various design patterns in software development, including SOLID principles, the Repository pattern, the Unit of Work pattern, and the Decorator pattern. It outlines definitions, principles, and examples of each pattern, detailing their implementations and potential issues. The document emphasizes best practices for managing data access and transaction handling within applications.

1. APPLIED PATTERNS
The current project implementation

2. TOPICS
 SOLID
 Repository pattern
 Unit of Work pattern
 Decorator pattern

3. SOLID
 Single Responsibility Principle
 “a class should have only a single responsibility”
 Open/closed Principle
 “software entities … should be open for extension, but closed
for modification.”
 Liskov substitution principle
 “objects in a program should be replaceable with instances of
their subtypes without altering the correctness of that
program.”
 Interface segregation principle
 ““many client-specific interfaces are better than one general-
purpose interface.”
 Dependency inversion principle
 one should “Depend upon Abstractions. Do not depend upon
concretions.”

4. REPOSITORY PATTERN
 Abstraction data access
 Database
 Services
 Files
 Etc.
 Hide implementation details

5. SEPERATION
 Repository.Database
 Database context
 Initializers
 Migrations
 Scripts
 Repository.Entities
 Entity objects (POCO)
 Repository.DataAccess
 Repository abstraction layer

6. REPOSITORY INTERFACE
public interface IRepository<TEntity>
where TEntity : class
{
IEnumerable<TEntity> Get(
Expression<Func<TEntity, bool>> filter = null,
Func<IQueryable<TEntity>,
IOrderedQueryable<TEntity>> orderBy = null,
string includeProperties = "");
TEntity GetById(object id);
TEntity Insert(TEntity entity);
TEntity Delete(object id);
TEntity Delete(TEntity entityToDelete);
void Update(TEntity entityToUpdate);
}

7. REPOSITORY IMPLEMENTATION
public Repository(DatabaseContext context)
{
this.context = context;
this.dbSet = context.Set<TEntity>();
}

8. DI REGISTRATION
builder.RegisterGeneric(typeof(Repository<>))
.As(typeof(IRepository<>));
builder.RegisterType<DatabaseContext>()
.AsSelf()
.InstancePerLifetimeScope();

9. USAGE
protected StoreNewQueueItem(
IRepository<ProcessQueue> processQueueRepository,
...)
{
this.processQueueRepository = processQueueRepository;
...
}
...
var insertedItem = processQueueRepository
.Insert(queueItem);
...

10. UNIT OF WORK PATTERN
 “A Unit of Work keeps track of everything you do
during a business transaction that can affect the
database. When you're done, it figures out
everything that needs to be done to alter the
database as a result of your work.”
SOURCE: http://www.martinfowler.com/eaaCatalog/unitOfWork.html
 Committing changes
 Handling of transaction

11. COMMON REPOSITORY USAGE
var insertedItem = processQueueRepository
.Insert(queueItem);
processQueueRepository.Save();
OR
public virtual TEntity Insert(
TEntity entity)
{
var insertedItem = dbSet.Add(entity);
context.SaveChanges();
return insertedItem;
}

12. UNIT OF WORK + REPOSITORY
public class MyCommand
{
private readonly IUnitOfWorkFactory factory;
public MyCommand(IUnitOfWorkFactory factory)
{
this.factory = factory;
}
public void Execute()
{
using (var context = this.factory.CreateNew())
{
this.DoSomeNiceThings(context);
context.Commit();
}
}
}
SOURCE: http://stackoverflow.com/a/4944201/352640

13. NOT A GOOD IMPLEMENTATION
 UoW + Repository, great idea
 Some of the greater developer minds are
opponents
 Violates some principles
 Opaque dependencies
 Open/closed principle
 Single Responsibility Principle
 Nominal abstraction

14. BETTER IMPLEMENTATION?
 List of example implementations:
SOURCE: https://lostechies.com/derekgreer/2015/11/01/survey-of-entity-framework-unit-of-work-
patterns/
 Unit of Work Decorator
 Works everywhere
 Close to point of need
 More control
 Setup is hard!

15. DECORATOR PATTERN
 “…the decorator pattern … allows behavior to be
added to an individual object … without
affecting the behavior of other objects from the
same class.
The decorator pattern is often useful for adhering to
the Single Responsibility Principle, as it allows
functionality to be divided between classes with
unique areas of concern.”
SOURCE: https://en.wikipedia.org/wiki/Decorator_pattern
 Extending functionality
 Adhering SRP

16. DECORATOR PATTERN CLASS DIAGRAM
 Decorator implements same interface

17. DECORATOR PATTERN EXAMPLE
/// <summary>
/// The 'Component' abstract class
/// </summary>
abstract class Component
{
public abstract void Operation();
}
/// <summary>
/// The 'Decorator' abstract class
/// </summary>
abstract class Decorator : Component
{
protected Component component;
public void SetComponent(Component component)
{
this.component = component;
}
public override void Operation()
{
if (component != null)
{
component.Operation();
}
}
}
static void Main()
{
// Create ConcreteComponent and two Decorators
ConcreteComponent c = new ConcreteComponent();
ConcreteDecoratorA d1 = new ConcreteDecoratorA();
ConcreteDecoratorB d2 = new ConcreteDecoratorB();
// Link decorators
d1.SetComponent(c);
d2.SetComponent(d1);
d2.Operation();
}
/// <summary>
/// The 'ConcreteComponent' class
/// </summary>
class ConcreteComponent : Component
{
public override void Operation()
{
Console.WriteLine("ConcreteComponent.Operation()");
}
}
/// <summary>
/// The 'ConcreteDecoratorA' class
/// </summary>
class ConcreteDecoratorA : Decorator
{
public override void Operation()
{
base.Operation();
Console.WriteLine("ConcreteDecoratorA.Operation()");
}
}
/// <summary>
/// The 'ConcreteDecoratorB' class
/// </summary>
class ConcreteDecoratorB : Decorator
{
public override void Operation()
{
base.Operation();
AddedBehavior();
Console.WriteLine("ConcreteDecoratorB.Operation()");
}
void AddedBehavior()
{
}
}

18. PUTTING IT ALL TOGETHER
 Create handler
 Query
 Command
 Repository
 Repository actions
 Create decorator
 Committing changes

19. USAGE THE TRANSACTION DECORATOR
public class TransactionRequestHandlerDecorator<...> :
IConvertorCommandHandler<...>
{
private readonly IConvertorCommandHandler<...> decorated;
private readonly MyDatabaseContext context;
public TransactionRequestHandlerDecorator(
IConvertorCommandHandler<...> decorated,
MyDatabaseContext context)
{
this.decorated = decorated;
this.context = context;
}
public void Handle(TCommand command)
{
Log.Debug("Starting new transaction.");
using (var transaction = context.Database.BeginTransaction())
{
try
{
decorated.Handle(command);
context.SaveChanges();
Log.Debug("Saving changes.");
transaction.Commit();
Log.Debug("Comitting the transaction.");
}
...

20. DECORATOR REGISTRATION
foreach (var commandHandler in commandHandlers)
{
builder.RegisterGeneric(commandHandler)
.Named("commandHandler",
typeof(IConvertorCommandHandler<,,>));
}
builder.RegisterGenericDecorator(
typeof(TransactionRequestHandlerDecorator<,,>),
typeof(IConvertorCommandHandler<,,>),
fromKey: "commandHandler")
.Named("decorated",
typeof(IConvertorCommandHandler<,,>));

21. QUESTIONS?