/// <summary>
/// Adds support to Blazor for the Fluxor library
/// </summary>
/// <param name="serviceCollection">The service collection</param>
/// <param name="configure">A callback used to configure options</param>
/// <returns>The service collection</returns>
/// <example>
///var serviceProvider = new BrowserServiceProvider(services =>
///{
/// services.AddFluxor(options => options
/// .UseDependencyInjection(typeof(Program).Assembly)
/// );
///});
///</example>
public static IServiceCollection AddFluxor(this IServiceCollection serviceCollection, Action <Options> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
// We only use an instance so middleware can create extensions to the Options
var options = new Options();
configure(options);
// Register all middleware types with dependency injection
foreach (Type middlewareType in Options.MiddlewareTypes)
{
serviceCollection.AddSingleton(middlewareType);
}
IEnumerable <AssemblyScanSettings> scanWhitelist = Options.MiddlewareTypes
.Select(t => new AssemblyScanSettings(t.Assembly, t.GetNamespace()));
// Scan for features and effects
if (Options.DependencyInjectionEnabled)
{
DependencyScanner.Scan(
serviceCollection: serviceCollection,
assembliesToScan: Options.DependencyInjectionAssembliesToScan,
scanWhitelist: scanWhitelist);
serviceCollection.AddSingleton(typeof(IState <>), typeof(State <>));
}
return(serviceCollection);
}
private static async Task Main(string[] args)
{
await foreach (var item in DependencyScanner.ScanDirectoryAsync(args[0], options: null, CancellationToken.None).ConfigureAwait(false))
{
Console.WriteLine(item.ToString());
}
}
private async Task <List <Dependency> > GetDependencies(DependencyScanner scanner)
{
var dependencies = new List <Dependency>();
await foreach (var dep in DependencyScanner.ScanDirectoryAsync(_directory.FullPath, new ScannerOptions {
DegreeOfParallelism = 1, Scanners = new[] { scanner }
}))
{
dependencies.Add(dep);
}
// Execute in parallel and compare the number of found dependencies
var dependencies2 = new List <Dependency>();
await foreach (var dep in DependencyScanner.ScanDirectoryAsync(_directory.FullPath, new ScannerOptions {
DegreeOfParallelism = 16, Scanners = new[] { scanner }
}))
{
dependencies2.Add(dep);
}
Assert.Equal(dependencies.Count, dependencies2.Count);
return(dependencies);
}
public static DependencyScanner RegisterSystems(
this DependencyScanner scanner,
DependencyLifetime lifetime = DependencyLifetime.Singleton)
{
scanner.UseCollector(new SystemsCollector(lifetime));
return(scanner);
}
public async Task LargeDirectory_NoScannerMatch()
{
var stopwatch = ValueStopwatch.StartNew();
using var directory = TemporaryDirectory.Create();
const int FileCount = 10_000;
for (var i = 0; i < FileCount; i++)
{
File.WriteAllText(directory.GetFullPath($"text{i}.txt"), "");
}
_testOutputHelper.WriteLine("File generated in " + stopwatch.GetElapsedTime());
stopwatch = ValueStopwatch.StartNew();
var items = new List <Dependency>(FileCount);
await foreach (var item in DependencyScanner.ScanDirectoryAsync(directory.FullPath, new ScannerOptions {
Scanners = new[] { new DummyScannerNeverMatch() }
}))
{
items.Add(item);
}
_testOutputHelper.WriteLine("File scanned in " + stopwatch.GetElapsedTime());
Assert.Empty(items);
}
/// <summary>
/// Adds support to Blazor for the Fluxor library
/// </summary>
/// <param name="serviceCollection">The service collection</param>
/// <param name="configure">A callback used to configure options</param>
/// <returns>The service collection</returns>
/// <example>
///var serviceProvider = new BrowserServiceProvider(services =>
///{
/// services.AddFluxor(options => options
/// .UseDependencyInjection(typeof(Program).Assembly)
/// );
///});
///</example>
public static IServiceCollection AddFluxor(
this IServiceCollection serviceCollection,
Action <Options> configure = null)
{
// We only use an instance so middleware can create extensions to the Options
var options = new Options(serviceCollection);
configure?.Invoke(options);
// Register all middleware types with dependency injection
foreach (Type middlewareType in Options.MiddlewareTypes)
{
serviceCollection.AddScoped(middlewareType);
}
IEnumerable <AssemblyScanSettings> scanIncludeList = Options.MiddlewareTypes
.Select(t => new AssemblyScanSettings(t.Assembly, t.Namespace));
DependencyScanner.Scan(
serviceCollection: serviceCollection,
assembliesToScan: Options.AssembliesToScan,
scanIncludeList: scanIncludeList);
serviceCollection.AddScoped(typeof(IState <>), typeof(State <>));
return(serviceCollection);
}
/// <summary>
/// Adds support to Blazor for the Fluxor library
/// </summary>
/// <param name="serviceCollection">The service collection</param>
/// <param name="configure">A callback used to configure options</param>
/// <returns>The service collection</returns>
/// <example>
///var serviceProvider = new BrowserServiceProvider(services =>
///{
/// services.AddFluxor(options => options
/// .UseDependencyInjection(typeof(Program).Assembly)
/// );
///});
///</example>
public static IServiceCollection AddFluxor(this IServiceCollection serviceCollection, Action <Options> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
// We only use an instance so middleware can create extensions to the Options
var options = new Options(serviceCollection);
configure(options);
// Register all middleware types with dependency injection
foreach (Type middlewareType in Options.MiddlewareTypes)
{
serviceCollection.AddScoped(middlewareType);
}
IEnumerable <AssemblyScanSettings> scanIncludeList = Options.MiddlewareTypes
.Select(t => new AssemblyScanSettings(t.Assembly, t.Namespace));
// Scan for features and effects
if (Options.DependencyInjectionEnabled)
{
serviceCollection.AddScoped <IStoreInitializationStrategy, JavaScriptStoreInitializationStrategy>();
serviceCollection.AddScoped <ReduxDevTools.ReduxDevToolsInterop>();
DependencyScanner.Scan(
serviceCollection: serviceCollection,
assembliesToScan: Options.DependencyInjectionAssembliesToScan,
scanIncludeList: scanIncludeList);
serviceCollection.AddScoped(typeof(IState <>), typeof(State <>));
}
return(serviceCollection);
}
public DependencyCollection Scan(Action <DependencyScanner> action)
{
var scanner = new DependencyScanner(this);
action(scanner);
scanner.Execute();
return(this);
}
public void TypeLicense_InvalidRepositoryFormat_CorrectResult()
{
var config = Config.WithoutCache(new Config());
var packagePolicies = new PackagePolicies(new PackagePolicy[] { });
var scanner = new DependencyScanner(new FakeNpm(), new FakeFileSystem(), packagePolicies, config.DiskCache);
var x = scanner.FindPackageDependencies(new[] { new PackageRange("test-package", "^1.0.0", "") }, new HashSet <string>()).Result;
Assert.Equal(1, x[0].Dependencies.Count);
}
public void DependencyScanner_GetDependencyScanner_None_Test()
{
//arrange
Type fakeType = typeof(Boot);
DependencyScanner dependencyScanner;
//act
dependencyScanner = DependencyScanner.GetDependencyScanner(DependencyScanTarget.None, fakeType.Assembly, fakeType.Namespace);
//assert
Assert.IsNull(dependencyScanner);
}
public void CyclincDependency_IsIgnored()
{
var config = Config.WithoutCache(new Config());
var packagePolicies = new PackagePolicies(new PackagePolicy[] { });
var scanner = new DependencyScanner(new FakeNpm(), new FakeFileSystem(), packagePolicies, config.DiskCache);
var x = scanner.FindPackageDependencies(new[] { new PackageRange("test-package", "^2.0.0", "") }, new HashSet <string>()).Result;
Assert.Equal(1, x[0].Dependencies.Count);
Assert.Equal(0, x[0].Dependencies.First().Dependencies.Count);
}
private async Task <List <Dependency> > GetDependencies(DependencyScanner scanner)
{
var dependencies = new List <Dependency>();
await foreach (var dep in DependencyScanner.ScanDirectoryAsync(_directory.FullPath, new ScannerOptions {
DegreeOfParallelism = 1, Scanners = new[] { scanner }
}))
{
dependencies.Add(dep);
}
return(dependencies);
}
public void DependencyScanner_GetDependencyScanner_Namespace_Test()
{
//arrange
Type fakeType = typeof(Boot);
DependencyScanner dependencyScanner;
//act
dependencyScanner = DependencyScanner.GetDependencyScanner(DependencyScanTarget.CurrentNamespace, fakeType.Assembly, fakeType.Namespace);
//assert
Assert.IsNotNull(dependencyScanner);
Assert.IsInstanceOfType(dependencyScanner, typeof(NamespaceScanner));
}
public async Task ReportScanException(int degreeOfParallelism)
{
await using var directory = TemporaryDirectory.Create();
await File.WriteAllTextAsync(directory.GetFullPath($"text.txt"), "");
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await DependencyScanner.ScanDirectoryAsync(directory.FullPath, new ScannerOptions {
DegreeOfParallelism = degreeOfParallelism, Scanners = new[] { new ShouldScanThrowScanner() }
}, _ => ValueTask.CompletedTask);
});
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await DependencyScanner.ScanDirectoryAsync(directory.FullPath, new ScannerOptions {
DegreeOfParallelism = degreeOfParallelism, Scanners = new[] { new ScanThrowScanner() }
}, _ => ValueTask.CompletedTask);
});
}
public async Task ReportScanException_IAsyncEnumerablt(int degreeOfParallelism)
{
await using var directory = TemporaryDirectory.Create();
await File.WriteAllTextAsync(directory.GetFullPath($"text.txt"), "");
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await foreach (var item in DependencyScanner.ScanDirectoryAsync(directory.FullPath, new ScannerOptions {
DegreeOfParallelism = degreeOfParallelism, Scanners = new[] { new ShouldScanThrowScanner() }
}))
{
}
});
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await foreach (var item in DependencyScanner.ScanDirectoryAsync(directory.FullPath, new ScannerOptions {
DegreeOfParallelism = degreeOfParallelism, Scanners = new[] { new ScanThrowScanner() }
}))
{
}
});
}
public static DependencyScanner RegisterAsTransient <TContract>(this DependencyScanner scanner)
where TContract : class
{
return(scanner.Register(Typeof <TContract> .Raw, DependencyLifetime.Transient));
}
public static DependencyScanner RegisterAsTransient(this DependencyScanner scanner, Type contract)
{
return(scanner.Register(contract, DependencyLifetime.Transient));
}
public static DependencyScanner RegisterAsSingleton <TContract>(this DependencyScanner scanner)
where TContract : class
{
return(scanner.Register(Typeof <TContract> .Raw, DependencyLifetime.Singleton));
}
public static DependencyScanner RegisterAsSingleton(this DependencyScanner scanner, Type contract)
{
return(scanner.Register(contract, DependencyLifetime.Singleton));
}
public static DependencyScanner RegisterAsScoped(this DependencyScanner scanner, Type contract)
{
return(scanner.Register(contract, DependencyLifetime.Scoped));
}
public static DependencyScanner RegisterEmitterProcessors(this DependencyScanner scanner,
DependencyLifetime lifetime = DependencyLifetime.Singleton)
{
return(scanner.UseCollector(new ProcessorsCollector(lifetime)));
}
public static DependencyScanner AddEmitterProcessors(this DependencyScanner scanner,
DependencyLifetime lifetime = DependencyLifetime.Singleton)
{
return(scanner.UseAllover(new ProcessorsAllover(lifetime)));
}
private static async Task UpdateDependencies(IEnumerable <Dependency> dependencies, string newVersion)
{
await DependencyScanner.UpdateAllAsync(dependencies, newVersion, CancellationToken.None);
}
public AttributeBasedDIContext(Type callingType) : base(callingType)
{
this.Scanner = DependencyScanner.GetDependencyScanner(this._scanTarget, this._callingAssembly, this._currentNamespace);
this.Registrar = DependencyRegistrar.BuildRegistrarChain(this._container);
}
public DependencyScannerShould()
{
_collection = new DependencyCollection();
_contract = typeof(IBooRepository);
_scanner = new DependencyScanner(_collection).AssemblyOf <IBooRepository>();
}