Does it possible horizontal scaling for monolithic solutions.? lets consider about this.

[semihyildiz]

Do you think that is it possible while building microservices for in-company applications, can we use Monolithic development?.

As you know microservice architecture has many advantages.Many people knows this. and I dont need to explain this advantages in this topic.

But how can we eliminate the disadvantages.which are:

1-)the number of developers needed is too much.It is developed by more than one team. It is difficult to coordinate and keep teams up to date.

2-)A complex structure may arise. It is difficult for a developer working in any of the Micro Services to know the whole system

Applications that we can perform monolithic require less human documentation and less effort as development. and developers have a very high command over the overall project.

My theory is as follows.
First, let's consider a classic solution prepared in a layered manner.

Layer descriptions:

Entities: it is common library, entities, models ex: Product ,User

public class Product
   {
       public int Id { get; set; }
       public string Name { get; set; }
   }

    public class User
   {
       public int Id { get; set; }
       public string Name { get; set; }
       public string Email { get; set; }
   }

Db : DbContexes (mysql,mssql,Mongo,etc)

No need to give information about this layer for narration

Repositories : Repositories of entities ex:RepProduct,RepUser*

No need to give information about this layer for narration

Bussiness :Bussiness logic of solution ex:ProductManagement,UserManagement

 public class ProductManagement 
{
    public List<Product> GetProducts() 
    {
        /*GetProducts  Processes ,Repository or Memory Processes*/

        return new List<Product>();
    }   
}
public class UserManagement 
{
    public List<Product> GetUsers()
    {
        /*GetUsers  Processes,Repository or Memory Processes*/

        return new List<Product>();
    }
}

Services : EndPoints of Bussiness library ex:ProductService,UserService

 public class ProductService
{
    [HttpGet]
    public List<Product> GetProducts()
    {
        UserManagement userMan = new UserManagement();
        return userMan.GetUsers();
    }
}
public class UserService
{
    [HttpGet]
    public List<Product> GetProducts()
    {
        ProductManagement prodMan = new ProductManagement();
        return prodMan.GetProducts();
    }
}

As you can see, there is only one Back-End system that gives out products and users in its simplest form.
We can quickly develop this project with vertical scaling, with fewer developers needed.

So over time our application has grown and if we want to scale this application horizontally, how do we do it? By writing new application?

It is not neccesary, I think,
A structure like this is needed.

   public class ProductManagement 
{
    [MicroRoute("ProductService","GetProducts", "GET","Before")]
    public List<Product> GetProducts() 
    {
        /*GetProducts  Processes ,Repository or Memory Processes*/

        return new List<Product>();
    }   
}
public class UserManagement 
{
    [MicroRoute("UserService","GetUsers", "GET","Before")]
    public List<Product> GetUsers()
    {
        /*GetUsers  Processes,Repository or Memory Processes*/

        return new List<Product>();
    }
}

As you can see, there is only one Back-End system that gives out products and users in its simplest form.
We can quickly develop this project with monolithic, with fewer developers needed.

So over time our application has grown and if we want to scale this application horizontally, how do we do it? By writing new application?

It is not neccesary, I think,
A structure like this is needed.

As you can see my aim, to be able to redirect the request from one method to another before method working

i am planning to do this with MicroRoute attribute

 [AttributeUsage(AttributeTargets.Method)]
public class MicroRoute : Attribute
{
    private string baseurl{get;set;}
    private string method { get; set; }
    private string httpType { get; set; }
    private string workingEvent { get; set; }

    public MicroRoute(string BaseUrl,string Method,string HttpType,string WorkingEvent)
    {
        this.baseurl = BaseUrl;
        this.method = Method;
        this.httpType = HttpType;
        this.workingEvent = WorkingEvent;//decides working type{before method running or after method run}
    }
    private object Before() 
    {
        object result = null;
        /*Get Settings for "this.baseurl" from anywhere (application.settings,parameters etc)
        like Content-Type ,Token Informations, body style etc.
        For Ex. 
        ProductService {
            endpoint: "www.myProductService.com/v1",
            "Content-Type":"Application/json"
                        },
        UserService {
            endpoint: "www.myUserService.com/v1",
            "Content-Type":"Application/json"
         */
        /*Catch calling method request*/
        /*Convert request of calling method to WebRequest.*/
        /*Route this request to endPoint which taken from settings*/
        /*result=response*/
        return result;
    }
    private object After()
    {
        object result = null;
        /*I dont need to call this method after any BussinessLogic return.
         but maybe someone needs.
         */
        return result;
    }
}

In this way, end points can be directed to different servers according to service settings using the same source code repository.

 [MicroRoute("ProductService","GetProducts", "GET","Before")]

With the MicroRoute attribute, we define that this method should pull the ProductServiceParameters, the name of the method in the endpoint, which http type it works with, and whether it can work before or after the method.

For this example, the MicroRoute attribute method runs the Before () method before it runs.

Let's talk about the Before () method

First step,It pulls the necessary settings for the web service.

Second Step, If exists, it prepares http request with the request from the method using these settings.
and sends it to the destination.

The request reaches a working copy of the same application on a different server for ProductService.
There, the GetProducts method in Product Management meets our request as well.
but since its parameters are empty, it is not directed to any other endpoints. and does GetProducts ()

As a result:
I tried it in c# like above but I failed ,because attibute programming, or AOP Structure does not support this kind of things as I know.

but I done that manualy like below,

      public List<Product> GetProducts() 
    {
        if (MicroRoute.CheckRouteChange("ProductService", "GetProducts")==true) 
        {
            RestRequests request = RestRequests.Create().SetMethodPath("ProductService/GetProducts");
            Result = request.GET<List<Product>>();
        }

        /*GetProducts  Processes,Repository or Memory Processes*/

        return new List<Product>();
    }  

I think this system can work in different containers by changing configurations except database layer.

I have two questions

How can this approach be done more professionally?

Can't c# support such a feature in new versions?

[YairHalberstadt]

I'm not understanding what you're asking for here. Is there a specific language feature you want?

[semihyildiz]

Mr.YairHalberstadt thank you for your response,

I tried to explain Micro Route inherited from Attribute. But it is not able to do Before() and after() methods by catching request

[MicroRoute("ProductService","GetProducts", "GET","Before")]

[YairHalberstadt]

It sounds like you're wanting aspect oriented programming. PostSharp may help you there - take a look at their post here: #4357

This issue may also be relevant: #107. That issue has however been put on the backlog indefinitely.