How To Create Help Desk Web Application using ASP.NET Core

CheapASPNETHostingReview.com | Best and cheap ASP.NET Core hosting. Suppose you work for a small to midsize company that employs 50-100 workers. The Help Desk — a subsidiary of the Information Services Division — is in charge of trouble tickets regarding general PC issues such as email, viruses, network issues, etc. Initially, the Help Desk team stored this information in Excel spreadsheets, but as the company has grown, managing these spreadsheets has become tedious and time consuming.

The Help Desk has asked you to devise a more efficient solution that could be developed internally, saving the company money. As you start to think about it, the following requirements are apparent: fields for the submitter’s first and last name, as well as their email address. You’ll also need combo boxes for indicating ticket severity (low, medium, high), department, status (new, open, resolved), employee working on the issue, as well as an area for comments. Of all the solutions available, creating an internal help desk Web application with ASP.NET is relatively simple.

In the following article, we’ll see how to implement these features in an ASP.NET help desk Web application using a database-driven approach,
Creating the JavaScript File
Because creating the JavaScript file is the easiest of the work left, we’ll do this next. From the Solution Explorer, follow these steps:

Creating the Help Desk Class

Now that we have our data coming in, we need to be able to record a help desk ticket submission. We need to create an event handler in a class to handle it. Let’s first create a help desk class by doing the following:

Right click the project solution.
Choose Add>New Item.
In the Add New Item window, select Class.cs.
In the name text field, type “HelpDesk” and then click Add.

Double click HelpDesk.cs from the Solution Explorer, which will show the empty class as shown below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace HelpDesk
{
    public class HelpDesk
    {
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

namespace HelpDesk

{

public class HelpDesk

{

}

We need to import three libraries as shown below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using System.Configuration;
using System.Data.SqlClient;
namespace HelpDesk
{
    public class HelpDesk
    {
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Data;

using System.Configuration;

using System.Data.SqlClient;

namespace HelpDesk

{

public class HelpDesk

{

}

The first library (System.Data) allows us to work with stored procedures in ADO.NET, the second (System.Configuration) allows us to reference a connection key from configuration file and the last (System.Data.SqlClient) one allows us to connect to SQL Server.

How To Using Sessions and HttpContext in ASP.NET Core and MVC Core

CheapASPNETHostingReview.com | Best and cheap ASP.NET core 1.0 hosting. If you’re new to ASP.NET Core or MVC Core, you’ll find that sessions don’t work the way they used to. Here’s how to get up and running the new way.

Add Session NuGet Package

Add the Microsoft.AspNetCore.Session NuGet package to your project.

VERSION WARNING: As you’ll find with most Microsoft.* packages, you should make sure the versions all match. At RTM time as of writing, this means “1.0.0”.

Update startup.cs

Now that we have the Session nuget package installed, we can add sessions to the ASP.NET Core pipeline.

Open up startup.cs and add the AddSession() and AddDistributedMemoryCache() lines to the ConfigureServices(IServiceCollection services)

// Add MVC services to the services container.
services.AddMvc();
services.AddDistributedMemoryCache(); // Adds a default in-memory implementation of IDistributedCache
services.AddSession();

// Add MVC services to the services container.

services.AddMvc();

services.AddDistributedMemoryCache(); // Adds a default in-memory implementation of IDistributedCache

services.AddSession();

Next, we’ll tell ASP.NET Core to use a Memory Cache to store the session data. Add the UseSession() call below to the Configure(IApplicationBulider app, ...)

// IMPORTANT: This session call MUST go before UseMvc()
app.UseSession();

// Add MVC to the request pipeline.
app.UseMvc(routes =&gt;
{
    routes.MapRoute(
        name: "default",
        template: "{controller=Home}/{action=Index}/{id?}");
});

// IMPORTANT: This session call MUST go before UseMvc()

app.UseSession();

// Add MVC to the request pipeline.

app.UseMvc(routes =>

{

routes.MapRoute(

name: "default",

template: "{controller=Home}/{action=Index}/{id?}");

});

Where’s the Session variable gone?

Relax it’s still there, just not where you think it is. You can now find the session object by using HttpContext.Session. HttpContext is just the current HttpContext exposed to you by the Controller class.

If you’re not in a controller, you can still access the HttpContext by injecting IHttpContextAccessor.

Let’s go ahead and add sessions to our Home Controller:

using Microsoft.AspNetCore.Http; // Needed for the SetString and GetString extension methods

public class HomeController : Controller
{
    public IActionResult Index()
    { 
        HttpContext.Session.SetString("Test", "Ben Rules!");
        return View();
    }

    public IActionResult About()
    {
        ViewBag.Message = HttpContext.Session.GetString("Test");

        return View();
    }
}

using Microsoft.AspNetCore.Http; // Needed for the SetString and GetString extension methods

public class HomeController : Controller

{

public IActionResult Index()

{

HttpContext.Session.SetString("Test", "Ben Rules!");

return View();

}

public IActionResult About()

{

ViewBag.Message = HttpContext.Session.GetString("Test");

return View();

}

You’ll see the Index() and About() methods making use of the Session object. It’s pretty easy here, just use one of the Set() methods to store your data and one of the Get() methods to retrieve it.

Just for fun, let’s inject the context into a random class:

public class SomeOtherClass
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private ISession _session =&gt; _httpContextAccessor.HttpContext.Session;

    public SomeOtherClass(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }

    public void TestSet()
    {
        _session.SetString("Test", "Ben Rules!");
    }

    public void TestGet()
    {
        var message = _session.GetString("Test");
    }
}

public class SomeOtherClass

{

private readonly IHttpContextAccessor _httpContextAccessor;

private ISession _session => _httpContextAccessor.HttpContext.Session;

public SomeOtherClass(IHttpContextAccessor httpContextAccessor)

{

_httpContextAccessor = httpContextAccessor;

}

public void TestSet()

{

_session.SetString("Test", "Ben Rules!");

}

public void TestGet()

{

var message = _session.GetString("Test");

}

Let’s break this down.

Firstly I’m setting up a private variable to hold the HttpContextAccessor. This is the way you get the HttpContext now.

Next I’m adding a convenience variable as a shortcut directly to the session. Notice the =>? That means we’re using an expression body, aka a shortcut to writing a one liner method that returns something.

Moving to the contructor you can see that I’m injecting the IHttpContextAccessor and assigning it to my private variable. If you’re not sure about this whole dependency injection thing, don’t worry, it’s not hard to get the hang of (especially constructor injection like I’m using here) and it will improve your code by forcing you to write it in a modular way.

But wait a minute, how do I store a complex object?

How do I store a complex object?

I’ve got you covered here too. Here’s a quick JSON storage extension to let you store complex objects nice and simple

public static class SessionExtensions
{
    public static void SetObjectAsJson(this ISession session, string key, object value)
    {
        session.SetString(key, JsonConvert.SerializeObject(value));
    }

    public static T GetObjectFromJson&lt;T&gt;(this ISession session, string key)
    {
        var value = session.GetString(key);

        return value == null ? default(T) : JsonConvert.DeserializeObject&lt;T&gt;(value);
    }
}

public static class SessionExtensions

{

public static void SetObjectAsJson(this ISession session, string key, object value)

{

session.SetString(key, JsonConvert.SerializeObject(value));

}

public static T GetObjectFromJson<T>(this ISession session, string key)

{

var value = session.GetString(key);

return value == null ? default(T) : JsonConvert.DeserializeObject<T>(value);

}

Now you can store your complex objects like so:

var myComplexObject = new MyClass();
HttpContext.Session.SetObjectAsJson("Test", myComplexObject);

1 2	var myComplexObject = new MyClass(); HttpContext.Session.SetObjectAsJson("Test", myComplexObject);

and retrieve them just as easily:

var myComplexObject = HttpContext.Session.GetObjectFromJson&lt;MyClass&gt;("Test");

1	var myComplexObject = HttpContext.Session.GetObjectFromJson<MyClass>("Test");

Use a Redis or SQL Server Cache instead

Instead of using services.AddDistributedMemoryCache() which implements the default in-memory cache, you can use either of the following.

SQL Server
Firstly, install this nuget package:

"Microsoft.Extensions.Caching.SqlServer": "1.0.0"

Secondly, add the appropriate code snippet below:

// Microsoft SQL Server implementation of IDistributedCache.
// Note that this would require setting up the session state database.
services.AddSqlServerCache(o =&gt;
{
	o.ConnectionString = "Server=.;Database=ASPNET5SessionState;Trusted_Connection=True;";
	o.SchemaName = "dbo";
	o.TableName = "Sessions";
});

// Microsoft SQL Server implementation of IDistributedCache.

// Note that this would require setting up the session state database.

services.AddSqlServerCache(o =>

{

o.ConnectionString = "Server=.;Database=ASPNET5SessionState;Trusted_Connection=True;";

o.SchemaName = "dbo";

o.TableName = "Sessions";

});

Redis Cache
Unfortunately, the redis package does not support netcoreapp1.0 at the moment. You can still use this if you’re using net451 or higher.

"Microsoft.Extensions.Caching.Redis": "1.0.0"

// Redis implementation of IDistributedCache.
// This will override any previously registered IDistributedCache service.
services.AddSingleton&lt;IDistributedCache, RedisCache&gt;();

// Redis implementation of IDistributedCache.

// This will override any previously registered IDistributedCache service.

services.AddSingleton<IDistributedCache, RedisCache>();

Stay up to date

Even though we’ve reached RTM, you should still keep an eye on the ASP.NET Session Repository for any changes.

How To Creating and requesting SQL localized data in ASP.NET Core

CheapASPNETHostingReview.com | Best and cheap ASP.NET Core 1.0 hosting. This article shows how localized data can be created and used in a running ASP.NET Core application without restarting. The Localization.SqlLocalizer package is used to to get and localize the data, and also to save the resources to a database. Any database which is supported by Entity Framework Core can be used.

Configuring the localization

The Localization.SqlLocalizer package is configured in the Startup class in the ConfigureServices method. In this example, a SQLite database is used to store and retrieve the data. The LocalizationModelContext DbContext needs to be configured for the SQL Localization. The LocalizationModelContext class is defined inside the Localization.SqlLocalizer package.

The AddSqlLocalization extension method is used to define the services and initial the SQL localization when required. The UseTypeFullNames options is set to true, so that the Full Type names are used to retrieve the localized data. The different supported cultures are also defined as required.

public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient&lt;IProductRequestProvider, ProductRequestProvider&gt;();
    services.AddTransient&lt;IProductCudProvider, ProductCudProvider&gt;();
     
    // init database for localization
    var sqlConnectionString = Configuration["DbStringLocalizer:ConnectionString"];
 
    services.AddDbContext&lt;LocalizationModelContext&gt;(options =&gt;
        options.UseSqlite(
            sqlConnectionString,
            b =&gt; b.MigrationsAssembly("Angular2LocalizationAspNetCore")
        )
    );
 
    services.AddDbContext&lt;ProductContext&gt;(options =&gt;
      options.UseSqlite( sqlConnectionString )
    );
 
    // Requires that LocalizationModelContext is defined
    services.AddSqlLocalization(options =&gt; options.UseTypeFullNames = true);
     
    services.Configure&lt;RequestLocalizationOptions&gt;(
        options =&gt;
            {
                var supportedCultures = new List&lt;CultureInfo&gt;
                {
                    new CultureInfo("en-US"),
                    new CultureInfo("de-CH"),
                    new CultureInfo("fr-CH"),
                    new CultureInfo("it-CH")
                };
 
                options.DefaultRequestCulture = new RequestCulture(culture: "en-US", uiCulture: "en-US");
                options.SupportedCultures = supportedCultures;
                options.SupportedUICultures = supportedCultures;
            });
             
    services.AddMvc()
        .AddViewLocalization()
        .AddDataAnnotationsLocalization();
}

public void ConfigureServices(IServiceCollection services)

{

services.AddTransient<IProductRequestProvider, ProductRequestProvider>();

services.AddTransient<IProductCudProvider, ProductCudProvider>();

// init database for localization

var sqlConnectionString = Configuration["DbStringLocalizer:ConnectionString"];

services.AddDbContext<LocalizationModelContext>(options =>

options.UseSqlite(

sqlConnectionString,

b => b.MigrationsAssembly("Angular2LocalizationAspNetCore")

)

);

services.AddDbContext<ProductContext>(options =>

options.UseSqlite( sqlConnectionString )

);

// Requires that LocalizationModelContext is defined

services.AddSqlLocalization(options => options.UseTypeFullNames = true);

services.Configure<RequestLocalizationOptions>(

options =>

{

var supportedCultures = new List<CultureInfo>

{

new CultureInfo("en-US"),

new CultureInfo("de-CH"),

new CultureInfo("fr-CH"),

new CultureInfo("it-CH")

};

options.DefaultRequestCulture = new RequestCulture(culture: "en-US", uiCulture: "en-US");

options.SupportedCultures = supportedCultures;

options.SupportedUICultures = supportedCultures;

});

services.AddMvc()

.AddViewLocalization()

.AddDataAnnotationsLocalization();

}

The UseRequestLocalization is used to define the localization in the Startup Configure method.

var locOptions = app.ApplicationServices.GetService&lt;IOptions&lt;RequestLocalizationOptions&gt;&gt;();
app.UseRequestLocalization(locOptions.Value);

1 2	var locOptions = app.ApplicationServices.GetService<IOptions<RequestLocalizationOptions>>(); app.UseRequestLocalization(locOptions.Value);

The database also needs to be created. This can be done using Entity Framework Core migrations.

&gt;
&gt; dotnet ef migrations add LocalizationMigrations --context LocalizationModelContext
&gt;
&gt; dotnet ef database update --context LocalizationModelContext
&gt;

> dotnet ef migrations add LocalizationMigrations --context LocalizationModelContext

> dotnet ef database update --context LocalizationModelContext

Now the SQL Localization is ready to use.

Saving the localized data

The application creates products with localized data using the ShopAdmin API. A test method AddTestData is used to add dummy data to the database and call the provider logic. This will later be replaced by an Angular 2 form component in the third part of this series.

using Angular2LocalizationAspNetCore.Models;
using Angular2LocalizationAspNetCore.Providers;
using Angular2LocalizationAspNetCore.ViewModels;
using Microsoft.AspNetCore.Mvc;
 
namespace Angular2LocalizationAspNetCore.Controllers
{
    [Route("api/[controller]")]
    public class ShopAdminController : Controller
    {
        private readonly IProductCudProvider _productCudProvider;
 
        public ShopAdminController(IProductCudProvider productCudProvider)
        {
            _productCudProvider = productCudProvider;
        }
 
        //[HttpGet("{id}")]
        //public IActionResult Get(long id)
        //{
        //    return Ok(_productCudProvider.GetProductCudProvider(id));
        //}
 
        [HttpPost]
        public void Post([FromBody]ProductCreateEditDto value)
        {
            _productCudProvider.AddProduct(value);
        }
 
        // Test method to add data
        // http://localhost:5000/api/ShopAdmin/AddTestData/description/name
        [HttpGet]
        [Route("AddTestData/{description}/{name}")]
        public IActionResult AddTestData(string description, string name)
        {
            var product = new ProductCreateEditDto
            {
                Description = description,
                Name = name,
                ImagePath = "",
                PriceCHF = 2.40,
                PriceEUR = 2.20,
                LocalizationRecords = new System.Collections.Generic.List&lt;Models.LocalizationRecordDto&gt;
                {
                    new LocalizationRecordDto { Key= description, LocalizationCulture = "de-CH", Text = $"{description} de-CH" },
                    new LocalizationRecordDto { Key= description, LocalizationCulture = "it-CH", Text = $"{description} it-CH" },
                    new LocalizationRecordDto { Key= description, LocalizationCulture = "fr-CH", Text = $"{description} fr-CH" },
                    new LocalizationRecordDto { Key= description, LocalizationCulture = "en-US", Text = $"{description} en-US" },
                    new LocalizationRecordDto { Key= name, LocalizationCulture = "de-CH", Text = $"{name} de-CH" },
                    new LocalizationRecordDto { Key= name, LocalizationCulture = "it-CH", Text = $"{name} it-CH" },
                    new LocalizationRecordDto { Key= name, LocalizationCulture = "fr-CH", Text = $"{name} fr-CH" },
                    new LocalizationRecordDto { Key= name, LocalizationCulture = "en-US", Text = $"{name} en-US" }
                }
            };
            _productCudProvider.AddProduct(product);
            return Ok("completed");
        }
    }
}

using Angular2LocalizationAspNetCore.Models;

using Angular2LocalizationAspNetCore.Providers;

using Angular2LocalizationAspNetCore.ViewModels;

using Microsoft.AspNetCore.Mvc;

namespace Angular2LocalizationAspNetCore.Controllers

{

[Route("api/[controller]")]

public class ShopAdminController : Controller

{

private readonly IProductCudProvider _productCudProvider;

public ShopAdminController(IProductCudProvider productCudProvider)

{

_productCudProvider = productCudProvider;

}

//[HttpGet("{id}")]

//public IActionResult Get(long id)

//{

// return Ok(_productCudProvider.GetProductCudProvider(id));

//}

[HttpPost]

public void Post([FromBody]ProductCreateEditDto value)

{

_productCudProvider.AddProduct(value);

}

// Test method to add data

// http://localhost:5000/api/ShopAdmin/AddTestData/description/name

[HttpGet]

[Route("AddTestData/{description}/{name}")]

public IActionResult AddTestData(string description, string name)

{

var product = new ProductCreateEditDto

{

Description = description,

Name = name,

ImagePath = "",

PriceCHF = 2.40,

PriceEUR = 2.20,

LocalizationRecords = new System.Collections.Generic.List<Models.LocalizationRecordDto>

{

new LocalizationRecordDto { Key= description, LocalizationCulture = "de-CH", Text = $"{description} de-CH" },

new LocalizationRecordDto { Key= description, LocalizationCulture = "it-CH", Text = $"{description} it-CH" },

new LocalizationRecordDto { Key= description, LocalizationCulture = "fr-CH", Text = $"{description} fr-CH" },

new LocalizationRecordDto { Key= description, LocalizationCulture = "en-US", Text = $"{description} en-US" },

new LocalizationRecordDto { Key= name, LocalizationCulture = "de-CH", Text = $"{name} de-CH" },

new LocalizationRecordDto { Key= name, LocalizationCulture = "it-CH", Text = $"{name} it-CH" },

new LocalizationRecordDto { Key= name, LocalizationCulture = "fr-CH", Text = $"{name} fr-CH" },

new LocalizationRecordDto { Key= name, LocalizationCulture = "en-US", Text = $"{name} en-US" }

}

};

_productCudProvider.AddProduct(product);

return Ok("completed");

}

The ProductCudProvider uses the LocalizationModelContext, and the ProductCudProvider class to save the data to the database. The class creates the entities from the View model DTO and adds them to the database. Once saved the IStringExtendedLocalizerFactory interface method ResetCache is used to reset the cache of the localized data. The cache could also be reset for each Type if required.

using Angular2LocalizationAspNetCore.Models;
using Angular2LocalizationAspNetCore.Resources;
using Angular2LocalizationAspNetCore.ViewModels;
using Localization.SqlLocalizer.DbStringLocalizer;
 
namespace Angular2LocalizationAspNetCore.Providers
{
    public class ProductCudProvider : IProductCudProvider
    {
        private LocalizationModelContext _localizationModelContext;
        private ProductContext _productContext;
        private IStringExtendedLocalizerFactory _stringLocalizerFactory;
 
        public ProductCudProvider(ProductContext productContext, 
            LocalizationModelContext localizationModelContext,
            IStringExtendedLocalizerFactory stringLocalizerFactory)
        {
            _productContext = productContext;
            _localizationModelContext = localizationModelContext;
            _stringLocalizerFactory = stringLocalizerFactory;
        }
 
        public void AddProduct(ProductCreateEditDto product)
        {
            var productEntity = new Product
            {
                Description = product.Description,
                ImagePath = product.ImagePath,
                Name = product.Name,
                PriceCHF = product.PriceCHF,
                PriceEUR = product.PriceEUR
            };
            _productContext.Products.Add(productEntity);
 
            _productContext.SaveChanges();
 
            foreach(var record in product.LocalizationRecords)
            {
                _localizationModelContext.Add(new LocalizationRecord
                {
                    Key = $"{productEntity.Id}.{record.Key}",
                    Text = record.Text,
                    LocalizationCulture = record.LocalizationCulture,
                    ResourceKey = typeof(ShopResource).FullName
                });
            }
 
            _localizationModelContext.SaveChanges();
            _stringLocalizerFactory.ResetCache();
        }
    }
}

using Angular2LocalizationAspNetCore.Models;

using Angular2LocalizationAspNetCore.Resources;

using Angular2LocalizationAspNetCore.ViewModels;

using Localization.SqlLocalizer.DbStringLocalizer;

namespace Angular2LocalizationAspNetCore.Providers

{

public class ProductCudProvider : IProductCudProvider

{

private LocalizationModelContext _localizationModelContext;

private ProductContext _productContext;

private IStringExtendedLocalizerFactory _stringLocalizerFactory;

public ProductCudProvider(ProductContext productContext,

LocalizationModelContext localizationModelContext,

IStringExtendedLocalizerFactory stringLocalizerFactory)

{

_productContext = productContext;

_localizationModelContext = localizationModelContext;

_stringLocalizerFactory = stringLocalizerFactory;

}

public void AddProduct(ProductCreateEditDto product)

{

var productEntity = new Product

{

Description = product.Description,

ImagePath = product.ImagePath,

Name = product.Name,

PriceCHF = product.PriceCHF,

PriceEUR = product.PriceEUR

};

_productContext.Products.Add(productEntity);

_productContext.SaveChanges();

foreach(var record in product.LocalizationRecords)

{

_localizationModelContext.Add(new LocalizationRecord

{

Key = $"{productEntity.Id}.{record.Key}",

Text = record.Text,

LocalizationCulture = record.LocalizationCulture,

ResourceKey = typeof(ShopResource).FullName

});

}

_localizationModelContext.SaveChanges();

_stringLocalizerFactory.ResetCache();

}

Requesting the localized data

The Shop API is used to request the product data with the localized fields. The GetAvailableProducts method returns all products localized in the current culture.

using Angular2LocalizationAspNetCore.Providers;
using Microsoft.AspNetCore.Mvc;
namespace Angular2LocalizationAspNetCore.Controllers
{
    [Route("api/[controller]")]
    public class ShopController : Controller
    {
        private readonly IProductRequestProvider _productRequestProvider;
        public ShopController(IProductRequestProvider productProvider)
        {
            _productRequestProvider = productProvider;
        }
        // http://localhost:5000/api/shop/AvailableProducts
        [HttpGet("AvailableProducts")]
        public IActionResult GetAvailableProducts()
        {
            return Ok(_productRequestProvider.GetAvailableProducts());
        }
    }
}

using Angular2LocalizationAspNetCore.Providers;

using Microsoft.AspNetCore.Mvc;

namespace Angular2LocalizationAspNetCore.Controllers

{

[Route("api/[controller]")]

public class ShopController : Controller

{

private readonly IProductRequestProvider _productRequestProvider;

public ShopController(IProductRequestProvider productProvider)

{

_productRequestProvider = productProvider;

}

// http://localhost:5000/api/shop/AvailableProducts

[HttpGet("AvailableProducts")]

public IActionResult GetAvailableProducts()

{

return Ok(_productRequestProvider.GetAvailableProducts());

}

The ProductRequestProvider is used to get the data from the database. Each product description and name are localized. The Localization data is retrieved from the database for the first request, and then read from the cache, unless the localization data was updated. The IStringLocalizer is used to localize the data.

using System;
using System.Collections.Generic;
using System.Linq;
using Angular2LocalizationAspNetCore.Models;
using Angular2LocalizationAspNetCore.Resources;
using Angular2LocalizationAspNetCore.ViewModels;
using Localization.SqlLocalizer.DbStringLocalizer;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Localization;
 
namespace Angular2LocalizationAspNetCore.Providers
{
    public class ProductRequestProvider : IProductRequestProvider
    {
        private IStringLocalizer _stringLocalizer;
        private IStringExtendedLocalizerFactory _stringLocalizerFactory;
        private ProductContext _productContext;
 
        public ProductRequestProvider(IStringExtendedLocalizerFactory stringLocalizerFactory,
            ProductContext productContext)
        {
            _stringLocalizerFactory = stringLocalizerFactory;
            _stringLocalizer = _stringLocalizerFactory.Create(typeof(ShopResource));
            _productContext = productContext;
        }
 
        public List&lt;ProductDto&gt; GetAvailableProducts()
        {
            var products = _productContext.Products.OrderByDescending(dataEventRecord =&gt; EF.Property&lt;DateTime&gt;(dataEventRecord, "UpdatedTimestamp")).ToList(); 
            List&lt;ProductDto&gt; data = new List&lt;ProductDto&gt;();
            foreach(var t in products)
            {
                data.Add(new ProductDto() {
                    Id = t.Id,
                    Description = _stringLocalizer[$"{t.Id}.{t.Description}"],
                    Name = _stringLocalizer[$"{t.Id}.{t.Name}"],
                    ImagePath = t.ImagePath,
                    PriceCHF = t.PriceCHF,
                    PriceEUR = t.PriceEUR
                });
            }
 
            return data;
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using Angular2LocalizationAspNetCore.Models;

using Angular2LocalizationAspNetCore.Resources;

using Angular2LocalizationAspNetCore.ViewModels;

using Localization.SqlLocalizer.DbStringLocalizer;

using Microsoft.EntityFrameworkCore;

using Microsoft.Extensions.Localization;

namespace Angular2LocalizationAspNetCore.Providers

{

public class ProductRequestProvider : IProductRequestProvider

{

private IStringLocalizer _stringLocalizer;

private IStringExtendedLocalizerFactory _stringLocalizerFactory;

private ProductContext _productContext;

public ProductRequestProvider(IStringExtendedLocalizerFactory stringLocalizerFactory,

ProductContext productContext)

{

_stringLocalizerFactory = stringLocalizerFactory;

_stringLocalizer = _stringLocalizerFactory.Create(typeof(ShopResource));

_productContext = productContext;

}

public List<ProductDto> GetAvailableProducts()

{

var products = _productContext.Products.OrderByDescending(dataEventRecord => EF.Property<DateTime>(dataEventRecord, "UpdatedTimestamp")).ToList();

List<ProductDto> data = new List<ProductDto>();

foreach(var t in products)

{

data.Add(new ProductDto() {

Id = t.Id,

Description = _stringLocalizer[$"{t.Id}.{t.Description}"],

Name = _stringLocalizer[$"{t.Id}.{t.Name}"],

ImagePath = t.ImagePath,

PriceCHF = t.PriceCHF,

PriceEUR = t.PriceEUR

});

}

return data;

}

The products with localized data can now be added and updated without restarting the application and using the standard ASP.NET Core localization.