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;
}
