ioc | Inversion of Control | Aspect Oriented library

This can be achived using generics:

finally, I found my answers in this article https://snede.net/you-dont-need-a-idesigntimedbcontextfactory/

Create ApplicationDbContextFactory in Portal.Data project:

You have a order issue source

change to:

The main advantages of using a library to handle dependency injection is:

• The automation of boilerplate code
• Having a central place that contains the instance about the current context

Using a dependency injection container, you have that single entity that contains the all the instances. It can be tempting to send that thing everywhere since you'll have the whole context available, but I would advise against.

In the kangaru documentation, I added this in the guidelines:

This library is a great tool to minimize coupling, but coupling with this library is still coupling.

So for example, if void f(); (as a free function) needs the logger, then it should be passed as parameter.

Async functions in JS are syntax sugar for functions returning a Promise.

core.async does not work with Promises by default and you need to use the helper function to make them act like channels if you want to. The macro does this for you.

You don't actually need to wire it up as part of the .NET ILogger. I am sure there is a way (probably via OWIN) but you nothing stops you from writing a basic logging service as you would any other service and using that via bog standard DI. The answer was pretty much in the question to begin with.

Have you tried annotating your executeJob Method with a @PostConstruct ? That way upon initialisation of your application, the jobs would be registered to the JobServer.

I believe the @Job annotation is meant fo the method of the job itself. (In your case the debug method).

Dependency Injection is the concept of passing depended on objects into the object itself. In this case passing the IRepository repository into the AnonymousLoginService means that AnonmyousLoginService is dependent upon IRepository. It has nothing to do with the parameters passed into the methods.

If you feel it is best to have the separation of concerns and instantiating new db models in the method to verify that it is valid, instead of accepting user input as a db model and passing it in. It is okay.

Having the Domain Layer in a separate application is not wrong at all. Especially if you don't want to have to create a new Domain Layer for every application built. The Domain Layer could be used this way to loosely couple the code and have one single Domain Layer for multiple applications. Assuming that method return types, method names, and method parameters don't change, a change to the Domain Layer should not break any project depending on it.

As far as having the api know about both types of models (db and api models) sounds a lot better than having the Domain Layer know about both types of models. The Domain Layer would probably be better served to only know about Domain Models, then every application that uses the Domain Layer could also have access to the Domain Models. Instead of having the Domain Layer understand models from multiple projects, the only thing to consider is how secure the domain models should be? Maybe have set of dummy domain models (public facing db models) and a set of private db models (actual db models) and the Domain Layer gives access to the dummy models and then from there instantiates the actual db models. Ensuring that the actual logic and code is encapsulated.

We ended up removing ActionForm from the site and the API started working as expected. So it was related to dependency injection conflicts. I could have done a paid upgrade to ActionForm to get a more recent version that fixed it (we were using v5.1.54), but instead there was only 1 contact form, so we replaced it with something else, removed AF and the issue vanished.