static void Main(string[] args)
{
Console.WriteLine("Dependency Injection Demo (3)");
Console.WriteLine("Alternative implementations and Guids");
Console.WriteLine("-------------------------------------");
var services = new ServiceCollection();
services.AddSingleton <IXMLWriter, XMLWriter>();
var provider = services.BuildServiceProvider();
var XMLInstance = provider.GetService <IXMLWriter>();
XMLInstance.WriteXML();
var XMLInstance2 = ServiceProviderServiceExtensions.
GetService <IXMLWriter>(provider);
XMLInstance2.WriteXML();
// Provider via DefaultServiceProviderFactory
//var factory = new DefaultServiceProviderFactory();
//IServiceProvider prov = factory.CreateServiceProvider(services);
// Provider via ServiceCollectionContainerBuilderExtensions
//IServiceProvider prov = ServiceCollectionContainerBuilderExtensions.
// BuildServiceProvider(services);
//var XMLInstance = prov.GetService<IXMLWriter>();
//XMLInstance.WriteXML();
Console.ReadLine();
}
public override void OnActionExecuting(ActionExecutingContext context)
{
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Expected O, but got Unknown
if (CurrentUser != null)
{
HttpContext httpContext = context.HttpContext;
string text = httpContext.Request.Cookies["pc"];
if (text != null)
{
((dynamic)this.ViewBag).UserPromotionCount = text;
}
else
{
IPromotionService service = ServiceProviderServiceExtensions.GetService <IPromotionService>(httpContext.RequestServices);
Result <int> result = service.GetUserActivePromotionCount(CurrentUser.UserId).Result;
int data = result.Data;
IResponseCookies cookies = httpContext.Response.Cookies;
string text2 = data.ToString();
CookieOptions val = new CookieOptions();
val.HttpOnly = (true);
val.Secure = (true);
val.Expires = ((DateTimeOffset?)DateTime.Now.AddMinutes(1.0));
cookies.Append("pc", text2, val);
((dynamic)this.ViewBag).UserPromotionCount = data.ToString();
}
}
base.OnActionExecuting(context);
}
public JsonResult ProductInformation([Bind(Prefix = "id")] string productId)
{
var service = ServiceProviderServiceExtensions.GetService <IVisitorContext>(ServiceLocator.ServiceProvider);
var product = _arRepository.GetProductInformation(service, productId);
return(Json(product, JsonRequestBehavior.AllowGet));
}
private IShellPipeline BuildTenantPipeline()
{
V_0 = new ApplicationBuilder(ShellScope.get_Context().get_ServiceProvider(), this._features);
stackVariable7 = ServiceProviderServiceExtensions.GetService <IEnumerable <IStartupFilter> >(V_0.get_ApplicationServices());
V_1 = new ShellRequestPipeline();
V_2 = new Action <IApplicationBuilder>(this.u003cBuildTenantPipelineu003eb__6_0);
V_3 = stackVariable7.Reverse <IStartupFilter>().GetEnumerator();
try
{
while (V_3.MoveNext())
{
V_2 = V_3.get_Current().Configure(V_2);
}
}
finally
{
if (V_3 != null)
{
V_3.Dispose();
}
}
V_2.Invoke(V_0);
V_1.set_Next(V_0.Build());
return(V_1);
}
protected static string[] GetDependencies(IDatabaseRepository databaseRepository)
{
if (databaseRepository == null)
{
databaseRepository = ServiceProviderServiceExtensions.GetService <IDatabaseRepository>(ServiceLocator.ServiceProvider);
}
return((databaseRepository.GetContentDatabase().Name.ToLower() == GlobalSettings.Database.Master) ? AssetContentRefresher.MasterCacheDependencyKeys : AssetContentRefresher.WebCacheDependencyKeys);
}
public static void RegisterCache(this IServiceCollection services, IConfiguration configuration)
{
services.Configure <RedisSettings>(option =>
{
var jsonFileConfig = configuration.GetSection(nameof(RedisSettings));
option.Host = jsonFileConfig.GetValue <string>(nameof(RedisSettings.Host));
option.Password = jsonFileConfig.GetValue <string>(nameof(RedisSettings.Password));
});
services.AddSingleton <IRedisStore, RedisStore>();
services.AddSingleton <IRedisClientFactory, RedisClientFactory>();
services.AddTransient(serviceProvider => ServiceProviderServiceExtensions.GetService <IRedisClientFactory>(serviceProvider).GetDatabase());
services.AddMemoryCache(setup => { setup.ExpirationScanFrequency = TimeSpan.FromMinutes(1); });
}
public static IUserContext GetUserContext(this IServiceProvider container, IUserContext userContext)
{
IUserContext userContext1 = userContext;
try
{
if (ServiceProviderServiceExtensions.GetService <IUserContextLoader>(container) != null)
{
ServiceProviderServiceExtensions.GetService <IUserContextLoader>(container).Load(userContext1);
}
}
catch
{
}
return(userContext1);
}
/// <summary>
/// Method to clear expired persisted grants.
/// </summary>
/// <returns></returns>
public async Task RemoveExpiredGrantsAsync()
{
try
{
_logger.LogTrace("Querying for expired grants to remove");
var found = Int32.MaxValue;
using (var serviceScope = _serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
var tokenCleanupNotification = ServiceProviderServiceExtensions.GetService <IOperationalStoreNotification>(serviceScope.ServiceProvider);
{
while (found >= _options.TokenCleanupBatchSize)
{
var expired = PersistedGrants.FindAllByExpirationAndBatchSize(_options.TokenCleanupBatchSize);
found = expired.Count;
_logger.LogInformation("Removing {grantCount} grants", found);
if (found > 0)
{
try
{
expired.Delete();
if (tokenCleanupNotification != null)
{
await tokenCleanupNotification.PersistedGrantsRemovedAsync(expired);
}
}
catch (Exception ex)
{
// we get this if/when someone else already deleted the records
// we want to essentially ignore this, and keep working
_logger.LogDebug("Concurrency exception removing expired grants: {exception}", ex.Message);
}
}
}
}
}
}
catch (Exception ex)
{
_logger.LogError("Exception removing expired grants: {exception}", ex.Message);
}
}
/// <summary>
/// Uses the SQLite cache.
/// </summary>
/// <returns>The SQLite cache.</returns>
/// <param name="app">App.</param>
public static IApplicationBuilder UseLiteXSQLiteCache(this IApplicationBuilder app)
{
try
{
SqliteConnection connection = ServiceProviderServiceExtensions.GetService <ISQLiteConnectionProvider>(app.ApplicationServices).GetConnection();
if (((DbConnection)connection).State == ConnectionState.Closed)
{
((DbConnection)connection).Open();
}
SqlMapper.Execute((IDbConnection)connection, "CREATE TABLE IF NOT EXISTS [litexcache] (\r\n [ID] INTEGER PRIMARY KEY\r\n , [cachekey] TEXT\r\n , [cachevalue] TEXT\r\n , [expiration] INTEGER)", (object)null, (IDbTransaction)null, (int?)null, (CommandType?)null);
return(app);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(app);
}
}
/// <summary>
/// 记录异常日志。
/// </summary>
/// <param name="filterContext"></param>
protected virtual void LogException(ExceptionContext filterContext)
{
var controllerName = (string)filterContext.RouteData.Values["controller"];
var actionName = (string)filterContext.RouteData.Values["action"];
Tracer.Error($"Throw exception when '{controllerName}.{actionName}' is executed:\n{filterContext.Exception.Output()}");
//记录日志
#if !NETCOREAPP
var logger = LoggerFactory.CreateLogger();
#else
var logger = ServiceProviderServiceExtensions.GetService <ILogger>(filterContext.HttpContext.RequestServices);
#endif
if (logger != null)
{
logger.Error(string.Format("执行控制器 {0} 的方法 {1} 时发生错误。",
controllerName, actionName), filterContext.Exception);
}
}
public static void UseStaticCommands(this IAppBuilder builder, StaticCommandsList staticCommands)
{
builder.UsePossibleCommands();
builder.Services.TryAddSingleton(provider =>
{
ServiceProviderServiceExtensions.GetService <ILogger>(provider)
?.Debug("Loaded {Count} static commands: {Commands}",
staticCommands.StaticCommandsTypes.Count,
string.Join(", ", staticCommands.StaticCommandsTypes.Select(a => a.Name)));
return(staticCommands);
});
builder.UseMiddleware <StaticCommandsMiddleware>();
foreach (var command in staticCommands.StaticCommandsTypes)
{
builder.Services.AddScoped(command);
}
}
public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
{
if (Policy != null || (object)PolicyProvider != null)
{
return(this);
}
IAuthorizationPolicyProvider requiredService = ServiceProviderServiceExtensions.GetRequiredService <IAuthorizationPolicyProvider>(serviceProvider);
if (PolicyProvider == null)
{
PolicyProvider = ServiceProviderServiceExtensions.GetRequiredService <IAuthorizationPolicyProvider>(serviceProvider);
}
if (Policy == null)
{
Policy = AuthorizationPolicy.CombineAsync(requiredService, AuthorizeData).GetAwaiter().GetResult();
}
if (AuthorizeFilter == null)
{
AuthorizeFilter = ServiceProviderServiceExtensions.GetService <IAuthorizeFilter>(serviceProvider);
}
return(this);
}
// Big hack, tests fails if only call AddHangfire because Hangfire fail at initializing at the second test run
private void AddHangfireFix(IServiceCollection services)
{
Action <IGlobalConfiguration> configuration = o =>
{
var scope = AspNetCoreJobActivator.Current.BeginScope(null);
var options = (ApplicationDbContextFactory)scope.Resolve(typeof(ApplicationDbContextFactory));
options.ConfigureHangfireBuilder(o);
};
ServiceCollectionDescriptorExtensions.TryAddSingleton <Action <IGlobalConfiguration> >(services, (IServiceProvider serviceProvider) => new Action <IGlobalConfiguration>((config) =>
{
ILoggerFactory service = ServiceProviderServiceExtensions.GetService <ILoggerFactory>(serviceProvider);
if (service != null)
{
Hangfire.GlobalConfigurationExtensions.UseLogProvider <AspNetCoreLogProvider>(config, new AspNetCoreLogProvider(service));
}
IServiceScopeFactory service2 = ServiceProviderServiceExtensions.GetService <IServiceScopeFactory>(serviceProvider);
if (service2 != null)
{
Hangfire.GlobalConfigurationExtensions.UseActivator <AspNetCoreJobActivator>(config, new AspNetCoreJobActivator(service2));
}
configuration(config);
}));
services.AddHangfire(configuration);
services.AddCors(o =>
{
o.AddPolicy("BitpayAPI", b =>
{
b.AllowAnyMethod().AllowAnyHeader().AllowAnyOrigin();
});
});
services.Configure <IOptions <ApplicationInsightsServiceOptions> >(o =>
{
o.Value.DeveloperMode = _Env.IsDevelopment();
});
}
private IHostingEnvironment GetHostingEnvironment(ExceptionContext context)
{
return(ServiceProviderServiceExtensions.GetService <IHostingEnvironment>(context.HttpContext.RequestServices));
}
private IModelMetadataProvider GetModelMetadataProvider(ExceptionContext context)
{
return(ServiceProviderServiceExtensions.GetService <IModelMetadataProvider>(context.HttpContext.RequestServices));
}
public T GetService <T>()
{
return(ServiceProviderServiceExtensions.GetService <T>(this));
}
private static ILoggerFactory GetLoggerFactory(ExceptionContext context)
{
return(ServiceProviderServiceExtensions.GetService <ILoggerFactory>(context.HttpContext.RequestServices));
}
private IAssemblyProviderResolveCallback GetResolveCallback()
{
return(ServiceProviderServiceExtensions.GetService <IAssemblyProviderResolveCallback>(ServiceProvider));
}
private IStringLocalizer GetStringLocalizer(ExceptionContext context)
{
return(ServiceProviderServiceExtensions.GetService <IStringLocalizer>(context.HttpContext.RequestServices));
}
private IMongoUnitOfWork GetUnitOfWork(ExceptionContext context)
{
return(ServiceProviderServiceExtensions.GetService <IMongoUnitOfWork>(context.HttpContext.RequestServices));
}
public static bool IsRelational(this DatabaseFacade database)
{
return(ServiceProviderServiceExtensions.GetService <IRelationalConnection>(AccessorExtensions.GetInfrastructure(database)) != null);
}
public static IMenuItemsRenderer GetMenuItemsRenderer(ViewContext context)
{
return(ServiceProviderServiceExtensions.GetService <IMenuItemsRenderer>(context.HttpContext.RequestServices));
}
public CustomizableTaxonomyProvider()
{
_tagsSettingService = ServiceProviderServiceExtensions.GetService <ICustomTaggerSettingService>(ServiceLocator.ServiceProvider);
_tagsCategoryService = ServiceProviderServiceExtensions.GetService <ICustomizableTagCategoryService>(ServiceLocator.ServiceProvider);
_tagsEntryService = ServiceProviderServiceExtensions.GetService <ICustomizableTagEntryService>(ServiceLocator.ServiceProvider);
}
public virtual async Task OnAuthorizationAsync(AuthorizationFilterContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
AuthorizationPolicy effectivePolicy = Policy;
if (effectivePolicy == null)
{
if (PolicyProvider == null)
{
throw new InvalidOperationException("An AuthorizationPolicy cannot be created without a valid instance of IAuthorizationPolicyProvider.");
}
effectivePolicy = await AuthorizationPolicy.CombineAsync(PolicyProvider, AuthorizeData);
}
if (effectivePolicy != null)
{
MvcPrincipal newPrincipal = null;
string currentScheme = effectivePolicy.AuthenticationSchemes.FirstOrDefault();
if (!string.IsNullOrEmpty(currentScheme))
{
if (!(context.HttpContext.User.Identity is MvcIdentity) || !context.HttpContext.User.Identity.IsAuthenticated)
{
string cookie = CookieUtil.GetCookie(currentScheme, true);
if (!string.IsNullOrEmpty(cookie))
{
try
{
string value = DataProtectionUtil.UnProtect(cookie);
MvcIdentity identity = JsonExtension.GetModel <MvcIdentity>(value, "");
if (identity != null)
{
newPrincipal = identity.GetPrincipal();
}
}
catch
{
}
}
}
else
{
newPrincipal = (context.HttpContext.User as MvcPrincipal);
}
}
if (newPrincipal == null)
{
context.HttpContext.User = MvcIdentity.Instance.GetPrincipal();
}
else
{
context.HttpContext.User = newPrincipal;
}
if (!context.Filters.Any((IFilterMetadata item) => item is IAllowAnonymousFilter))
{
if (context.HttpContext.User.Identity.IsAuthenticated)
{
if (AuthorizeFilter == null)
{
AuthorizeFilter = ServiceProviderServiceExtensions.GetService <IAuthorizeFilter>(context.HttpContext.RequestServices);
}
if (AuthorizeFilter != null)
{
await AuthorizeFilter.OnAuthorizedAsync(context, currentScheme);
}
}
else
{
context.Result = new ChallengeResult(effectivePolicy.AuthenticationSchemes.ToArray());
}
}
}
}
public static IUrlHelper GetUrlHelper(ViewContext context)
{
var factory = ServiceProviderServiceExtensions.GetService <IUrlHelperFactory>(context.HttpContext.RequestServices);
return(factory.GetUrlHelper(context));
}
public Task ExecuteDbContextAsync(Func <FooContext, Task> action)
{
return(ExecuteScopeAsync(sp => action(ServiceProviderServiceExtensions.GetService <FooContext>(sp))));
}
private IHisarExceptionFilter GetHisarExceptionFilter(ExceptionContext context)
{
return(ServiceProviderServiceExtensions.GetService <IHisarExceptionFilter>(context.HttpContext.RequestServices));
}
public CustomizableTagger()
{
_settingsService = ServiceProviderServiceExtensions.GetService <ICustomTaggerSettingService>(ServiceLocator.ServiceProvider);
}
private IClaimsProvider GetClaimsProvider(ExceptionContext context)
{
return(ServiceProviderServiceExtensions.GetService <IClaimsProvider>(context.HttpContext.RequestServices));
}
private static RunningComponentHelper GetComponentHelper(IServiceProvider applicationServices)
{
return(ServiceProviderServiceExtensions.GetService <RunningComponentHelper>(applicationServices));
}