Enforce Consistency through Application Infrastructure - Florin Coros

@ITCAMPRO #ITCAMP16Community Conference for IT Professionals

Enforce Consistency through

Application Infrastructure

Florin Coros

www.rabs.ro | www.iquarc.com | onCodeDesign.com

florin.coros@rabs.ro

@florincoros

Many thanks to our sponsors & partners!

SILVER

PARTNERS

PLATINUM

POWERED BY

About me

@florincoros

Founder & Partner

Partner

Many thanks to our sponsors & partners!

SILVER

PARTNERS

PLATINUM

POWERED BY

@ITCAMPRO #ITCAMP16Community Conference for IT Professionals 5

Why Consistency is Key?

Impeded by Others Code?

Different Solutions to the Same Problem

Which one is the ONE?

Cost of Change

Wrong approach consistently

repeated in all of the

application screens

Uniquely new approach in all

of the application screens

Managing Complexity

when projects do fail for reasons that are primarily

technical, the reason is often

uncontrolled complexity

Controlling the Complexity

uniqueness consistency

Rules Are Easy to Ignore

Quick and Dirty

The only way to go fast, is to go well!

Quality through Discipline

Seniors May Be Overwhelmed with Review

Quality through Structure

• You enforce consistency with structure

• Create a structure that makes difficult to write

bad code rather then code that follows the

design

• You use assemblies and references among

them to enforce rules

• Hide external frameworks to enforce the way

they are used

• Enforce Constructor Dependency Injection and

encourage Programming Against Interfaces

Assure Consistency in Using External Library by Hiding It

<<static class>>

+LogError()+LogWarining()

Exception Wrappers Decorators

<<Interface>>

API Interfaces

public interface ILog

void Info(string message, params object[] args);

void Warn(string message, params object[] args);

void Error(string message, Exception ex);

Enforces Separation of Concerns

• The application code only knows about ILog

• Once I is defined we can develop screens and call this interface to log traces or errors– The real implementation can be done later

• If logging needs changes, we can modify the interfaces at once in all places it is used– The implementation is in only one place, so one place to

change only

Encapsulate Data Access Concerns

<<Interface>>

TDataModel

IRepository

+GetEntities<TDataModel>()

<<Interface>>

TDataModel

IUnitOfWork

+GetEntities<TDataModel>()+SaveChanges()

Database

Repository UnitOfWork

<<Stereotype>><<DTO>>

Order<<DTO>>

Person

[Service(typeof (IRepository))]

internal class EfRepository : IRepository, IDisposable

private readonly IDbContextFactory contextFactory;

private readonly IInterceptorsResolver interceptorsResolver;

private DbContext context;

private readonly IEnumerable<IEntityInterceptor> interceptors;

public EfRepository(IDbContextFactory contextFactory, IInterceptorsResolver resolver)

this.contextFactory = contextFactory;

this.interceptorsResolver = interceptorsResolver;

this.interceptors = resolver.GetGlobalInterceptors();

} \iQuarc\DataAccess

public interface IRepository

IQueryable<TDbEntity> GetEntities<TDbEntity>() where TDbEntity : class;

IUnitOfWork CreateUnitOfWork();

public interface IUnitOfWork : IRepository, IDisposable

void SaveChanges();

void Add<T>(T entity) where T : class;

void Delete<T>(T entity) where T : class;

void BeginTransactionScope(SimplifiedIsolationLevel isolation);

Create Separated Patterns for Read-Only and Read-Write

Patterns for Read-Only datapublic class OrdersController : Controller{private readonly IRepository repository;public OrdersController(IRepository repository){

this.repository = repository;}

public IActionResult Index(string customer){

var orders = repository.GetEntities<SalesOrderHeader>().Where(soh => soh.Customer.Person.LastName == customer).Select(soh => new OrdersListViewModel{

CustomerName = customer,Number = soh.SalesOrderNumber,SalesPersonName = soh.SalesPerson,DueDate = soh.DueDate,

return View(orders);}

Enforce Construction of Unit of Workinternal class EfRepository : IRepository, IDisposable

public IQueryable<T> GetEntities<T>() where T : class{

return Context.Set<T>().AsNoTracking();}

public IUnitOfWork CreateUnitOfWork(){

return new EfUnitOfWork(contextFactory, interceptorsResolver);}

private sealed class EfUnitOfWork : IUnitOfWork{

private DbContext context;private TransactionScope transactionScope;

private readonly IDbContextFactory contextFactory;

public EfUnitOfWork(IDbContextFactory contextFactory, IInterceptorsResolver resolver){

this.contextFactory = contextFactory;this.interceptorsResolver = interceptorsResolver;

Patterns for Read-Write datapublic class OrdersController : Controller{...

[HttpPost][ValidateAntiForgeryToken]

public IActionResult PlaceOrder(OrderRequestViewModel model){

using (IUnitOfWork uof = repository.CreateUnitOfWork()){

SalesOrderHeader order = uof.GetEntities<SalesOrderHeader>().FirstOrDefault(o => o.CustomerID == c.ID && o.OrderDate.Month == DateTime.Now.Month);

if (order == null){

order = new SalesOrderHeader {Customer = c};uof.Add(order);

}AddRequestToOrder(model, order);

uof.SaveChanges();

Create Development Patters in how Data is Accessed

Enforce Separation of Data Access Concerns

<<Interface>>

TDataModel

IRepository

+GetEntities<TDataModel>()

<<Interface>>

TDataModel

IUnitOfWork

+GetEntities<TDataModel>()+SaveChanges()

Database

Repository UnitOfWork

<<Stereotype>><<DTO>>

Order<<DTO>>

Person

DIP to Enforce Separation of Data Access Concern

<<Interface>>

TDataModel

IEntityInterceptor

+OnLoad()+OnSaving()

<<Interface>>

TDataModel

IDbContextFactory

+CreateContext()

Database

<<DTO>>

Customer<<DTO>>

Order <<DTO>>

Person

DbContextFactoryUnitOfWorkRepository

DIP to Enforce OnSave/OnLoad Logic out of Data Access

<<Interface>>

TDataModel

IEntityInterceptor

<<Interface>>

TDataModel

IDbContextFactory

+CreateContext()

Database

<<DTO>>

Customer<<DTO>>

Order <<DTO>>

Person

AppBoot as Support

<<Attribute>>

ServiceAttribute

IModule

<<Interface>>

TDataModel

IEntityInterceptor

<<Interface>>

TDataModel

IRepository

Database

<<DTO>>

Customer<<DTO>>

Order<<DTO>>

Person

<<Interface>>

TDataModel

IUnitOfWork

AppBoot to Enforce Constructor Dependency Injection

<<Attribute>>

ServiceAttribute

+ ServiceAttribute()+ServiceAttribute(Type contract)+ ServiceAttribute(Type t, Lifetime lifetime)

Bootstrapper

+Bootstrapper(Assembly[] assemblies)+Run()

public interface IPriceCalculator

int CalculateTaxes(Order o, Customer c);

int CalculateDiscount(Order o, Customer c);

[Service(typeof(IPriceCalculator), Lifetime.Instance)]

interal class PriceCalculator : IPriceCalculator

public int CalculateTaxes(Order o, Customer c)

return 10; // do actual calculation

public int CalculateDiscount(Order o, Customer c)

return 20; // do actual calculation

\iQuarc\AppBoot

Software systems should separate the startup process, when the application objects are constructed and the

dependencies are “wired” together, from the runtime logic that takes over after startup

<<Interface>>

IModule

+ Initialize()

Application

+ Initialize()*

+ Modules[]

AppModule1

+ Initialize()

AppModule2

+ Initialize()

Enforce Separation of Construction from Use

public static void Main(string[] args){

var assemblies = GetApplicationAssemblies().ToArray();Bootstrapper bootstrapper = new Bootstrapper(assemblies);bootstrapper.ConfigureWithUnity();bootstrapper.AddRegistrationBehavior(new ServiceRegistrationBehavior());

bootstrapper.Run();}

Patters for Creating Services that Depend Only on Interfaces

[Service(typeof (IOrderingService))]public class OrderingService : IOrderingService{

private readonly IRepository repository;private readonly IPriceCalculator calculator;private readonly IApprovalService orderApproval;

public OrderingService(IRepository repository, IPriceCalculator calculator, IApprovalService orderApproval){

this.repository = repository;this.calculator = calculator;this.orderApproval = orderApproval;

public SalesOrderInfo[] GetOrdersInfo(string customerName){

var orders = repository.GetEntities<SalesOrderHeader>()...return orders.ToArray();

public SalesOrderResult PlaceOrder(string customerName, OrderRequest request){

Enforce Constructor DI to Prevent Circular Dependencies[Service(typeof(IApprovalService))]class ApprovalService : IApprovalService{private readonly IPriceCalculator priceCalculator;

public ApprovalService(IPriceCalculator priceCalculator){this.priceCalculator = priceCalculator;

[Service(typeof (IPriceCalculator), Lifetime.Instance)]public class PriceCalculator : IPriceCalculator{private readonly IApprovalService approvalService;

public PriceCalculator(IApprovalService approvalService){this.approvalService = approvalService;

Design Patterns like Composition or Chain of Responsibility

Development Patters in How Dependencies are Created

No References Between Modules -> Enforce Constraints

<<Attribute>>

ServiceAttribute

+ ServiceAttribute()+ServiceAttribute(Type contract)+ ServiceAttribute(Type t, Lifetime lifetime)

\iQuarc iQuarc

Dependencies Management

Design Patterns in Service Composition

Enforce Consistency through Structure

Enforce

Separation of Concerns

Patterns for

Queries & Commands

Interceptors for Queries & Commands

Enforce Consistency through Application Infrastructure

\iQuarc\Code-Design-Training

Florin CorosCo-founder & Partner, iQuarc www.iquarc.com

Partner, Infiniswiss www.infiniswiss.com

email: florin.coros@iquarc.com

blog: onCodeDesign.com

tweet: @florincoros

Enforce Consistency through Application Infrastructure - Florin Coros

Technology

Code Quality Through Application Software Infrastructure (Florin Coros)

FLORIN-VINEYARD GAP COMMUNITY PLAN PROJECT Agendas Minutes/Florin-Vineyar… · The County Planning representatives for the Florin-Vineyard Gap Community Plan Project are Tricia Stevens,

AVAILABLE FOR LEASE Florin Auto Center - 2680 Florin Road...Florin Auto Center - 2680 Florin Road ±5,000 SF END-CAP VEHICLE REPAIR SHOP AVAILABLE CONTACT US CBRE, Inc. 500 Capitol

Brand Building Innovation FLorin

Manual Autor Florin Tudose_Scala SANSS

148355680 Seminario Teologico Presbiteriano de Mexico Partituras Coros Inmortales PDF

Florin J.A.C.L. Newsletter · Fall 2015 Newsletter Florin J.A.C.L. Newsletter Florin Japanese American Citizens League Marielle Tsukamoto and Andy Noguchi, Co-Presidents P.O. Box

CV Florin Caus Engleza

Criste Florin

Turcaş Florin Marius, PhD candidate

5 COROS SACROS pag.0...Title 5 COROS SACROS pag.0.pdf Created Date 3/8/2011 8:46:23 PM

ITCamp 2017 - Florin Coros - Decide between In-Process or Inter-Processes Communication at Deploy Time

AVAILABLE FOR LEASE Florin Auto Center - 2680 Florin Roadimages2.loopnet.com/d2/w8bAy5Rx6chkwuYF589BXPXxHl...SARAENTO, A 9523 AVALALE O LEASE Florin Auto Center - 2680 Florin Road

coros infantiles.pdf

138920323 Marcha Triunfal de Aida Coros

Mingireanu Florin

Vineyard Gap/FVGCP-PDS-Charac.pdfcrosses Florin-Perkins Road, and continuing west. A south tributary to Florin Creek identified as "Florin Creek — South" serves the area immediately

Programación General XX Festival de Coros Coro INTEGRACION 2011

Nitish Kumar , Stelian Coros · Nitish Kumar , Stelian Coros Abstract—We present a concept of constrained collaborative mobile agents (CCMA) system, which consists of multiple wheeled

Adam Florin Presentation Compressed