Tutorial: Create Simple ExtCore-Based Web Application

We are going to create simple modular and extendable ExtCore-based web application. First of all, if you are new to ASP.NET Core please visit this page. You will find there everything you need to start developing ASP.NET Core web applications.

Create Main Web Application

Now let’s start Visual Studio and create new ASP.NET Core project:

Empty project is created.

Right click on your project in the Solution Explorer and open NuGet Package Manager. Switch to Browse tab and type ExtCore.WebApplication in the Search field (be sure that Include prerelease checkbox is checked). Click Install button:

You can get the same result manually by opening the WebApplication.csproj file and adding next line into it:

<ItemGroup>
  <PackageReference Include="ExtCore.WebApplication" Version="6.0.0" />
</ItemGroup>

Create the appsettings.json file in the project root. We will use this file to provide configuration parameters to ExtCore (such as path of the extensions folder). Now it should contain only one parameter Extensions:Path and look like this:

{
  "Extensions": {
    // Please keep in mind that you have to change '\' to '/' on Linux-based systems
    "Path": "\\Extensions"
  }
}

Open Startup.cs file. Inside the ConfigureServices method call services.AddExtCore one. Pass the extensions path as the parameter. Inside the Configure method call applicationBuilder.UseExtCore one with no parameters.

Now your Startup class should look like this:

public class Startup
{
  private string extensionsPath;

  public Startup(IHostingEnvironment hostingEnvironment, IConfiguration configuration)
  {
    this.extensionsPath = hostingEnvironment.ContentRootPath + configuration["Extensions:Path"];
  }

  public void ConfigureServices(IServiceCollection services)
  {
    services.AddExtCore(this.extensionsPath);
  }

  public void Configure(IApplicationBuilder applicationBuilder)
  {
    applicationBuilder.UseExtCore();
    applicationBuilder.Run(async (context) =>
    {
      await context.Response.WriteAsync("Hello World!");
    });
  }
}

That’s all, you now have ExtCore-based web application.

Now we need to create some extension project to show how ExtCore types discovering works.

Create Extension

Create new .NET Core class library project:

Open NuGet Package Manager and add dependency on the ExtCore.Infrastructure package.

Create Extension class and inherit it from ExtCore.Infrastructure.ExtensionBase. Override Name property in this way:

public override string Name
{
  get
  {
    return "Some name";
  }
}

It is enough for now.

Put it Together

We have two options to make our extension available in main web application:

• add direct dependency on Extension in the WebApplication;
• put compiled Extension.dll file to extensions folder of the WebApplication that is configured in appsettings.json file.

While the first option is too obvious let’s try the second one. Copy the Extension.dll file to the extensions folder of the WebApplication and modify Configure method of Startup class in next way:

public void Configure(IApplicationBuilder applicationBuilder)
{
  applicationBuilder.UseExtCore();
  applicationBuilder.Run(async (context) =>
  {
    await context.Response.WriteAsync(ExtensionManager.GetInstance<IExtension>().Name);
  });
}

It will search for the implementation of the IExtension interface, create instance of found type, and write its Name property value on every request.

If we run our web application we will have the following result:

It may not look very impressive, but it’s only the beginning! In the next tutorials we will see how extensions may execute their own code insite the ConfigureServices and Configure methods, how to use MVC and how to work with a storage.

You can find the complete source of this sample project on GitHub: ExtCore framework 6.0.0 sample simplest web application.