The new Microsoft.AspNet.Core.All package contains all ASP.NET Core 2.0 features in a single library. It includes authentication, MVC, Razor, monitoring, Kestrel support and many others. They are explained in more detail later in the book.

The runtime store is an important new component shipped with ASP.NET Core 2.0. It contains compiled packages, which were compiled using the native machine language and it is key for improved performance. All applications using the Microsoft.AspNet.Core.All package benefit from it, because they do not need to be deployed with all the dependent packages anymore. Everything is already there, so their deployment size will be reduced and their execution time will be optimized.

ASP.NET Core 2.0 allows you to create well-factored and testable web applications that follow the Model-View-Controller (MVC) pattern. We have dedicated a full chapter to this topic later in the book.

Furthermore, you can build HTTP services with full support for content negotiation using custom and built-in formatters such as JSON or XML as well as RESTful services.

ASP.NET Core 2.0 fully supports Razor which contains an efficient language for creating your views and Tag Helpers enable server-side code to participate in creating and rendering HTML elements in Razor files.

Model binding automatically maps data from HTTP requests to action method parameters and model validation automatically performs client and server side validation.

In terms of client-side development, ASP.NET Core 2.0 is designed to integrate seamlessly with a variety of client-side frameworks including AngularJS, KnockoutJS, and Bootstrap.

Additionally, it provides the following fundamental improvements:

• ASP.NET MVC and Web API have been combined into a single framework
• Modern client-side frameworks and development workflows
• Environment-based configuration system ready for cloud hosting
• Built-in dependency injection functionalities
• New light-weight and modular HTTP request pipeline
• Host the same application in IIS, self-host, Docker, Cloud and even in your own processes
• Hosts multiple versions of an application or a component side-by-side
• Ships entirely as NuGet packages
• New tooling that simplifies modern web development
• Simplified csproj file, making it easier to work with development environments other than Visual Studio (on Linux and macOS, for example)
• The Program.cs class has been extended to fully automate the integration of Kestrel, the setting of the ContentRootPath, loading the configuration files, initializing the logging middleware, and other steps by only calling a single method
• The Startup.cs has been simplified by moving logging and configuration into the WebHost builder initialization

As explained before, the ASP.NET Core 2.0 framework has been built, from the beginning, with cross-platform support in mind. It supports a wide variety of operating systems and technologies such as Windows, Linux, macOS, Docker, Azure, and others.

ASP.NET Core 2.0 currently supports the following Linux distributions:

• Ubuntu 14, 16
• Linux Mint 17, 18
• Debian 8
• Fedora
• CentOS 7.1 and Oracle 7.1
• SUSE Enterprise Server 64 bits
• OpenSuse 64 bits

Concerning macOS, it currently only supports (other versions might be added later):

• macOS 10.11
• macOS 10.12

For application development, you may develop on Windows using Visual Studio or Visual Studio Code and then deploy your ASP.NET Core 2.0 application to your target system.

If you choose so, you can of course directly develop on Linux and macOS using several system-specific source code editors. On Linux, you could use Visual Studio Code, VIM/VI, Sublime, or Emacs for example. On macOS, you could use Visual Studio for Mac, Visual Studio Code or any other Mac-specific text editor.

The Visual Studio 2017 or Visual Studio Code developer environments would be the preferred choice though, since they provide everything necessary to be highly productive and to be able to debug and understand your code as well as navigate within it easily. That is why we are going to use those IDEs throughout the rest of the book.

After building your application, you can use several web servers to run it. Here are some examples:

• Apache
• IIS
• Kestrel self-host
• Nginx

Microservices also known as the microservice architecture, is an architectural layout that structures an application as a collection of loosely coupled services, which implement business capabilities. It can be used to build e-commerce system, business application, and IOT.

ASP.NET Core 2.0 is the best candidate when you want to embrace this system architecture. The ASP.NET Core 2.0 framework is lightweight and its API surface can be minimized to the scope of a specific microservice. A microservice architecture also allows you to mix technologies across service boundaries, enabling for a gradual transition to ASP.NET Core.

Notice that microservices built with ASP.NET Core 2.0 can work together with services using other technologies such as the full classic .NET Framework, Java, Ruby, and even other more legacy technologies. This is a big advantage when you need to progressively transform monolithic applications into more (micro)service-oriented applications.

You are not bound to a specific underlying infrastructure, instead, you have a wide choice since ASP.NET Core 2.0 supports nearly all the technologies that you can think of today. Additionally, you can modify the infrastructure when needed so there is no technological lock-in for applications that have been developed based on it.

Your primary choice for orchestrating and managing microservices written in C# efficiently and at high scale, on-premises, and in the cloud, should be Microsoft Service Fabric. It was conceived exactly for that and is used by Microsoft for various Azure services (SQL Database, and more) for many years already.

A microservices Docker container approach might also fit your needs, we are going to explain its use cases in the next paragraphs. To sum it up, ASP.NET Core 2.0 is the ideal choice for implementing and hosting your microservices in any kind of technical environment.

Docker and containers are everywhere at the moment. Everybody is speaking about them and there are so many use cases where they seem to be a great fit. They provide an efficient, lightweight and self-contained approach for packaging applications with their dependencies while re-using the underlying operating system files and resources.

They are a perfect fit for microservice architectures, but can also be used for any other application archetypes. They work exceptionally well together with ASP.NET Core 2.0 applications since both have been conceived with modularity, performance, scalability, lightweight nature, and efficiency in mind.

Both, Docker containers and the ASP.NET Core 2.0 framework, provide full cross-platform support (Windows, Linux, and macOS). Furthermore, you can host your containers on-premises and in the cloud. You can use Azure for example, either via IAAS deployments or via Azure Container Services, which additionally allows for mixing and matching different operating systems and technologies.

If you need the best possible performance and support high scalability scenarios then you need to absolutely use ASP.NET Core 2.0 and the underlying .NET Core Framework. ASP.NET Core 2.0 has been built from the ground up for high performance and high scalability scenarios. It really shines in these areas and it can be considered as the best choice.

It is ten times faster than classic ASP.NET, you can even think of it to be the fastest web application runtime in the .NET world currently available!

Furthermore, it provides the best solution for microservices architectures, where performance and scalability are extremely important. No other technology is as efficient while consuming such low system resources, which also leads to reduced infrastructure and cloud hosting costs.

If you want to be able to install applications with dependencies on different versions of the .NET Framework, then you should consider using the ASP.NET Core 2.0 framework, since it provides 100% side-by-side deployment capabilities.

Side-by-side deployments of different .NET Core and ASP.NET Core versions allow for having multiple services and applications on the same server. Each of them can be using their own dedicated versions of the respective frameworks, thus eliminating risks and saving money when doing application upgrades and common IT operations.

Please look carefully at the technologies shown in this section. If you use a technology or framework within your current application, which is listed here and which is not (yet) supported, then you might find it difficult or even impossible to migrate to ASP.NET Core 2.0.

Not all current .NET Framework technologies are available in ASP.NET Core 2.0 and some might never be ported over, since they do not comply with the new .NET Core specific paradigms and patterns.

The following list shows the most common technologies not directly found in ASP.NET Core and .NET Core, knowing that some can be used via the multi-targeting features:

• ASP.NET Web Forms applications: The legacy Web Forms technology is only available using the full classic .NET Framework, you cannot use ASP.NET Core and .NET Core for these types of applications.
• ASP.NET Web Pages applications: They are not included in ASP.NET Core 2.0 as such, but it is possible to use the Razor web pages engine to provide the same functionalities.
• ASP.NET SignalR applications: Currently, ASP.NET SignalR is not available for ASP.NET Core. However, you can find a first preview version in the corresponding server-side and client library GitHub repositories, so they should be included in one of the next releases.
• WCF Services: ASP.NET Core 2.0 contains a WCF client for accessing WCF services, but creating WCF services is not supported. This feature might be added in future releases though.
• Workflow Services: Windows Workflow Foundation, Workflow Services, and WCF Data Services are not supported and there are no plans for adding them to ASP.NET Core in the future.
• WPF and Windows Forms applications: Windows Presentation Foundation and Windows Forms cannot be built with ASP.NET Core, it would go against the cross-platform paradigm. You could, however, replace your WPF applications by UWP applications provided by the XAML2 Universal standard.

Not all .NET languages are currently supported by ASP.NET Core 2.0. For example, F# does not have any tooling support. Visual Basic support has been added in the latest version of Visual Studio 2017. There will be more and more languages that will be supported.

In addition to the official ASP.NET Core roadmap, there are other frameworks and technologies, that are planned to be ported over to .NET Core in the next months. To get further information on what will be ported over and what will not, go to the GitHub repository of the .NET Core Libraries (https://github.com/dotnet/corefx).

For those that are planned, there is no assurance that they will really get ported over, though. But you will find a good indication of what you can expect in the next versions of ASP.NET Core. Note that you can, in some cases, use the multi-targeting features of ASP.NET Core 2.0 for being able to call frameworks that are currently not directly supported by ASP.NET Core 2.0.

If you care about a specific framework or component that you need within your projects, consider participating in the discussions on GitHub. Maybe others will have the same requirements and Microsoft decides to prioritize their .NET Core migration accordingly.

Some Microsoft services, and even some third-party platforms, do not support ASP.NET Core. For example, some Azure services such as Service Fabric Stateful Reliable Services and Service Fabric Reliable Actors require the full classic .NET Framework.

Also, sometimes ASP.NET Core SDKs are not provided or not yet available. In the meantime, you can always use the equivalent REST APIs instead of the client SDKs and then replace them later. Be assured, all Azure services are going to support ASP.NET Core in the future as can be seen on the respective product roadmap.

After having seen the various features and functionalities provided by ASP.NET Core 2.0, you could ask yourself if it will replace the full classic .NET Framework in the future. It is true that ASP.NET Core 2.0 and the underlying .NET Core Framework provide some major enhancement and performance improvements, but there are still some specific scenarios, where those new application patterns do not apply and where the full .NET Framework will be the best and sometimes even the only choice.

Migrating your whole existing applications to ASP.NET Core right from the start might be difficult or even impossible to do. You should think about how to transform your applications progressively to lower the risk of failure or over-complexification and give yourself time to really understand the new patterns and paradigms.

You could start for instance by only using ASP.NET Core 2.0 for all new developments, then see how to migrate your legacy code later and sometimes even leave it be since there will be no real benefits for migrating it over. If you are really interested in the migration topic, please consider the appendix, since we have a full chapter dedicated to this important topic.

ASP.NET Core and the .NET Core Framework get more and more framework and client library support each day. Microsoft, tool and framework vendors, and the different developer communities work hard to provide a large set of functionalities for allowing feature-rich and high performing web applications. Everybody wants to work on this promising technology that could shape the future in a sustainable way.

The possibility to use .NET Core and .NET Framework libraries together at the same time when using .NET Standard 2.0 extends the possibilities even more and gives developers a temporary solution until every important feature and every major framework will be available in .NET Core.

To recap what has been discussed in this chapter, you should use ASP.NET Core 2.0 for your server applications when:

• You have cross-platform needs
• You are specifically targeting microservices
• You want to use Docker containers
• You need high performance and highly scalable applications
• You need to put multiple applications with different .NET versions side by side
• The presented technical restrictions do not apply to your application requirements

In this chapter, you have learned about the ASP.NET Core 2.0 framework and its features. You have seen that it includes everything necessary to work efficiently in a cross-platform environment while using microservices architectures and container technologies such as Docker.

Furthermore, you have learned that it provides very good performances and exceptional scalability for your web applications and that even side-by-side deployments are supported.

At the end, we have talked about technical restrictions and when it is advisable to use the ASP.NET Core 2.0 framework.

In the next chapter, we will talk about how to set up your development environment including either Visual Studio 2017 or Visual Studio Code as an integrated development environment.