S.O.L.I.D

1. S.O.L.I.D Principles of object oriented Design

2. S.O.L.I.D Principles • What is SOLID? • Acrostic of 5 Principles: • The Single Responsibility Principle • The Open Closed Principle • The Liskov Substitution Principle • The Interface Segregation Principle • The Dependency Inversion Principle

3. S.O.L.I.D Principles • The Open Closed Principle • The Liskov Substitution Principle • The Single Responsibility Principle • The Dependency Inversion Principle • The Interface Segregation Principle • Bringing it all together

4. S.O.L.I.D Principles • How can SOLID help? • Drives good design • Maintenance • Refactorability • Clarity • Coupling and Cohesion • We want LOW coupling • And HIGH cohesion

5. S.O.L.I.D Principles The Open/Closed Principle and The Liskov Substitution Principle

6. OCP and LSP • OCP • “Classes should be open for extension but closed for modification” • Polymorphism / abstraction • LSP • “Derived classes must be substitutable for their base class” • Basic polymorphism/inheritance • Has implications with covariance/contravariance

7. S.O.L.I.D Principles The Single Responsibility Principle

8. The Single Responsibility Principle • “Every object should have a single responsibility, and that all its services should be narrowly aligned with that responsibility” • Achieved with • Dependency Inversion • Interface Segregation

9. The Single Responsibility Principle     public class User       {           public int Id { get; set; }           public string FirstName { get; set; }           public string LastName { get; set; }           public string GenerateUpdate()           {               return String.Format(                   "UPDATE Users SET FirstName='{0}', LastName='{1}' WHERE Id={2}",   FirstName, LastName, Id);           }           public string GenerateDelete()           {               return String.Format(                   "DELETE FROM Users WHERE Id={0}", Id);           }           public string GenrateInsert()           {               if (Id != 0)                   throw new InvalidOperationException(   String.Format(                           "This user already exists with an ID of {0}",                           Id));               return String.Format(                   "INSERT INTO Users VALUES ({0},{1})",   FirstName, LastName);           }           public boolIsValid()           {               return !String.IsNullOrEmpty(FirstName) &&                      !String.IsNullOrEmpty(LastName);           }       }  

10. S.O.L.I.D Principles The Dependency Inversion Principle

11. The Dependency Inversion Principle “Depend on abstractions and not concretions” “High level modules should not depend upon low level modules. Both should depend upon abstractions. Abstractions should not depend upon details. Details should depend upon abstractions.”

12. The Dependency Inversion Principle • Heavily uses • Interface based programming • Achieved with • Dependency Injection

13. The Dependency Inversion Principle • Interface based programming • public string Concatenate(List<string> parts, string delimeter) • { • string result = ""; • foreach (var part in parts) • result += part + delimeter; • return result; • }

14. The Dependency Inversion Principle • Interface based programming • public string Concatenate(List<string> parts, string delimeter) • { • string result = ""; • foreach (var part in parts) • result += part + delimeter; • return result; • } • public string Concatenate(string[] parts, string delimeter) • { • string result = ""; • foreach (var part in parts) • result += part + delimeter; • return result; • }

15. The Dependency Inversion Principle • Interface based programming • public string Concatenate(IList<string> parts, string delimeter) • { • string result = ""; • foreach (var part in parts) • result += part + delimeter; • return result; • } • public string Concatenate(string[] parts, string delimeter) • { • string result = ""; • foreach (var part in parts) • result += part + delimeter; • return result; • }

16. The Dependency Inversion Principle • Interface based programming • public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable • { • // Methods • intIndexOf(T item); • void Insert(int index, T item); • void RemoveAt(int index); • // Properties • T this[int index] { get; set; } • }

17. The Dependency Inversion Principle • Interface based programming • public interface ICollection<T> : IEnumerable<T>, IEnumerable • { • // Methods • void Add(T item); • void Clear(); • bool Contains(T item); • void CopyTo(T[] array, intarrayIndex); • bool Remove(T item); • // Properties • int Count { get; } • boolIsReadOnly { get; } • }

18. The Dependency Inversion Principle • Interface based programming • public string Concatenate(IEnumerable<string> parts, string delimeter) • { • string result = ""; • foreach (var part in parts) • result += part + delimeter; • return result; • }

19. The Dependency Inversion Principle DRY Don’t Repeat Yourself!

20. The Dependency Inversion Principle • Dependency Injection • “Depend on abstractions and not concretions” • Never call “new” to obtain a dependency • Inject dependencies instead

21. The Dependency Inversion Principle Dependency Injection public interface IRepository<TEntity> { IQueryable<TEntity> Query(); void Insert(TEntity entity); void Update(TEntity entity); void Delete(TEntity entity); } public interface IValidator<TEntity> { IEnumerable<IViolation> Validate(TEntity entity); }

22. The Dependency Inversion Principle • Dependency Injection • public class Repository<TEntity> : IRepository<TEntity> • { • private readonlyIValidator<TEntity> validator; • public Repository(IValidator<TEntity> validator) • { • this.validator = validator; • } • public void Insert(TEntity entity) • { • var violations = this.validator.Validate(entity); • if (violations.Count() != 0) • throw new ValidationException(violations); • // Insert if validation passed • Session.Save(entity); • } • // other methods • }

23. S.O.L.I.D Principles The Interface Segregation Principle

24. The Interface Segregation Principle • “Clients should not be forced to depend on interfaces that they do not use” • Fat vs Thin Interfaces • Drives low coupling • Helps create self-documenting code

25. The Interface Segregation Principle Example: public interface ICRUDService<TEntity> { TEntity Find(int id); void Insert(TEntity entity); void Update(TEntity entity) void Delete(TEntity entity); }

26. The Interface Segregation Principle Example: public interface ICRUDService<TEntity> { TEntity Find(int id); void Insert(TEntity entity); void Update(TEntity entity) void Delete(TEntity entity); }

27. The Interface Segregation Principle Example public class CountryService : ICRUDService<Country> { Country Find(int id) { // bla } void Insert(Country entity) { throw new NotImplementedException(); } void Update(Country entity) { // bla } void Delete(Country entity) { throw new NotImplementedException(); } }

28. The Interface Segregation Principle Example: public interface IQueryService<TEntity> { TEntity Find(int id); } public interface IInsertService<TEntity> { void Insert(TEntity entity); }

29. The Interface Segregation Principle Example: public class CountryService : IQueryService<Country>, IUpdateService<Country> { Customer Get(int id) { // bla } void Update(Customer customer) { // bla } }

30. Implementing S.R.P. • To achieve SRP • Inject Dependencies by Inverting Control • Deal with abstractions not concretions by using interface based programming • Segregate interfaces into groups of concerns

31. Moving Forwards Using IoC Containers to help with Dependency Injection Using N-Tier architecture to create layers of concerns to aid with SRP