Abto Software is a provider of quality ASP.NET solutions with comprehensive ASP.NET and .NET framework utilization. Today we share our practical experience by reviewing the ways of implementing modern enterprise solutions using Microsoft .NET ecosystem.
There are many good choices and the final ‘what to use’ decision should be made by a qualified architect after a thorough analysis of a particular project and customer’s business objectives. In this article, we tried outlining what road should be taken and the considerations that will make all the difference. All recommendations are based on Microsoft guidelines and our 13 years’ experience with the .NET stack.
.NET Framework vs .NET Core
One of the first choices is whether .NET Framework or .NET Core should be used. If there is already an existing application written in .NET Framework, the recommendation is to extend instead of migrating. Another reason to continue with .NET Framework is the dependency on third-party libraries not available yet in .NET Core.
If the application has to be designed and written from scratch, .NET Core is the choice. Being developed since 2014, it is a seasoned framework. .NET Core 3.1 is a long-term support (LTS) version. High performance and scalability needs, cross-platform requirements are indicators that .NET Core should be used. The modularity and lightweight nature of .NET Core makes it de facto standard for Docker containers and microservices architecture.
Web, Mobile, Desktop
Desktop applications were main players for a long time and they still keep their positions where it is needed to have a rich UI with heavy processor or video card usage – take AutoCAD as an example. .NET WPF is a preferred solution in this case.
Mobile versions of the program are inevitable nowadays, providing immediate access to the main functionalities from smartphones or tablets. They usually are developed as an optimized version of the main web application or native apps for a better user experience. In the latter case, cross-platform tools like Xamarin provide a possibility to quickly develop applications with one codebase for both Android and iPhone OS.
And finally, web versions are most widespread now. Modern web applications are expected to be available 24/7, must be secure, flexible, and scalable to handle peaks in demand.
Further in the article, we will speak about the architecture of modern web solutions.
Cloud vs. On-premise
On-premise solutions give fine-grained in-house control over deployment and hosting. Cloud, on the other hand, removes the necessity to care about your infrastructure and frees your resources to be focused on the application features themselves. In a cloud, it is easy to scale both up (more resources per node) and out (more hosted nodes) to meet any increase in demand. Nodes might be either physical servers, virtual machines, or containers. With configured automatic scaling, the app can automatically increase or decrease the number of nodes where the app is hosted, based on current load and average demand across nodes. A load balancer is used to orchestrate requests between individual app machines.
Azure cloud is developed by Microsoft and has first-class support for the .NET. It results in faster time to production and simplifies the constant evolution of the application. Amazon Web Services (AWS) also has all the main features required for the .NET. Pricing comparison between two is not straightforward and has to be done in each case separately. This is partially because they offer hundreds of features with different pricing options. Some other cloud providers are available as well.
Microservices vs. Monolithic
Modern microservices architecture provides many benefits compared with the traditional monolithic approach. All of them are consequences from the fact that each microservice is responding to a specific domain capability with a clear boundary.
The most noticeable advantage is the possibility to independently scale specific parts of the application that encounter heavy load. That means cost savings because you need less hardware.
Microservices facilitate better maintainability since all of them can have its own deployment lifecycle. They can be deployed at different times, require less regression testing because of the well-defined boundaries of responsibility.
Also, it is possible to make parallel development by different teams more autonomous.
It is also worth noting that microservices are, in a way, successors of 2000’s Service-Oriented Architecture (SOA). SOA comprised loosely coupled components that used an Enterprise Service Bus for messaging between them. That Service Bus could be a single point of failure affecting all of the system. On the contrary, if microservice crashes, it only means outage for that one microservice only.
But all the advantages come with a price. Such architecture requires a very well-thought design. Separating concepts between microservices is feasible with excellent knowledge of the underlying business logic. It requires a highly professional team to tackle the extra complexity of this approach.
Simply scaling monolithic applications as a whole can prove to be more efficient with little redundancy.
The next thing to look at is whether there is a need to expose a rich GUI. In this case, a single page application (SPA) with an appropriate UI framework can be chosen. Two of the most popular frameworks are React and Angular.
React is a library with good documentation, many specialists, great performance. One disadvantage is that it requires leveraging additional libraries and the choice is vast. It must take a qualified architect to make appropriate decisions and later verify them. Thus, a good start can be a React Slingshot kit which prepackages a set of compatible libraries together with React.
Angular is a complete, robust framework with defined guidelines which makes it arguably the best choice for enterprise applications where long-term stability is a must.
Traditional web applications are a choice when client UI is read-only or read-mostly and has simple requirements.
The properly established development process is of no less importance than the choice of development technologies. Continuous integration and continuous delivery (CI/CD), with automated unit and integration tests, are a bit expensive to set up and maintain, however, help to identify and resolve issues quickly, thus optimizing software development quality, time and cost for long-term projects especially. Professional setup includes code running on alpha (testing), beta (UAT) and pre-production servers before releasing to live. Using Docker containers ensures that the program is tested in the exact same environment as it will be run in production. Regular demos to a client help to synchronize expectations from both sides.
One scenario is planning a data-intensive enterprise system with thousands of users and millions of requests per minute with a rich GUI. Obviously, such a system might be developed by several distributed teams. Possible setup is as follows:
- .NET Core
- Azure cloud services
- Microservices architecture
- Angular SPA
Another scenario is a smaller website with low to medium load and straightforward UI, which should be released very quickly an improved with time. The following setup should be OK:
- .NET Core (unless this is an upgrade from an older system)
- On-premise hosting or virtual private server on either Azure or AWS
- Monolithic architecture
- React SPA or regular ASP.NET MVC Razor views
And, of course, your scenario might be a combination of two above scenarios in different proportions.
Discover how .NET development can benefit your business – contact us by filling out the form below.