Develop Reference

How to solve this error with my services ASP.NET Core 6

I get this error when I start my app:
System.AggregateException: 'Some services are not able to be constructed (Error while validating the service descriptor 'ServiceType: Data.Access.Layer.Interfaces.IUnitOfWork Lifetime: Scoped ImplementationType: Data.Access.Layer.Repositories.UnitOfWork': Unable to resolve service for type 'Data.Access.Layer.EFContext' while attempting to activate 'Data.Access.Layer.Repositories.UnitOfWork'.)'
My code:
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
public interface IUnitOfWork: IDisposable
{
IGenericRepository<ApplicationUser> Users { get; }
IGenericRepository<Painting> Paintings { get; }
IGenericRepository<OrderItem> OrdersItems { get; }
IGenericRepository<Order> Orders { get; }
IGenericRepository<ShoppingCartItem> ShoppingCartItems { get; }
}
public class UnitOfWork : IUnitOfWork
{
private readonly EFContext _eFContext;
private GenericRepository<ApplicationUser> _users;
private GenericRepository<Painting> _paintings;
private GenericRepository<Order> _orders;
private GenericRepository<OrderItem> _ordersItems;
private GenericRepository<ShoppingCartItem> _shoppingCartItems;
public UnitOfWork(EFContext eFContext)
{
_eFContext = eFContext;
}
public IGenericRepository<ApplicationUser> Users => _users ??= new GenericRepository<ApplicationUser>(_eFContext);
public IGenericRepository<Painting> Paintings => _paintings ??= new GenericRepository<Painting>(_eFContext);
public IGenericRepository<Order> Orders => _orders??= new GenericRepository<Order>(_eFContext);
public IGenericRepository<OrderItem> OrdersItems => _ordersItems ??= new GenericRepository<OrderItem>(_eFContext);
public IGenericRepository<ShoppingCartItem> ShoppingCartItems => _shoppingCartItems ??= new GenericRepository<ShoppingCartItem>(_eFContext);
private bool disposed = false;
public virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
_eFContext.Dispose();
}
this.disposed = true;
}
}
void IDisposable.Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
using AutoMapper;
using Business.Layer.Interfaces;
using Business.Layer.Services;
using Data.Access.Layer.Entities;
using Data.Access.Layer.Interfaces;
using Data.Access.Layer.Repositories;
using Presentation.Layer.Mapping;
var builder = WebApplication.CreateBuilder(args);
//Add services to the container.
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();
builder.Services.AddAutoMapper(typeof(AutoMapperProfile).Assembly, typeof(BLAutoMapperProfile).Assembly);
var app = builder.Build();
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.UseRouting();
app.UseAuthorization();
app.MapRazorPages();
app.Run();

I'd like to call your attention to this part of your error message, because it tells you exactly what the problem is:
Unable to resolve service for type 'Data.Access.Layer.EFContext' while attempting to activate 'Data.Access.Layer.Repositories.UnitOfWork'.)
This tells you that the dependency injection container tried to create an instance of UnitOfWork, but was unable to do so, because that class has a dependency on EFContext, which was not registered with the container.
Your UnitOfWork class is registered here:
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
It basically means "hey, container, when I ask you for an IUnitOfWork, you should provide me with an instance of UnitOfWork".
But, as mentioned, UnitOfWork has a dependency:
public UnitOfWork(EFContext eFContext)
{
_eFContext = eFContext;
}
To get an instance of UnitOfWork, you need an instance of EFContext. When the container realizes this, it's going to check if EFContext has been registered with the container. But you haven't told the container about EFContext, so it has no way to provide you with a UnitOfWork.
To solve the error, you need to inform the container that you have something called EFContext. For an Entity Framework DbContext, this is usually done with the AddDbContext extension method:
builder.Services.AddDbContext<EFContext>();
You might also need to pass some options to this method, depending on how you're configuring your context.
Here's a few documentation links that goes more in depth:
https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection
https://learn.microsoft.com/en-us/ef/core/dbcontext-configuration/

.NET 6 - Inject service into program.cs

I know how to do dependency injection in the Startup.cs in .NET 5 (or before), but how do I do the same with the top-level Program.cs in .NET 6?
.NET 5: for example, I can inject a class in the Configure method
public class Startup
{
public IConfiguration _configuration { get; }
public IWebHostEnvironment _env { get; set; }
public Startup(IConfiguration configuration, IWebHostEnvironment env)
{
_configuration = configuration;
_env = env;
}
public void ConfigureServices(IServiceCollection services)
{
// TODO
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IToInjectService serviceToInject)
{
// USE SERVICE
}
}
How can I achieve this in .NET 6?

Using .Net 6 is easy. Just execute GetService method after configure app services and have ran Build method.
WebApplication? app = builder.Build();
var someService = app.Services.GetService<SomeService>();
someService.DoSomething();

You add your service to the builder.Services collection and then access it with
var myService = services.BuildServiceProvider().GetService<MyService>();

Inside the program.cs file you can manage your services by builder.Services
For example, I added DbContext and Two different services based on the Singleton pattern and Scoped
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddDbContext<MyDbContext>(options =>
{
// options.UseSqlServer(...);
});
builder.Services.AddSingleton<IMyService, MyService>();
builder.Services.AddScoped<IMySessionBasedService, MySessionBasedService>();
For more information check Code samples migrated to the new minimal hosting model in ASP.NET Core 6.0

If you need to use a scoped service at start, this is how your program.cs should looks like:
var builder = WebApplication.CreateBuilder(args);
//Add the service
builder.Services.AddScoped<IMyDependency, MyDependency>();
var app = builder.Build();
using (var serviceScope = app.Services.CreateScope())
{
var services = serviceScope.ServiceProvider;
var myDependency = services.GetRequiredService<IMyDependency>();
//Use the service
myDependency.DoSomething();
}
app.Run();
from:
Resolve a service at app start up
it did work for mi DbInitializer

I tried to use the GetService method but I pass the service interface type as input (as shown below) and this worked with me.
var app = builder.Build();
var injectedService1 = app.Services.GetService<IToInjectService>();
injectedService1.DoSomething();

aspnetcore - How to Access Injection inside the "Configure" Method?

In Asp.net core, inside the Startup class, I configured a class AccountService as an injection inside this method:
public void ConfigureServices(IServiceCollection services)
{
...
services.AddScoped(typeof(CharacterService));
}
I can successfully inject it on another class, but I want to also access CharacterService inside the Configure() method of Startup, because I want to call a method on the event of shut down of the server. Is it possible?
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IHostApplicationLifetime hostApplicationLifetime)
{
...
// var temp = app.ApplicationServices.GetService<CharacterService>();
hostApplicationLifetime.ApplicationStopping.Register(() =>
{
//CharacterService.Instance.SaveMemoryInDatabase();
});
}
How can I access CharacterService inside the Configure method?
Thanks,

You can access service using app.ApplicationServices.
In some cases you need to create a scope for services that are added scoped or transient. It often depends on where they were added. In case of the normal setup through ConfigureServices you need to create a scope. (Another place where services can be added is the host builder, which is often in the Program class.)
public void ConfigureServices(IServiceCollection services)
{
...
services.AddScoped<CharacterService>();
}
public void Configure(IApplicationBuilder app,
IWebHostEnvironment env,
IHostApplicationLifetime hostApplicationLifetime)
{
using var scope = app.ApplicationServices.CreateScope();
var characterService = scope.ServiceProvider.GetRequiredService<CharacterService>();
hostApplicationLifetime.ApplicationStopping.Register(() =>
{
characterService.Instance.SaveMemoryInDatabase();
});
}
CreateScope returns an IServiceScope which is disposable. All IDisposable services that are created for a scope, such as scoped and transient services, will be disposed when the IServiceScope is disposed.

How to get HttpContext.Current in ASP.NET Core? [duplicate]

This question already has answers here:
Access the current HttpContext in ASP.NET Core
(7 answers)
Closed 6 years ago.
We are currently rewriting/converting our ASP.NET WebForms application using ASP.NET Core. Trying to avoid re-engineering as much as possible.
There is a section where we use HttpContext in a class library to check the current state. How can I access HttpContext.Current in .NET Core 1.0?
var current = HttpContext.Current;
if (current == null)
{
// do something here
// string connection = Configuration.GetConnectionString("MyDb");
}
I need to access this in order to construct current application host.
$"{current.Request.Url.Scheme}://{current.Request.Url.Host}{(current.Request.Url.Port == 80 ? "" : ":" + current.Request.Url.Port)}";

As a general rule, converting a Web Forms or MVC5 application to ASP.NET Core will require a significant amount of refactoring.
HttpContext.Current was removed in ASP.NET Core. Accessing the current HTTP context from a separate class library is the type of messy architecture that ASP.NET Core tries to avoid. There are a few ways to re-architect this in ASP.NET Core.
HttpContext property
You can access the current HTTP context via the HttpContext property on any controller. The closest thing to your original code sample would be to pass HttpContext into the method you are calling:
public class HomeController : Controller
{
public IActionResult Index()
{
MyMethod(HttpContext);
// Other code
}
}
public void MyMethod(Microsoft.AspNetCore.Http.HttpContext context)
{
var host = $"{context.Request.Scheme}://{context.Request.Host}";
// Other code
}
HttpContext parameter in middleware
If you're writing custom middleware for the ASP.NET Core pipeline, the current request's HttpContext is passed into your Invoke method automatically:
public Task Invoke(HttpContext context)
{
// Do something with the current HTTP context...
}
HTTP context accessor
Finally, you can use the IHttpContextAccessor helper service to get the HTTP context in any class that is managed by the ASP.NET Core dependency injection system. This is useful when you have a common service that is used by your controllers.
Request this interface in your constructor:
public MyMiddleware(IHttpContextAccessor httpContextAccessor)
{
_httpContextAccessor = httpContextAccessor;
}
You can then access the current HTTP context in a safe way:
var context = _httpContextAccessor.HttpContext;
// Do something with the current HTTP context...
IHttpContextAccessor isn't always added to the service container by default, so register it in ConfigureServices just to be safe:
public void ConfigureServices(IServiceCollection services)
{
services.AddHttpContextAccessor();
// if < .NET Core 2.2 use this
//services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
// Other code...
}

Necromancing.
YES YOU CAN, and this is how.
A secret tip for those migrating large junks chunks of code:
The following method is an evil carbuncle of a hack which is actively engaged in carrying out the express work of satan (in the eyes of .NET Core framework developers), but it works:
In public class Startup
add a property
public IConfigurationRoot Configuration { get; }
And then add a singleton IHttpContextAccessor to DI in ConfigureServices.
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<Microsoft.AspNetCore.Http.IHttpContextAccessor, Microsoft.AspNetCore.Http.HttpContextAccessor>();
Then in Configure
public void Configure(
IApplicationBuilder app
,IHostingEnvironment env
,ILoggerFactory loggerFactory
)
{
add the DI Parameter IServiceProvider svp, so the method looks like:
public void Configure(
IApplicationBuilder app
,IHostingEnvironment env
,ILoggerFactory loggerFactory
,IServiceProvider svp)
{
Next, create a replacement class for System.Web:
namespace System.Web
{
namespace Hosting
{
public static class HostingEnvironment
{
public static bool m_IsHosted;
static HostingEnvironment()
{
m_IsHosted = false;
}
public static bool IsHosted
{
get
{
return m_IsHosted;
}
}
}
}
public static class HttpContext
{
public static IServiceProvider ServiceProvider;
static HttpContext()
{ }
public static Microsoft.AspNetCore.Http.HttpContext Current
{
get
{
// var factory2 = ServiceProvider.GetService<Microsoft.AspNetCore.Http.IHttpContextAccessor>();
object factory = ServiceProvider.GetService(typeof(Microsoft.AspNetCore.Http.IHttpContextAccessor));
// Microsoft.AspNetCore.Http.HttpContextAccessor fac =(Microsoft.AspNetCore.Http.HttpContextAccessor)factory;
Microsoft.AspNetCore.Http.HttpContext context = ((Microsoft.AspNetCore.Http.HttpContextAccessor)factory).HttpContext;
// context.Response.WriteAsync("Test");
return context;
}
}
} // End Class HttpContext
}
Now in Configure, where you added the IServiceProvider svp, save this service provider into the static variable "ServiceProvider" in the just created dummy class System.Web.HttpContext (System.Web.HttpContext.ServiceProvider)
and set HostingEnvironment.IsHosted to true
System.Web.Hosting.HostingEnvironment.m_IsHosted = true;
this is essentially what System.Web did, just that you never saw it (I guess the variable was declared as internal instead of public).
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IServiceProvider svp)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
ServiceProvider = svp;
System.Web.HttpContext.ServiceProvider = svp;
System.Web.Hosting.HostingEnvironment.m_IsHosted = true;
app.UseCookieAuthentication(new CookieAuthenticationOptions()
{
AuthenticationScheme = "MyCookieMiddlewareInstance",
LoginPath = new Microsoft.AspNetCore.Http.PathString("/Account/Unauthorized/"),
AccessDeniedPath = new Microsoft.AspNetCore.Http.PathString("/Account/Forbidden/"),
AutomaticAuthenticate = true,
AutomaticChallenge = true,
CookieSecure = Microsoft.AspNetCore.Http.CookieSecurePolicy.SameAsRequest
, CookieHttpOnly=false
});
Like in ASP.NET Web-Forms, you'll get a NullReference when you're trying to access a HttpContext when there is none, such as it used to be in Application_Start in global.asax.
I stress again, this only works if you actually added
services.AddSingleton<Microsoft.AspNetCore.Http.IHttpContextAccessor, Microsoft.AspNetCore.Http.HttpContextAccessor>();
like I wrote you should.
Welcome to the ServiceLocator pattern within the DI pattern ;)
For risks and side effects, ask your resident doctor or pharmacist - or study the sources of .NET Core at github.com/aspnet, and do some testing.
Perhaps a more maintainable method would be adding this helper class
namespace System.Web
{
public static class HttpContext
{
private static Microsoft.AspNetCore.Http.IHttpContextAccessor m_httpContextAccessor;
public static void Configure(Microsoft.AspNetCore.Http.IHttpContextAccessor httpContextAccessor)
{
m_httpContextAccessor = httpContextAccessor;
}
public static Microsoft.AspNetCore.Http.HttpContext Current
{
get
{
return m_httpContextAccessor.HttpContext;
}
}
}
}
And then calling HttpContext.Configure in Startup->Configure
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IServiceProvider svp)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
System.Web.HttpContext.Configure(app.ApplicationServices.
GetRequiredService<Microsoft.AspNetCore.Http.IHttpContextAccessor>()
);

There is a solution to this if you really need a static access to the current context.
In Startup.Configure(….)
app.Use(async (httpContext, next) =>
{
CallContext.LogicalSetData("CurrentContextKey", httpContext);
try
{
await next();
}
finally
{
CallContext.FreeNamedDataSlot("CurrentContextKey");
}
});
And when you need it you can get it with :
HttpContext context = CallContext.LogicalGetData("CurrentContextKey") as HttpContext;
I hope that helps. Keep in mind this workaround is when you don’t have a choice. The best practice is to use de dependency injection.

Asp.Net Core - Need to access to HttpContext instance from instances generated without Dependency Injection

I'm using Asp.Net Core RC1, and I've to access to an HttpContext instance from instances generated by a model generator (from interceptors of Castle.Core, for be exact). Model generator has to be a single instance through the entire application.
I need to create an instance of ModelGenerator into startup file, because it is used into static lambdas needed to configure some serializers. Serializers are statically registered, so I have to write into startup:
var modelGenerator = new ModelGenerator();
Serializers.Configure(modelGenerator); // static use of model generator instance
I also add modelGenerator as singleton instance for other uses with DI.
services.AddInstance<IModelGenerator>(modelGenerator);
What I would have done with DI is to take a IHttpContextAccessor interface from ModelGenerator's constructor, but into this context I can't because I don't have an instance on startup. I need something like a ServiceLocator to call from ModelGenerator, or some other patter that I ignore.
How can reach an updated HttpContext instance, with information of current request, from interceptors generated by ModelGenerator?

It appears that there is no way to get an instance of HttpContext in application startup. This makes sense - in previous versions of MVC this wasn't possible in IIS integrated mode or OWIN.
So what you have are 2 issues:
How do you get the IHttpContextAccessor into your serializer?
How do you ensure the HttpContext is not accessed until it is available?
The first issue is pretty straightforward. You just need to use constructor injection on IHttpContextAccessor.
public interface ISerializer
{
void Test();
}
public class ModelGenerator : ISerializer
{
private readonly IHttpContextAccessor httpContextAccessor;
public ModelGenerator(IHttpContextAccessor httpContextAccessor)
{
this.httpContextAccessor = httpContextAccessor;
}
public void Test()
{
var context = this.httpContextAccessor.HttpContext;
// Use the context
}
}
And to register...
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Other code...
// Add the model generator
services.AddTransient<ISerializer, ModelGenerator>();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
var serializers = app.ApplicationServices.GetServices<ISerializer>();
foreach (var serializer in serializers)
{
Serializers.Configure(serializer);
}
// Other code...
}
The second issue can be resolved by moving whatever initialization calls that you require HttpContext in into a global filter.
public class SerializerFilter : IAuthorizationFilter
{
public void OnAuthorization(AuthorizationContext context)
{
// TODO: Put some kind of if condition (possibly a
// global static variable) here to ensure this
// only runs when needed.
Serializers.Test();
}
}
And to register the filter globally:
public void ConfigureServices(IServiceCollection services)
{
// Other code...
// Add the global filter for the serializer
services.AddMvc(options =>
{
options.Filters.Add(new SerializerFilter());
});
// Other code...
}
If your Serializers.Configure() method requires HttpContext to work, then you will need to move that call into the global filter.