// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
// 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.UseSwagger();
app.UseSwaggerUI(CacheProfile =>
{
CacheProfile.SwaggerEndpoint("/swagger/v1/swagger.json/", "My API V1");
});
var option = new RewriteOptions();
option.AddRedirect("^$", "swagger");
app.UseRewriter(option);
app.UseHttpsRedirection();
app.UseMvc();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.AddMvc(options =>
{
CacheProfile homeProfile = new CacheProfile();
Configuration.Bind("ResponseCache:Home", homeProfile);
options.CacheProfiles.Add("Home", homeProfile);
});
services.AddRazorPages().AddRazorRuntimeCompilation();
services.AddControllersWithViews();
//services.AddTransient<IReceiptService, AdoNetReceiptService>();
services.AddTransient <IReceiptService, EfCoreReceiptService>();
services.AddTransient <IErrorService, SwitcherErrorService>();
services.AddTransient <IDatabaseManager, SqliteDatabaseManager>();
services.AddTransient <IChachedReceiptService, MemoryCachedReceiptService>();
//services.AddScoped<ScontriniWebAppDbContext>();
services.AddDbContextPool <ScontriniWebAppDbContext>(optionsBuilder =>
{
optionsBuilder.UseSqlite(Configuration.GetConnectionString("Default"));
});
//----------- Options
services.Configure <ReceiptsOptions>(Configuration.GetSection("Receipts"));
services.Configure <CacheOptions>(Configuration.GetSection("Cache"));
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.AddMvc(options =>
{
var homeProfile = new CacheProfile();
//homeProfile.Duration = Configuration.GetValue<int>("ResponseCache:Home:Duration");
//homeProfile.Location = Configuration.GetValue<ResponseCacheLocation>("ResponseCache:Home:Location");
//homeProfile.VaryByQueryKeys = new string[] { "page" };
Configuration.Bind("ResponseCache:Home", homeProfile);
options.CacheProfiles.Add("Home", homeProfile);
}).SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddTransient <ICourseService, AdoNetCourseService>();
//services.AddTransient<ICourseService, EfCoreCourseService>();
services.AddTransient <IDatabaseAccessor, SqliteDatabaseAccessor>();
services.AddTransient <ICachedCourseService, MemoryCacheCourseService>();
services.AddDbContextPool <MyCourseDbContext>(optionsBuilder => {
string connectionString = Configuration.GetSection("ConnectionStrings").GetValue <string>("Default");
optionsBuilder.UseSqlite(connectionString);
});
//Options
services.Configure <CoursesOptions>(Configuration.GetSection("Courses"));
services.Configure <ConnectionStringsOptions>(Configuration.GetSection("ConnectionStrings"));
services.Configure <MemoryCacheOptions>(Configuration.GetSection("MemoryCache"));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.AddMvc(options =>
{
var homeProfile = new CacheProfile();
Configuration.Bind("ResponseCache:Home", homeProfile);
options.CacheProfiles.Add("Home", homeProfile);
}).SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
// Usiamo AdoNet o EF per l'accesso ai dati?
services.AddTransient <ICourseService, AdoNetCourseService>();
// services.AddTransient<ICourseService, EFCoreCourseService>();
services.AddTransient <IDatabaseService, DatabaseService>();
services.AddTransient <ICachedCourseService, MemoryCacheCourseService>();
services.AddDbContextPool <MyCourseDbContext>(optionBuilder => {
string connectionString = Configuration.GetSection("ConnectionStrings").GetValue <string>("Default");
optionBuilder.UseSqlite(connectionString);
});
services.Configure <ConnectionStringOptions>(Configuration.GetSection("ConnectionStrings"));
services.Configure <CoursesOptions>(Configuration.GetSection("Courses"));
services.Configure <CachedLifeOptions>(Configuration.GetSection("CachedLife"));
services.Configure <MemoryCacheOptions>(Configuration.GetSection("MemoryCache"));
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
/*PER MIDDLEWARE DI CACHING*/
services.AddResponseCaching();
/*PER MIDDLEWARE DI CACHING*/
/*SERVIZI MVC*/
services.AddMvc(option => {
option.EnableEndpointRouting = false;
var homeProfile = new CacheProfile();
configuration.Bind("ResponseCache:Home", homeProfile);
option.CacheProfiles.Add("Home", homeProfile);
});
/*SERVIZI MVC*/
/*PLACEHOLDER*/
// services.AddTransient<ICourseService, CourseService>();
/*PLACEHOLDER*/
/*ADONET*/
services.AddTransient <ICourseServiceAsync, AdoNetCourseService>();
services.AddTransient <IDatabaseAccessor, SqliteDatabaseAccessor>();
/*ADONET*/
/*CACHE*/
services.AddTransient <ICachedCourseService, MemoryCacheCourseService>();
services.Configure <MemoryCacheOptions>(configuration.GetSection("MemoryCache"));
/*CACHE*/
/*STRINGA DI CONNESSIONE AL DB*/
// string connectionStrin = Configuration.GetSection("ConnectionStrings").GetValue<string>("Default");
// string connectionStrin = Configuration.GetConnectionString("Default");
services.Configure <ConnectionStringsOptions>(configuration.GetSection("ConnectionStrings"));
/*STRINGA DI CONNESSIONE AL DB*/
/*PAGINAZIONE ED ORDINE*/
services.Configure <CoursesOptions>(configuration.GetSection("Courses"));
/*PAGINAZIONE ED ORDINE*/
}
public IEnumerable <string> Keys(CacheProfile cacheProfile, string keyPrefix)
{
ArgumentValidation.NotNull(cacheProfile, "cacheProfile");
var ret = Contents(cacheProfile, keyPrefix).Select(key => key.Split(new[] { CacheConstants.CacheItemKeyDelimiter }, StringSplitOptions.RemoveEmptyEntries)[1]);
return(ret);
}
private IEnumerable <string> Contents(CacheProfile cacheProfile, string keyPrefix = null)
{
var fullPrefix = string.Format("{0}{1}{2}", cacheProfile.ProfileName, CacheConstants.CacheItemKeyDelimiter, keyPrefix).ToLowerInvariant();
return(from cacheItem in GetMemoryCache(cacheProfile)
where cacheItem.Key != null && cacheItem.Key.StartsWith(fullPrefix)
select cacheItem.Key);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
#if DEBUG
services.AddLiveReload();
#endif
services.AddResponseCaching();
services.AddMvc(option =>
{
var homeProfile = new CacheProfile();
//homeProfile.Duration = Configuration.GetSection("ResponseCache").GetSection("Home").GetValue<int>("Duration");
//homeProfile.Location = Configuration.GetValue<ResponseCacheLocation>("ResponseCache:Home:Location");
//homeProfile.VaryByQueryKeys = new string[] { "page" };
Configuration.Bind("ResponseCache:Home", homeProfile);
option.CacheProfiles.Add("Home", homeProfile);
}).SetCompatibilityVersion(CompatibilityVersion.Latest)
#if DEBUG
.AddRazorRuntimeCompilation()
#endif
;
var persistence = Persistence.AdoNet;
switch (persistence)
{
case Persistence.AdoNet:
services.AddTransient <ICourseService, AdoNetCourseService>();
services.AddTransient <IDatabaseAccesso, SQLiteDatabaseAccesso>();
break;
case Persistence.EFCore:
services.AddTransient <ICourseService, EfCoreCourseService>();
services.AddDbContextPool <MyCourseDbContext>(option =>
{
string connectionString = Configuration.GetSection("ConnectionStrings").GetValue <string>("Default");
option.UseSqlite(connectionString);
}
);
break;
}
services.AddTransient <ICachedCourseService, MemoryCachedCourseService>();
services.AddSingleton <IErrorViewSelectorService, ErrorViewSelectorService>();
//services.AddScoped<MioCourseDbContext>();
//Options
services.Configure <ConnectionStringsOptions>(Configuration.GetSection("ConnectionStrings"));
services.Configure <CoursesOptions>(Configuration.GetSection("Courses"));
services.Configure <CachedOption>(Configuration.GetSection("CachedTime"));
//TODO: resolve problem with memorycache and EfCore
//services.Configure<MemoryCacheOptions>(Configuration.GetSection("MemoryCache"));
}
public void ApplyCacheProfile_DoesNotSetLocationOrDuration_IfNoStoreIsSet(
CacheProfile cacheProfile,
string output)
{
var context = new DefaultHttpContext();
context.ApplyCacheProfile(cacheProfile);
Assert.Equal(output, context.Response.Headers[HeaderNames.CacheControl]);
}
public void ApplyCacheProfile_CanSetCacheControlHeaders_CacheControlAndPragmaSetToOutput(
CacheProfile cacheProfile,
string output)
{
var context = new DefaultHttpContext();
context.ApplyCacheProfile(cacheProfile);
Assert.Equal(output, context.Response.Headers[HeaderNames.CacheControl]);
}
/// <summary>
/// Adds Cache-Control and Pragma HTTP headers by applying specified cache profile to the HTTP context.
/// </summary>
/// <param name="context">HTTP context.</param>
/// <param name="cacheProfile">Cache profile.</param>
/// <returns>The same HTTP context.</returns>
/// <exception cref="System.ArgumentNullException">context or cacheProfile.</exception>
public static HttpContext ApplyCacheProfile(this HttpContext context, CacheProfile cacheProfile)
{
ArgumentNullException.ThrowIfNull(context);
ArgumentNullException.ThrowIfNull(cacheProfile);
IHeaderDictionary headers = context.Response.Headers;
if (!string.IsNullOrEmpty(cacheProfile.VaryByHeader))
{
headers[HeaderNames.Vary] = cacheProfile.VaryByHeader;
}
if (cacheProfile.NoStore == true)
{
// Cache-control: no-store, no-cache is valid.
if (cacheProfile.Location == ResponseCacheLocation.None)
{
headers[HeaderNames.CacheControl] = NoStoreNoCache;
headers[HeaderNames.Pragma] = NoCache;
}
else
{
headers[HeaderNames.CacheControl] = NoStore;
}
}
else
{
string cacheControlValue;
string duration = cacheProfile.Duration.GetValueOrDefault().ToString(CultureInfo.InvariantCulture);
switch (cacheProfile.Location)
{
case ResponseCacheLocation.Any:
cacheControlValue = PublicMaxAge + duration;
break;
case ResponseCacheLocation.Client:
cacheControlValue = PrivateMaxAge + duration;
break;
case ResponseCacheLocation.None:
cacheControlValue = NoCacheMaxAge + duration;
headers[HeaderNames.Pragma] = NoCache;
break;
default:
NotImplementedException exception = new NotImplementedException($"Unknown {nameof(ResponseCacheLocation)}: {cacheProfile.Location}");
Debug.Fail(exception.ToString());
throw exception;
}
headers[HeaderNames.CacheControl] = cacheControlValue;
}
return(context);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.AddMvc(options =>
{
var homeProfile = new CacheProfile();
//homeProfile.Duration = Configuration.GetValue<int>("ResponseCache:Home:Duration");
//homeProfile.Location = Configuration.GetValue<ResponseCacheLocation>("ResponseCache:Home:Location");
//homeProfile.VaryByQueryKeys = new string[] { "page" };
Configuration.Bind("ResponseCache:Home", homeProfile);
options.CacheProfiles.Add("Home", homeProfile);
}).SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddTransient <ICourseService, AdoNetCouseService>();
//services.AddTransient<ICourseService, EFCoreCoursesService>();
services.AddTransient <IDatabaseAccessor, SqlliteDatabaseAccessor>();
services.AddTransient <ICachedCourseService, MemoryCachedCoursesService>();
services.AddAutoMapper();
//services.AddScoped<MyCourseDbContext>(); //Equivalente alla riga sotto
//services.AddDbContext<MyCourseDbContext>();
services.AddDbContextPool <MyCourseDbContext>(optionsBuilder => {
string connectionString = Configuration.GetSection("ConnectionStrings").GetValue <string>("Default");
optionsBuilder.UseSqlite(connectionString);
});
//Options
services.Configure <ConnectionStringsOptions>(Configuration.GetSection("ConnectionStrings"));
services.Configure <CachingOptions>(Configuration.GetSection("Caching"));
services.Configure <CoursesOptions>(Configuration.GetSection("Courses"));
services.Configure <MemoryCacheOptions>(Configuration.GetSection("MemoryCache"));
#region Configurazione del servizio di cache distribuita
//Se vogliamo usare Redis, ecco le istruzioni per installarlo: https://docs.microsoft.com/it-it/aspnet/core/performance/caching/distributed?view=aspnetcore-2.2#distributed-redis-cache
//Bisogna anche installare il pacchetto NuGet: Microsoft.Extensions.Caching.StackExchangeRedis
//services.AddStackExchangeRedisCache(options =>
//{
// Configuration.Bind("DistributedCache:Redis", options);
//});
//Se vogliamo usare Sql Server, ecco le istruzioni per preparare la tabella usata per la cache: https://docs.microsoft.com/it-it/aspnet/core/performance/caching/distributed?view=aspnetcore-2.2#distributed-sql-server-cache
/*services.AddDistributedSqlServerCache(options =>
* {
* Configuration.Bind("DistributedCache:SqlServer", options);
* });*/
//Se vogliamo usare la memoria, mentre siamo in sviluppo
//services.AddDistributedMemoryCache();
#endregion
}
public void Clear(CacheProfile cacheProfile, string keyPrefix = null)
{
ArgumentValidation.NotNull(cacheProfile, "cacheProfile");
var cache = GetMemoryCache(cacheProfile);
foreach (var key in Contents(cacheProfile, keyPrefix))
{
cache.Remove(key);
}
}
public void Execute_DoesNotSetLocationOrDuration_IfNoStoreIsSet(CacheProfile cacheProfile, string output)
{
// Arrange
var executor = new ResponseCacheFilterExecutor(cacheProfile);
var context = GetActionExecutingContext();
// Act
executor.Execute(context);
// Assert
Assert.Equal(output, context.HttpContext.Response.Headers["Cache-control"]);
}
public void Execute_CanSetCacheControlHeaders(CacheProfile cacheProfile, string output)
{
// Arrange
var executor = new ResponseCacheFilterExecutor(cacheProfile);
var context = GetActionExecutingContext();
// Act
executor.Execute(context);
// Assert
Assert.Equal(output, context.HttpContext.Response.Headers["Cache-control"]);
}
public void ResponseCacheCanSetVaryByHeader(CacheProfile cacheProfile, string varyOutput, string cacheControlOutput)
{
// Arrange
var executor = new ResponseCacheFilterExecutor(cacheProfile);
var context = GetActionExecutingContext();
// Act
executor.Execute(context);
// Assert
Assert.Equal(varyOutput, context.HttpContext.Response.Headers["Vary"]);
Assert.Equal(cacheControlOutput, context.HttpContext.Response.Headers["Cache-control"]);
}
/// <summary>
/// Initializes a new instance of the <see cref="SitemapService" /> class.
/// </summary>
/// <param name="cacheProfileSettings">The cache profile settings.</param>
/// <param name="loggerFactory">The logger factory.</param>
/// <param name="memoryCache">The memory cache for the application.</param>
/// <param name="urlHelper">The URL helper.</param>
public SitemapService(
IOptions <CacheProfileSettings> cacheProfileSettings,
ILoggerFactory loggerFactory,
IMemoryCache memoryCache,
IUrlHelper urlHelper)
{
CacheProfile cacheProfile = cacheProfileSettings.Options.CacheProfiles[CacheProfileName.SitemapNodes];
this.cacheSlidingExpiration = TimeSpan.FromSeconds(cacheProfile.Duration.Value);
this.logger = loggerFactory.CreateLogger <SitemapService>();
this.memoryCache = memoryCache;
this.urlHelper = urlHelper;
}
public IEnumerable <string> Keys(CacheProfile cacheProfile, string keyPrefix = null)
{
if (!_session.EnsureConnectionIsOpen())
{
return(new string[0]);
}
var prefix = keyPrefix == null ? "*" : keyPrefix.ToLowerInvariant() + "*";
var task = _session.Connection.Keys.Find(cacheProfile.CacheId, prefix);
var result = _session.Connection.Wait(task);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="SitemapService" /> class.
/// </summary>
/// <param name="cacheProfileSettings">The cache profile settings.</param>
/// <param name="distributedCache">The distributed cache for the application.</param>
/// <param name="logger">The <see cref="SitemapService"/> logger.</param>
/// <param name="urlHelper">The URL helper.</param>
public SitemapService(
IOptions <CacheProfileSettings> cacheProfileSettings,
IDistributedCache distributedCache,
ILogger <SitemapService> logger,
IUrlHelper urlHelper)
{
CacheProfile cacheProfile = cacheProfileSettings.Value.CacheProfiles[CacheProfileName.SitemapNodes];
this.cacheSlidingExpiration = TimeSpan.FromSeconds(cacheProfile.Duration.Value);
this.distributedCache = distributedCache;
this.logger = logger;
this.urlHelper = urlHelper;
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.AddMvc(options =>
{
var homeProfile = new CacheProfile();
//homeProfile.Duration = Configuration.GetValue<int>("ResponseCache:Home:Duration");
//homeProfile.Location = Configuration.GetValue<ResponseCacheLocation>("ResponseCache:Home:Location");
//homeProfile.VaryByQueryKeys = new string[] { "page" };
Configuration.Bind("ResponseCache:Home", homeProfile);
options.CacheProfiles.Add("Home", homeProfile);
options.ModelBinderProviders.Insert(0, new DecimalModelBinderProvider());
}).SetCompatibilityVersion(CompatibilityVersion.Version_3_0)
#if DEBUG
.AddRazorRuntimeCompilation()
#endif
;
//Usiamo ADO.NET o Entity Framework Core per l'accesso ai dati?
var persistence = Persistence.AdoNet;
switch (persistence)
{
case Persistence.AdoNet:
services.AddTransient <ICourseService, AdoNetCourseService>();
services.AddTransient <ILessonService, AdoNetLessonService>();
services.AddTransient <IDatabaseAccessor, SqliteDatabaseAccessor>();
break;
case Persistence.EfCore:
services.AddTransient <ICourseService, EfCoreCourseService>();
services.AddTransient <ILessonService, EfCoreLessonService>();
services.AddDbContextPool <MyCourseDbContext>(optionsBuilder => {
string connectionString = Configuration.GetSection("ConnectionStrings").GetValue <string>("Default");
optionsBuilder.UseSqlite(connectionString);
});
break;
}
services.AddTransient <ICachedCourseService, MemoryCacheCourseService>();
services.AddTransient <ICachedLessonService, MemoryCacheLessonService>();
services.AddSingleton <IImagePersister, MagickNetImagePersister>();
//Options
services.Configure <CoursesOptions>(Configuration.GetSection("Courses"));
services.Configure <ConnectionStringsOptions>(Configuration.GetSection("ConnectionStrings"));
services.Configure <MemoryCacheOptions>(Configuration.GetSection("MemoryCache"));
services.Configure <KestrelServerOptions>(Configuration.GetSection("Kestrel"));
}
private static void Configure(MvcOptions options)
{
var cacheProfile = new CacheProfile()
{
Duration = 30,
Location = ResponseCacheLocation.Any,
NoStore = false,
VaryByQueryKeys = new[] { "*" }
};
options.CacheProfiles.Add("default", cacheProfile);
options.Filters.Add <GlobalExceptionFilter>();
options.Filters.Add <DomainExceptionFilter>();
}
public void ResponseCacheCanSetVaryByQueryKeys(CacheProfile cacheProfile, string[] varyOutput, string cacheControlOutput)
{
// Arrange
var executor = new ResponseCacheFilterExecutor(cacheProfile);
var context = GetActionExecutingContext();
context.HttpContext.Features.Set <IResponseCachingFeature>(new ResponseCachingFeature());
// Acts
executor.Execute(context);
// Assert
Assert.Equal(varyOutput, context.HttpContext.Features.Get <IResponseCachingFeature>().VaryByQueryKeys);
Assert.Equal(cacheControlOutput, context.HttpContext.Response.Headers.CacheControl);
}
public void Clear(CacheProfile cacheProfile, string keyPrefix = null)
{
if (!_session.EnsureConnectionIsOpen())
{
return;
}
string[] keys = Keys(cacheProfile, keyPrefix).ToArray();
if (keys.Length > 0)
{
var task = _session.Connection.Keys.Remove(cacheProfile.CacheId, keys);
_session.Connection.Wait(task);
}
}
public void ApplyCacheProfile_SetsPragmaOnNoCache_CacheControlSetTonoStoreNoCachePragmaSetToNoCache()
{
var cacheProfile = new CacheProfile
{
Duration = 0,
Location = ResponseCacheLocation.None,
NoStore = true,
VaryByHeader = null
};
var context = new DefaultHttpContext();
context.ApplyCacheProfile(cacheProfile);
Assert.Equal("no-store,no-cache", context.Response.Headers[HeaderNames.CacheControl]);
Assert.Equal("no-cache", context.Response.Headers[HeaderNames.Pragma]);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.AddRazorPages();
services.AddMvc(options => {
var HomeProfile = new CacheProfile();
//HomeProfile.Duration = Configuration.GetValue<int>("ResponseCache:Home:Duration");
//HomeProfile.Location = Configuration.GetValue<ResponseCacheLocation>("ResponseCache:Home:Location");
//HomeProfile.VaryByQueryKeys = new string[] {"page"};
Configuration.Bind("ResponseCache:Home", HomeProfile);
options.CacheProfiles.Add("Home", HomeProfile);
}).SetCompatibilityVersion(CompatibilityVersion.Version_3_0);
//ado net
//services.AddTransient<IPasswordService, AdoNetPasswordService>();
//services.AddTransient<IDatabaseAccessor, SqLiteDatabaseAccessor>();
//ef core
services.AddDefaultIdentity <ApplicationUser>(var_Options => {
var_Options.Password.RequireDigit = true;
var_Options.Password.RequiredLength = 8;
var_Options.Password.RequireUppercase = true;
var_Options.Password.RequireLowercase = true;
var_Options.Password.RequireNonAlphanumeric = true;
var_Options.Password.RequiredUniqueChars = 4;
var_Options.SignIn.RequireConfirmedAccount = true;
})
.AddClaimsPrincipalFactory <CustomClaimsPrincipalFactory>()
.AddPasswordValidator <CommonPasswordValidator <ApplicationUser> >()
.AddEntityFrameworkStores <PasswordDbContext>();
services.AddTransient <IPasswordService, EFCorePasswordService>();
services.AddDbContextPool <PasswordDbContext>(optionsBuilder => {
String ConnectionString = Configuration.GetSection("ConnectionStrings").GetValue <String>("Default");
optionsBuilder.UseSqlite(ConnectionString);
});
services.AddTransient <ICachedPasswordService, MemoryCachedPasswordService>();
services.AddSingleton <IImagePersister, MagickNetImagePersister>();
services.AddSingleton <IEmailSender, MailKitEmailSender>();
//Options
services.Configure <MemoryCacheOptions>(Configuration.GetSection("MemoryCache"));
services.Configure <PasswordsOptions>(Configuration.GetSection("Passwords"));
services.Configure <ConnectionStringsOptions>(Configuration.GetSection("ConnectionStrings"));
services.Configure <KestrelServerOptions>(Configuration.GetSection("Kestrel"));
}
public static IServiceCollection AddMvcWithFilters(this IServiceCollection services, IConfiguration configuration)
{
var siteSettings = new SiteSettings(configuration);
services
.AddControllersWithViews(options =>
{
options.Filters.Add <SiteSettingsFilter>();
var defaultCacheProfile = new CacheProfile {
Location = ResponseCacheLocation.Any, Duration = siteSettings.DefaultCacheDuration, NoStore = siteSettings.DefaultCacheDuration <= 0
};
options.CacheProfiles.Add("Default", defaultCacheProfile);
});
return(services);
}
private MemoryCache GetMemoryCache(CacheProfile cacheProfile)
{
var cacheId = cacheProfile.CacheId;
if (!_caches.ContainsKey(cacheId))
{
lock (_caches)
{
if (!_caches.ContainsKey(cacheId))
{
_caches.Add(cacheId, new MemoryCache(cacheId.ToString()));
}
}
}
return(_caches[cacheId]);
}
/// <summary>
/// Initializes a new instance of the <see cref="SitemapService" /> class.
/// </summary>
/// <param name="cacheProfileSettings">The cache profile settings.</param>
/// <param name="distributedCache">The distributed cache for the application.</param>
/// <param name="logger">The <see cref="SitemapService"/> logger.</param>
// $Start-ApplicationInsights$
/// <param name="telemetryClient">The Azure Application Insights telemetry client.</param>
// $End-ApplicationInsights$
/// <param name="urlHelper">The URL helper.</param>
public SitemapService(
IOptions <CacheProfileSettings> cacheProfileSettings,
IDistributedCache distributedCache,
ILogger <SitemapService> logger,
// $Start-ApplicationInsights$
TelemetryClient telemetryClient,
// $End-ApplicationInsights$
IUrlHelper urlHelper)
{
CacheProfile cacheProfile = cacheProfileSettings.Value.CacheProfiles[CacheProfileName.SitemapNodes];
this.expirationDuration = TimeSpan.FromSeconds(cacheProfile.Duration.Value);
this.distributedCache = distributedCache;
this.logger = logger;
// $Start-ApplicationInsights$
this.telemetryClient = telemetryClient;
// $End-ApplicationInsights$
this.urlHelper = urlHelper;
}
/// <summary>
/// Initializes a new instance of the <see cref="SitemapService" /> class.
/// </summary>
/// <param name="cacheProfileSettings">The cache profile settings.</param>
/// <param name="distributedCache">The distributed cache for the application.</param>
/// <param name="logger">The <see cref="SitemapService"/> logger.</param>
/// <param name="urlHelper">The URL helper.</param>
public SitemapService(
IOptions <CacheProfileSettings> cacheProfileSettings,
IDistributedCache distributedCache,
ILogger <SitemapService> logger,
#if (ApplicationInsights)
TelemetryClient telemetryClient,
#endif
IUrlHelper urlHelper)
{
CacheProfile cacheProfile = cacheProfileSettings.Value.CacheProfiles[CacheProfileName.SitemapNodes];
_expirationDuration = TimeSpan.FromSeconds(cacheProfile.Duration.Value);
_distributedCache = distributedCache;
_logger = logger;
#if (ApplicationInsights)
this.telemetryClient = telemetryClient;
#endif
_urlHelper = urlHelper;
}
/// <summary>
/// Uses the static files middleware to serve static files. Also adds the Cache-Control and Pragma HTTP
/// headers. The cache duration is controlled from configuration.
/// See http://andrewlock.net/adding-cache-control-headers-to-static-files-in-asp-net-core/.
/// </summary>
public static IApplicationBuilder UseStaticFilesWithCacheControl(this IApplicationBuilder application)
{
CacheProfile cacheProfile = application
.ApplicationServices
.GetRequiredService <CacheProfileOptions>()
.Where(x => string.Equals(x.Key, CacheProfileName.StaticFiles, StringComparison.Ordinal))
.Select(x => x.Value)
.SingleOrDefault();
application.UseStaticFiles(
new StaticFileOptions()
{
OnPrepareResponse = context =>
{
context.Context.ApplyCacheProfile(cacheProfile);
},
});
return(application);
}
/// <summary>
/// Creates a new instance of <see cref="ResponseCacheFilter"/>
/// </summary>
/// <param name="cacheProfile">The profile which contains the settings for
/// <see cref="ResponseCacheFilter"/>.</param>
public ResponseCacheFilter(CacheProfile cacheProfile)
{
_cacheProfile = cacheProfile;
}
