public DelegateService(IServiceScopeFactory scopeFactory, Func<IServiceProvider, CancellationToken, Task> @delegate)
{
this.scopeFactory = scopeFactory;
this.@delegate = @delegate;
}
public RequestServicesContainerMiddleware(RequestDelegate next, IServiceScopeFactory scopeFactory)
{
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
if (scopeFactory == null)
{
throw new ArgumentNullException(nameof(scopeFactory));
}
_scopeFactory = scopeFactory;
_next = next;
}
public RequestServicesFeature(IServiceScopeFactory scopeFactory)
{
if (scopeFactory == null)
{
throw new ArgumentNullException(nameof(scopeFactory));
}
_scopeFactory = scopeFactory;
}
public DebugInitializer(
ILoggerFactory logger,
IServiceProvider serviceProvider,
UserManager<ApplicationUser> userManager,
RoleManager<ApplicationRole> roleManager)
{
_logger = logger.CreateLogger(nameof(DebugInitializer));
_serviceProvider = serviceProvider;
_scopeFactory = _serviceProvider.GetRequiredService<IServiceScopeFactory>();
_userManager = userManager;
_roleManager = roleManager;
}
private bool disposedValue = false; // To detect redundant calls
#endregion Fields
#region Constructors
public RequestServicesContainer(
HttpContext context,
IServiceScopeFactory scopeFactory,
IServiceProvider appServiceProvider)
{
if (scopeFactory == null)
{
throw new ArgumentNullException(nameof(scopeFactory));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
Context = context;
PriorAppServices = context.ApplicationServices;
PriorRequestServices = context.RequestServices;
// Begin the scope
Scope = scopeFactory.CreateScope();
Context.ApplicationServices = appServiceProvider;
Context.RequestServices = Scope.ServiceProvider;
}
public GoogleDriveService(ILogger <GoogleDriveService> logger, IConfiguration configuration, IServiceScopeFactory scopeFactory)
{
_logger = logger;
ScopeFactory = scopeFactory;
Configuration = configuration;
using (var stream = new FileStream(Configuration["GoogleDriveTokenPath"], FileMode.Open, FileAccess.Read))
{
string credPath = configuration["GoogleDriveOutputCredentialPath"];
Credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
Scopes,
"user",
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
_logger.LogInformation("Google Credential file saved to {0}", credPath);
}
DriveService = new DriveService(new BaseClientService.Initializer()
{
HttpClientInitializer = Credential,
ApplicationName = ApplicationName
});
UploadFilesInfo();
}
public JobTrackerService(IServiceScopeFactory scopeFactory, UserLogger userLogger)
{
this.scopeFactory = scopeFactory;
this.userLogger = userLogger;
}
public ProviderUserRepository(IServiceScopeFactory serviceScopeFactory, IMapper mapper)
: base(serviceScopeFactory, mapper, (DatabaseContext context) => context.ProviderUsers)
{
}
public CreateTransactionHandler(ITransactionExecuteSender transactionExecuteSender, IServiceScopeFactory serviceScopeFactory)
{
_transactionExecuteSender = transactionExecuteSender;
_serviceScopeFactory = serviceScopeFactory;
}
public ScheduledProcessor(IServiceScopeFactory serviceScopeFactory) : base(serviceScopeFactory)
{
_schedule = CrontabSchedule.Parse(Schedule);
_nextRun = _schedule.GetNextOccurrence(DateTime.Now);
}
public TweetsKQueryStreamSet(IServiceScopeFactory serviceScopeFactory, QueryContext queryContext) : base(serviceScopeFactory, queryContext)
{
}
public NotificationJob(IServiceScopeFactory serviceScopeFactory)
{
_serviceScopeFactory = serviceScopeFactory;
}
public LineBotApp(LineMessagingClient lineMessagingClient, jafleetContext context, ToolsContext toolsContext, IServiceScopeFactory serviceScopeFactory)
{
this.messagingClient = lineMessagingClient;
_context = context;
_tContext = toolsContext;
_services = serviceScopeFactory;
}
internal Consumer(BusConnection connection, IBusLogger logger, IRetryBehavior retryBehavior, IServiceScopeFactory scopeFactory, ConsumerOptions <T> options)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
_connection = connection ?? throw new ArgumentNullException(nameof(connection));
_logger = logger;
_retryBehavior = retryBehavior ?? throw new ArgumentNullException(nameof(retryBehavior));
_scopeFactory = scopeFactory ?? throw new ArgumentNullException(nameof(scopeFactory));
_tasks = new Tasks(_options.ConsumerMaxParallelTasks);
_channel = connection.ConsumerConnection.CreateModel();
_channel.BasicQos(0, options.PrefetchCount, false);
DeclareAndBind();
_consumerTag = _channel.BasicConsume(_options.Queue.Name.Value, false, this);
}
/// <summary>
/// 创建一个作用域范围
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="handler"></param>
/// <param name="scopeFactory"></param>
/// <returns></returns>
public static async Task <T> CreateRef <T>(Func <IServiceScopeFactory, IServiceScope, Task <T> > handler, IServiceScopeFactory scopeFactory = default)
{
// 禁止空调用
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
// 创建作用域
using var scoped = CreateScope(ref scopeFactory);
// 执行方法
var result = await handler.Invoke(scopeFactory, scoped);
return(result);
}
/// <summary>
/// 创建一个作用域范围
/// </summary>
/// <param name="handler"></param>
/// <param name="scopeFactory"></param>
public static void Create(Action <IServiceScopeFactory, IServiceScope> handler, IServiceScopeFactory scopeFactory = default)
{
// 禁止空调用
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
// 创建作用域
using var scoped = CreateScope(ref scopeFactory);
// 执行方法
handler.Invoke(scopeFactory, scoped);
}
/// <summary>
/// 创建一个工作单元作用域
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="handler"></param>
/// <param name="scopeFactory"></param>
/// <returns></returns>
public static async Task <T> CreateUowRef <T>(Func <IServiceScopeFactory, IServiceScope, Task <T> > handler, IServiceScopeFactory scopeFactory = default)
{
// 禁止空调用
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
// 创建作用域
using var scoped = CreateScope(ref scopeFactory);
// 创建一个数据库上下文池
var dbContextPool = scoped.ServiceProvider.GetService <IDbContextPool>();
var result = await handler.Invoke(scopeFactory, scoped);
dbContextPool.SavePoolNow();
return(result);
}
/// <summary>
/// 创建一个工作单元作用域
/// </summary>
/// <param name="handler"></param>
/// <param name="scopeFactory"></param>
public static void CreateUow(Action <IServiceScopeFactory, IServiceScope> handler, IServiceScopeFactory scopeFactory = default)
{
// 禁止空调用
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
// 创建作用域
using var scoped = CreateScope(ref scopeFactory);
// 创建一个数据库上下文池
var dbContextPool = scoped.ServiceProvider.GetService <IDbContextPool>();
handler.Invoke(scopeFactory, scoped);
dbContextPool.SavePoolNow();
}
public SendEmailsTask(IServiceScopeFactory serviceScopeFactory) : base(serviceScopeFactory)
{
}
public BlockHeightTracker(IConfiguration configuration, ILoggerFactory loggerFactory, IServiceScopeFactory scopeFactory, IShareCalculator shareCalculator, IMessenger messenger)
{
_configuration = configuration;
_logger = loggerFactory.CreateLogger <BlockHeightTracker>();
_scopeFactory = scopeFactory;
_shareCalculator = shareCalculator;
_messenger = messenger;
}
// JobType = "Oqtane.Infrastructure.NotificationJob, Oqtane.Server"
public NotificationJob(IServiceScopeFactory serviceScopeFactory) : base(serviceScopeFactory)
{
}
public RabbitMqMessageBroker(IConnectionFactory connectionFactory, IServiceScopeFactory serviceScopeFactory)
{
_connection = connectionFactory.CreateConnection();
_subscriptionChannel = _connection.CreateModel();
_serviceScopeFactory = serviceScopeFactory;
}
public JwtMiddleware(RequestDelegate next, IServiceScopeFactory factory)
{
_scopeFactory = factory;
_next = next;
}
public void CreateObjectsTest()
{
IServiceCollection pool = Implementation.CreateServiceCollection();
IServiceScopeFactory factory = Implementation.CreateServiceScopeFactory(pool);
IServiceProvider services = factory.CreateScope().ServiceProvider;
try
{
object staticobj = services.CreateInstance(typeof(StaticObject), 10) as StaticObject;
Assert.Fail();
}
catch (InvalidOperationException)
{
}
try
{
IFake fakeobj = services.CreateInstance <IFake>();
Assert.Fail();
}
catch (InvalidOperationException)
{
}
try
{
AbstractObject absobj = services.CreateInstance <AbstractObject>();
Assert.Fail();
}
catch (InvalidOperationException)
{
}
try
{
PrivateObject privateobj = services.CreateInstance <PrivateObject>(5);
Assert.Fail();
}
catch (InvalidOperationException)
{
}
try
{
EnumTest enumobj = services.CreateInstance <EnumTest>();
Assert.Fail();
}
catch (InvalidOperationException)
{
}
try
{
DelegateTest delegateobj = services.CreateInstance <DelegateTest>();
Assert.Fail();
}
catch (Exception)
{
}
GenericObject <int> intgeneric = services.CreateInstance <GenericObject <int> >(10);
Assert.AreEqual(10, intgeneric.Value);
GenericObject <double> doublegeneric = services.CreateInstance <GenericObject <double> >();
Assert.AreEqual(0, doublegeneric.Value);
try
{
int[] intarray = services.CreateInstance <int[]>(10);
Assert.Fail();
}
catch (InvalidOperationException)
{
}
int inttest = services.CreateInstance <int>(5);
Assert.AreEqual(5, inttest);
StructObject structobj = services.CreateInstance <StructObject>(5);
Assert.AreEqual(5, structobj.Value);
}
public HarbourTask(ILogger <HarbourTask> logger, IServiceScopeFactory scopeFactory)
{
this.logger = logger;
this.scopeFactory = scopeFactory;
}
public SortService(IServiceScopeFactory serviceScopeFactory, ILogger <SortService> logger)
{
_serviceScopeFactory = serviceScopeFactory;
_logger = logger;
}
public TestGrainStorageConvention(
IOptions <GrainStorageConventionOptions> options, IServiceScopeFactory serviceScopeFactory) : base(options,
serviceScopeFactory)
{
}
public void SetServiceProvider(IServiceScopeFactory serviceScopeFactory)
{
this.serviceScopeFactory = serviceScopeFactory;
}
public ProducerService(IServiceScopeFactory scopeFactory, ILogger <ProducerService> logger)
{
this.scopeFactory = scopeFactory;
this.logger = logger;
}
public static void RegisterJobs(IServiceScopeFactory serviceScopeFactory)
{
RecurringJob.AddOrUpdate <IElasticReorganizer>(a => a.StartReocganizationAsync(),
"0 0 * * *", //this cron expressions means execute at 00:00 am. more info: "https://crontab.guru/#0_0_*_*_*"
TimeZoneInfo.Utc);
}
public CommandDispatcher(IServiceScopeFactory serviceScopeFactory, ZaminServices zaminServices)
{
_serviceFactory = serviceScopeFactory;
_zaminServices = zaminServices;
}
public ChangesOfPendingSpodu(IServiceScopeFactory serviceScopeFactory
) :
base(serviceScopeFactory)
{
_serviceScopeFactory = serviceScopeFactory;
}
public UpdateGraphsService(ILogger <PruneDatabaseService> logger, IServiceScopeFactory scopeFactory)
{
_logger = logger;
_scopeFactory = scopeFactory;
}
public CacheHostedService(IServiceScopeFactory scopeFactory)
{
_scopeFactory = scopeFactory ?? throw new ArgumentNullException(nameof(scopeFactory));
}
public AspNetCoreJobActivator([NotNull] IServiceScopeFactory serviceScopeFactory)
{
if (serviceScopeFactory == null) throw new ArgumentNullException(nameof(serviceScopeFactory));
_serviceScopeFactory = serviceScopeFactory;
}
public AnotherSampleServiceImplementation(IServiceScopeFactory scopeFactory)
{
_scopeFactory = scopeFactory;
}
