Domain Driven Design with Web API extensions part 7: domain events with RabbitMq completed

November 12, 2015 1 Comment

Introduction

In the previous post we set up the local RabbitMq environment. We also created a simple console application that built the message queue where the DDD demo project and the simulated financial application will communicate. We also prepared the way for the completion of the messaging process by creating an app setting reader and adding the RabbitMq related settings to web config.

In this post we’ll complete the demo by sending a message to the queue and reading it from the dummy financial console application.

Read more of this post

Filed under .NET, Design patterns, Design principles, Messaging Tagged with , , , , ,

Domain Driven Design with Web API extensions part 6: domain events with RabbitMq

November 9, 2015 2 Comments

Introduction

In the previous post we looked at some basic theory behind messaging between independent applications. We discussed a couple of options to solve the problem. In this post we’ll start building our messaging environment using RabbitMq.

Read more of this post

Filed under .NET, Design patterns, Design principles, Messaging Tagged with , , , ,

Domain Driven Design with Web API extensions part 4: domain events in code

November 2, 2015 1 Comment

Introduction

In the previous post we looked at some theory behind domain events. We said that domain events were events that happen within a domain and that other components of the system may be interested in. The domain becomes the publisher – or producer – and the listeners will be the subscribers, or consumers of the domain messages.

We established that we’d solve the communication of consumers and subscribers through a mediator which stands in between. Publishers and subscribers will stay decoupled that way.

In this post we’ll implement the theory in C# code.

Read more of this post

Filed under .NET, Design patterns, Design principles, web api 2 Tagged with , , , ,

Domain Driven Design with Web API extensions part 3: starting with domain events

October 29, 2015 1 Comment

Introduction

In the previous post we looked at how to apply the decorator pattern for our emailing scenario in the domain driven design demo project. We saw how the pattern helped us augment the functionality of the original TimetableService in an object oriented fashion. We also managed to wire up the decorator in StructureMap.

In this post we’ll solve the same problem in a different way. Well, at least we’ll start looking at another solution. Also, we’ll start discussing another concept from DDD: domain events. This part of the topic will be divided into two posts: the current post lays the theoretical foundations for the concepts and the next post will show the code.

Read more of this post

Filed under .NET, Design patterns, Design principles Tagged with , , ,

Domain Driven Design with Web API extensions part 2: notifications with the decorator pattern

October 26, 2015 Leave a comment

Introduction

In the previous post we started building an extension to our DDD skeleton project. We saw a simple way of adding a component to the TimetableService so that we could send an email upon inserting or updating a load test. We also discussed the pros and cons of the current implementation.

In this post we’ll see an alternative solution using the Decorator design pattern.

Read more of this post

Filed under .NET, Design principles Tagged with , , , ,

Domain Driven Design with Web API extensions part 1: notifications

October 22, 2015 3 Comments

Introduction

A couple of weeks ago we went through an updated series on Domain Driven Design starting with this post. We built a functioning skeleton project with EntityFramework as the backing store, a Web API layer as the top consumer, a loosely coupled service layer and a central domain layer with some logic.

In this extension series we’ll investigate a couple of ways to add various dependencies to the project. In particular we’ll look into how to send email notifications in case a new load test has been booked.

Read more of this post

Filed under .NET, Design principles, Web API Tagged with , , , ,

Domain Driven Design with Web API revisited Part 18: tests and conclusions

October 5, 2015 2 Comments

Introduction

In the previous post we continued working on our Web API 2 layer and added two new controller actions: POST which handles both updates and insertions and DELETE which is responsible for deleting load tests. Our first draft of the DDD load testing demo is actually finished at this point. All that’s left is testing the POST and DELETE functions of the Web API.

We’ll do that in this post. We’ll also write some conclusions.

Read more of this post

Filed under .NET, Design principles Tagged with , , ,

Domain Driven Design with Web API revisited Part 17: the POST and DELETE controller actions

October 1, 2015 Leave a comment

Introduction

In the previous post we started building the top layer of our load testing DDD demo solution. We added an empty Web API 2 project and also created a GET controller action to retrieve the open load tests 2 weeks ahead. We also managed to add an IoC controller called StructureMap which injects the required concrete dependencies into the controllers and service methods.

In this post we’ll continue building on our demo project and add the POST and DELETE controller actions as well. We’ll also see another application of the view-model concept we saw earlier.

Read more of this post

Filed under .NET, Design principles Tagged with , , ,

Domain Driven Design with Web API revisited Part 16: the Web API consumer layer and the GET controller action

September 28, 2015 1 Comment

Introduction

In the previous post we built the concrete application service layer for our demo project. We saw that it was quite straightforward to implement the abstract service we inserted in the post before that.

It is time to build the top layer of the solution which will communicate with the application service. This post will be quite technical as we need to add an IoC container to the Web API project.

Read more of this post

Filed under .NET, Design principles Tagged with , , ,

Domain Driven Design with Web API revisited Part 15: the concrete application service

September 24, 2015 1 Comment

Introduction

In the previous post we looked at application services in general. We saw that they connect the ultimate consumer layer, such as MVC with the domain layer. They have no or very little logic. Instead, they act as coordinators. They accept requests from the consumer layer and make sure that the consumer layer gets back a valid response. The consumer won’t care how the application service carries out its job and what concrete dependencies it may have.

In this post we’ll build upon the abstract timetable service and basic messaging classes. The goal is to build a functioning service layer.

Read more of this post

Filed under .NET, Design principles Tagged with , , ,

← Older posts

Newer posts →

Elliot Balynn's Blog

A directory of wonderful thoughts

Software Engineering

Web development

Disparate Opinions

Various tidbits

chsakell's Blog

WEB APPLICATION DEVELOPMENT TUTORIALS WITH OPEN-SOURCE PROJECTS

Once Upon a Camayoc

ARCHIVED: Bite-size insight on Cyber Security for the not too technical.