Architecture and patterns
Design patterns in .NET
- Design patterns and practices in .NET: the Adapter Pattern
- Design patterns and practices in .NET: the Strategy Pattern
- Design patterns and practices in .NET: the Factory Patterns – concrete, static, abstract
- Design patterns and practices in .NET: the Null Object pattern
- Design patterns and practices in .NET: the Singleton pattern
- Design patterns and practices in .NET: the Decorator design pattern
- Design patterns and practices in .NET: the State pattern
- Design patterns and practices in .NET: the Template Method design pattern
- Design patterns and practices in .NET: the Chain of Responsibility pattern
- Design patterns and practices in .NET: the Composite pattern
- Design patterns and practices in .NET: the Interpreter pattern
- Design patterns and practices in .NET: the Mediator pattern
- Design patterns and practices in .NET: the Flyweight pattern
- Design patterns and practices in .NET: the Facade pattern
- Design patterns and practices in .NET: the Builder pattern
- Design patterns and practices in .NET: the Bridge pattern
- Design patterns and practices in .NET: the Observer pattern
- Design patterns and practices in .NET: the Prototype pattern
Design principles in .NET
- SOLID design principles in .NET: the Single Responsibility Principle
- SOLID design principles in .NET: the Open-Closed Principle
- SOLID design principles in .NET: the Liskov Substitution Principle
- SOLID design principles in .NET: the Interface Segregation Principle
- SOLID design principles in .NET: the Dependency Inversion Principle and the Dependency Injection pattern
- SOLID design principles in .NET: the Dependency Inversion Principle Part 2, DI patterns
- SOLID design principles in .NET: the Dependency Inversion Principle Part 3, DI anti-patterns
- SOLID design principles in .NET: the Dependency Inversion Principle Part 4, Interception and conclusions
- SOLID design principles in .NET: the Dependency Inversion Principle Part 5, Hello World revisited
- SOLID principles in .NET revisited part 1: introduction with code to be improved
- SOLID principles in .NET revisited part 2: Single Responsibility Principle
- SOLID principles in .NET revisited part 3: the Open-Closed principle
- SOLID principles in .NET revisited part 4: the Liskov Substitution Principle
- SOLID principles in .NET revisited part 5: the Liskov Substitution Principle 2
- SOLID principles in .NET revisited part 6: the Interface Segregation Principle
- SOLID principles in .NET revisited part 7: the Dependency Inversion Principle
- SOLID principles in .NET revisited part 8: clean-up
- SOLID principles in .NET revisited part 9: concentrating on enumerations
- SOLID principles in .NET revisited part 10: concentrating on enumerations resolved
- The Don’t-Repeat-Yourself (DRY) design principle in .NET Part 1
- The Don’t-Repeat-Yourself (DRY) design principle in .NET Part 2
- The Don’t-Repeat-Yourself (DRY) design principle in .NET Part 3
Domain Driven Design
Original skeleton project
- A model .NET web service based on Domain Driven Design Part 1: introduction
- A model .NET web service based on Domain Driven Design Part 2: DDD basics
- A model .NET web service based on Domain Driven Design Part 3: the Domain
- A model .NET web service based on Domain Driven Design Part 4: the abstract Repository
- A model .NET web service based on Domain Driven Design Part 5: the concrete Repository
- A model .NET web service based on Domain Driven Design Part 6: the concrete Repository continued
- A model .NET web service based on Domain Driven Design Part 7: the abstract Service
- A model .NET web service based on Domain Driven Design Part 8: the concrete Service
- A model .NET web service based on Domain Driven Design Part 9: the Web layer
- A model .NET web service based on Domain Driven Design Part 10: tests and conclusions
- Extension to the DDD skeleton project: domain specific rules Part 1
- Extension to the DDD skeleton project: domain specific rules Part 2
- Extension to the DDD skeleton project: caching in the service layer
- Extension to the DDD skeleton project: using an external settings source
- Extension to the DDD skeleton project: per session object context in Repository layer
DDD revisited
- Domain Driven Design with Web API revisited Part 1: introduction
- Domain Driven Design with Web API revisited Part 2: the problem domain and DDD basics refreshed
- Domain Driven Design with Web API revisited Part 3: shared kernel, bounded context and some initial code
- Domain Driven Design with Web API revisited Part 4: the ubiquitous language and our refined problem domain
- Domain Driven Design with Web API revisited Part 5: starting with the domain in code
- Domain Driven Design with Web API revisited Part 6: associations and standalone classes
- Domain Driven Design with Web API revisited Part 7: the aggregate root in our domain model
- Domain Driven Design with Web API revisited Part 8: the abstract repository
- Domain Driven Design with Web API revisited Part 9: the overall database context
- Domain Driven Design with Web API revisited Part 10: the load test database context
- Domain Driven Design with Web API revisited Part 11: database creation and initial tests
- Domain Driven Design with Web API revisited Part 12: testing the load testing database context
- Domain Driven Design with Web API revisited Part 13: view models
- Domain Driven Design with Web API revisited Part 14: the abstract application service
- Domain Driven Design with Web API revisited Part 15: the concrete application service
- Domain Driven Design with Web API revisited Part 16: the Web API consumer layer and the GET controller action
- Domain Driven Design with Web API revisited Part 17: the POST and DELETE controller actions
- Domain Driven Design with Web API revisited Part 18: tests and conclusions
- Domain Driven Design with Web API extensions part 1: notifications
- Domain Driven Design with Web API extensions part 2: notifications with the decorator pattern
- Domain Driven Design with Web API extensions part 3: starting with domain events
- Domain Driven Design with Web API extensions part 4: domain events in code
- Domain Driven Design with Web API extensions part 5: domain events between independent systems
- Domain Driven Design with Web API extensions part 6: domain events with RabbitMq
- Domain Driven Design with Web API extensions part 7: domain events with RabbitMq completed
- Domain Driven Design with Web API extensions part 8: domain repository with MongoDb
- Domain Driven Design with Web API extensions part 9: setting up MongoDb
- Domain Driven Design with Web API extensions part 10: the MongoDb context
- Domain Driven Design with Web API extensions part 11: the MongoDb database objects
- Domain Driven Design with Web API extensions part 12: seeding the MongoDb database
- Domain Driven Design with Web API extensions part 13: query examples with the MongoDb driver
- Domain Driven Design with Web API extensions part 14: implementing the ITimetableRepository interface in MongoDb
- Domain Driven Design with Web API extensions part 15: implementing the ITimetableViewModelRepository interface in MongoDb
- Domain Driven Design with Web API extensions part 16: testing the MongoDb repository in the DDD application
Externalising object dependencies
- Externalising dependencies with Dependency Injection in .NET part 1: setup
- Externalising dependencies with Dependency Injection in .NET part 2: caching
- Externalising dependencies with Dependency Injection in .NET part 3: configuration
- Externalising dependencies with Dependency Injection in .NET part 4: logging part 1
- Externalising dependencies with Dependency Injection in .NET part 5: logging with log4net
- Externalising dependencies with Dependency Injection in .NET part 6: file system
- Externalising dependencies with Dependency Injection in .NET part 7: emailing
- Externalising dependencies with Dependency Injection in .NET part 8: symmetric cryptography
- Externalising dependencies with Dependency Injection in .NET part 9: asymmetric cryptography
- Externalising dependencies with Dependency Injection in .NET part 10: hashing and digital signatures
Service Oriented Architecture
- A model SOA application in .NET Part 1: the fundamentals
- A model SOA application in .NET Part 2: the domain
- A model SOA application in .NET Part 3: the repository
- A model SOA application in .NET Part 4: the service layer part 1
- A model SOA application in .NET Part 5: the service layer continued
- A model SOA application in .NET Part 6: the client proxy
- A model SOA application in .NET Part 7: testing the client proxy
Using a Windows service
- Using a Windows service in your .NET project part 1: foundations
- Using a Windows service in your .NET project part 2: the domain and repository
- Using a Windows service in your .NET project part 3: the application service layer
- Using a Windows service in your .NET project part 4: the consumer layer
- Using a Windows service in your .NET project part 5: the Windows Service project basics
- Using a Windows service in your .NET project part 6: Windows Service installation
- Using a Windows service in your .NET project part 7: Windows Service body part 1
- Using a Windows service in your .NET project part 8: Windows Service body part 2
Various
- Various topics from software architecture part 1: the RequestResponse messaging pattern
- Various topics from software architecture part 2: the Repository pattern
- Various topics from software architecture part 3: the unit of work
- Various topics from software architecture part 4: the unit of work continued
- Various topics from software architecture part 5: aggregate roots
IIS
Exercises in .NET with Andras Nemes 
Love your work: thanks for sharing your great examples.
http://www.echancrure.eu
Dear Andras ! I’m so happy about your detailed and comprehensive explanations concerning DDD. Within the last weeks I did investigate weeks over weeks crawling through the books of Fowler (PoEA), Evans (DDD – Tackling…) and Jimmy Nilsson (Applying DDD …). During my odyssey through the books and as I was finished with the aforementioned trilogy I was really mixed up. I literally did feel the pain in my head when it came to a building of new synapses that break through my old database driven mindset. A plenty of questions left open. So I did a lot of searches on the wellknown “stackified” dev sources that provided me with unsufficient splints of knowhow. For example I especially looked after my misunderstanding concerning domain objects vs. Entity Framework entities. Some guys came up with DTOs used in a memento manner to merely store the state of the objects within a database. The solution that I was looking for was given by you: simply convert or map the domain objects to database typed objects within the repository layer. Cool, simple and comprehensible.
You did help me claryfying a complex issue and pushing my ongoing mindset evolvement to a next Level. Thanks for that !
Why don’t you try to transform your insights in a book that accomplishes the aforementioned trilogy.
Looking Forward concerning new and interesting posts concerning DDD.
Dear Alex,
Thanks for your comment. I’m glad the series helped you understand DDD better.
I have been considering writing a book actually, but I simply have no time for it right now.
//Andras
Hi Andras,
Thanks for your efforts, I am reading from your blogs these are just awesome. I would really like if you continue.
Excellent article, just what I needed.
Dinesh
Andras, if I’m ever in Sweden, I’d be honored to buy you a beer.
Hi Kevin,
Thanks a lot. I don’t drink beer but I can take a tea instead 😉
//Andras
Pingback: Architecture and patterns | Exercises in .NET with Andras Nemes | Steve's ramblings
Pingback: An Interesting List of Development Stuff (July 2014) | rionscode
Thanks for your effort and good on you. I could buy you more than a cup of tea lol 🙂
First i want’s to thank you for this wonderful post and same architecture and patters, i was looking from couple of days.
Thanks alot 🙂
hI andras, Awesome articles you listed at one place, salute from Hyderabad, india for the effort! I wish you would also “explain” GOF patterns.. when i was going through that book, though I could get essence of a pattern for the given example, I still fill gap of how its been deduced from basic design principles…unless if we start with If,else basic programming n go forward that using design principle we approach a design pattern, patterns are not digest-able for me.. i wish you would easily make a digestable patterns, when i saw your writing style…. internet is lacking that stuff, though Head first design patterns did a good job, but it took easy ones 🙂
Pingback: An Interesting List of Development Stuff (July 2014) - Rion.IO
Pingback: User Interface Links and Generally Interesting stuff | No fluff, just stuff...that matters.
These are simply great. Super job 🙂
Thanks Andras!
You’re very welcome Junior
Hi Andras, I have been going through your articles since last couple of weeks. I should really have to thank you for sharing such wonderful articles, more importantly making them very easy to understand. Thank you once again!!
Do you also have articles on SQL DB? If so, can you please share. Thanks
Hi Sridhar. Thanks for your kind words. I don’t have any SQL DB related articles but you possibly view a blog edited by Pinal Dave (sqlauthority.com). //Andras
Thanks for sharing your knowledge!
You’re very welcome!
//Andras
your work is just too awesome … you should definitely write a book. Thanks for your time.
I’m glad you like the blog. I have no time right now to write a book but it’s definitely on my long term to-do list. //Andras
Cheers !!! Andras for the wealth of information you present. Absolutely Great Stuff. Thx.
You’re very welcome Samuel. //Andras
Pingback: Architecture and patterns | Michael's Excerpts
Andras, this is so excellent that I added you near the top of my list (http://clairenstreb.blogspot.com/2015/10/design-patterns.html). I bet thousands will be referencing this page for years to come. The list itself is a helpful overview to your valuable in-depth articles and code samples.
Hi Claire, thanks for your kind words. I’m not sure about the “thousands” bit but let’s aim high 🙂
Take care,
Andras
Marvellous work, you’re my hero. Congratulations
this is seriously cool effort. awesome job. thank you.
This is amazing work.. thank you
Andras, Please accept my “Thank you very much” from Dubai 🙂 .
Thanks for your comment, Essam, I’m glad you’ve found the blog useful. //Andras
Pingback: Architecture Design Patterns In .net | Become Architecture Fan
nice explanation …thanks a lot
Very helpful and clear explanation. Thanks a lot for the information.
Andras,
Thankful for your effort. I had a very good understanding from your blogs. Please keep it up your good work.
Great effort, thanks for the enlightenment.
Andras, thank you so much for this very valuable and thorough examples.
I often come back to your page and recommend it often.
It’s very well explained and easy to follow. Great work – thanks!
Hi Neville,
Thanks for your feedback. Great to hear that you find this blog useful.
Have a nice day,
Andras
Excellent articles. Very helpful and clear. Where can we download the code for the samples?
Some of the code examples on this are available on GitHub. Checkout the Github link in the main menu. //Andras
Pingback: Architecture and patterns | Exercises in .NET with Andras Nemes
Andras,
I have been tasked with implementing a server based device monitoring system and full fledge database application analysing data collected. I’m the sole software engineer at my work(we are a small RnD lab transitioning to production) and when I received these projects I was overwhelmed at first. Your blogs have been a tremendous help in guiding me in the right directions. Thank you!!
Very helpful articles. Thank you very much
Dear Sir.
It has been while since you have published something.
Please lead us in this new era of micro-services, containers and monsters such kubernetes.