private Lazy <Mock <DbSet <TEntity> > > SetupLazyMockSet <TEntity>( IReadOnlyList <TEntity> entities) where TEntity : class { var lazyMockSet = LazyEx.Create(() => { var mockSet = entities .AsQueryable() .BuildMockDbSet(); mockSet .Setup(x => x.AsQueryable()) .Returns(() => mockSet.Object); mockSet .Setup(x => x.AsAsyncEnumerable()) .Returns(() => mockSet.Object); return(mockSet); }); Setup(x => x.Set <TEntity>()) .Returns(() => lazyMockSet.Value.Object); return(lazyMockSet); }
// Flagging the registration with WrapsInstanceCreationDelegate prevents false diagnostic warnings. private InstanceProducer(Type serviceType, Expression expression, Container container) : this(serviceType, new ExpressionRegistration(expression, container) { WrapsInstanceCreationDelegate = true }) { // Overrides earlier set value. This prevents ExpressionBuilt from being applied. this.lazyExpression = Helpers.ToLazy(expression); }
private UpdateService() { Settings.Default.PropertyChanged += _HandleSettingsPropertyChanged; mUpdateManager = new LazyEx <Task <UpdateManager> >(async() => { #if NOSQUIRREL return(null); #pragma warning disable 162 #endif var updateUrl = Settings.Default.GitHubUpdateUrl; var preRelease = Settings.Default.UpdateToPreRelease; this.Log().Information("Creating update manager with {Url} ({PreRelease})", updateUrl, preRelease); try { return(await UpdateManager.GitHubUpdateManager(updateUrl, prerelease: preRelease)); } catch (Exception ex) { this.Log().Error(ex, "Failed to create GitHub update manager"); return(null); } #if NOSQUIRREL #pragma warning restore 162 #endif }); }
public WellKnownTypes(SemanticModel semanticModel) { Contract.Requires(semanticModel != null); var compilation = semanticModel.Compilation; _exceptionType = LazyEx.Create(() => compilation.GetTypeByMetadataName(typeof(Exception).FullName)); _boolType = LazyEx.Create(() => compilation.GetTypeByMetadataName(typeof(bool).FullName)); }
public PureMethodVerifier(SemanticModel semanticModel) { Contract.Requires(semanticModel != null); _semanticModel = semanticModel; _wellKnownImmutableTypes = LazyEx.Create(() => GetWellKnownImmutableSystemTypes(semanticModel)); _wellKnownFactoryTypes = LazyEx.Create(() => GetWellKnownFactories(semanticModel)); }
public FileFilter() { mTextRegex = new LazyEx <Regex>(_CreateTextRegex); Settings.Default.PropertyChanged += (sender, args) => { if (args.PropertyName == nameof(Settings.MultiImageSelection) && !Settings.Default.MultiImageSelection) { ShowOnlyCheckedItems = false; } }; }
internal PredicateContext( Type serviceType, Type implementationType, InjectionConsumerInfo consumer, bool handled) { Requires.IsNotNull(serviceType, nameof(serviceType)); Requires.IsNotNull(implementationType, nameof(implementationType)); Requires.IsNotNull(consumer, nameof(consumer)); this.ServiceType = serviceType; this.implementationType = new LazyEx <Type>(implementationType); this.consumer = consumer; this.Handled = handled; }
public SwitchAnalyzer(SwitchStatementSyntax switchStatement, SemanticModel semanticModel) { // Hm...! It seems that Code Contracts still has a bug, and uncommenting Contract.Requires lead to NRE! //Contract.Requires(switchStatement != null); //Contract.Requires(semanticModel != null); _switchStatement = switchStatement; _semanticModel = semanticModel; var expressionSymbol = semanticModel.GetSymbolInfo(switchStatement.Expression).Symbol; _expressionType = LazyEx.Create(() => GetSymbolType(expressionSymbol)); _switchOverEnum = LazyEx.Create(() => _expressionType.Value.IsEnum(semanticModel)); _enumValues = LazyEx.Create(() => _expressionType.Value.GetSortedEnumFieldsAndValues().ToImmutableList()); _cases = LazyEx.Create(() => GetUsedCases().ToImmutableList()); }
public void CreateThreadSafe_Always_ReturnsNewLazy( string value) { var mockValueFactory = new Mock <Func <string> >(); mockValueFactory .Setup(x => x()) .Returns(value); var result = LazyEx.CreateThreadSafe( mockValueFactory.Object); result.IsValueCreated.ShouldBeFalse(); result.Value.ShouldBe(value); mockValueFactory.ShouldHaveReceived(x => x()); }
internal PredicateContext( Type serviceType, Func <Type?> implementationTypeProvider, InjectionConsumerInfo consumer, bool handled) { Requires.IsNotNull(serviceType, nameof(serviceType)); Requires.IsNotNull(implementationTypeProvider, nameof(implementationTypeProvider)); Requires.IsNotNull(consumer, nameof(consumer)); this.ServiceType = serviceType; // HACK: LazyEx does not support null (as a simplification and memory optimization). This is why // the dummy type is returned when the provider returns null. this.implementationType = new LazyEx <Type>(() => implementationTypeProvider() ?? typeof(NullMarkerDummy)); this.consumer = consumer; this.Handled = handled; }
internal InstanceProducer(Type serviceType, Registration registration, bool registerExternalProducer) { Requires.IsNotNull(serviceType, nameof(serviceType)); Requires.IsNotNull(registration, nameof(registration)); Requires.IsNotOpenGenericType(serviceType, nameof(serviceType)); this.ServiceType = serviceType; this.Registration = registration; this.validator = new CyclicDependencyValidator(this); this.lazyExpression = new LazyEx <Expression>(this.BuildExpressionInternal); if (registerExternalProducer) { registration.Container.RegisterExternalProducer(this); } this.instanceCreator = this.BuildAndReplaceInstanceCreatorAndCreateFirstInstance; }