/// <summary> /// Initializes a new instance of the <see cref="ActorPath" /> class. /// </summary> /// <param name="parentPath"> The parent path. </param> /// <param name="name"> The name. </param> /// <param name="uid"> The uid. </param> protected ActorPath(ActorPath parentPath, string name, long uid) { Address = parentPath.Address; Uid = uid; Name = name; _elements = new FastLazy <ActorPath, IList <string> >(FillElementsFunc, this); }
public void Setup() { lazySafe = new Lazy <int>(() => 100, LazyThreadSafetyMode.ExecutionAndPublication); lazyUnsafe = new Lazy <int>(() => 100, LazyThreadSafetyMode.None); fastLazy = new FastLazy <int>(() => 100); fastLazyWithInit = new FastLazy <int, int>(state => state + 100, 1000); }
public void Setup() { _fastLazy = new FastLazy <int>(() => new Random().Next()); _unsafeLazy = new Lazy <int>(() => new Random().Next()); _publishOnlySafeLazy = new Lazy <int>(() => new Random().Next(), LazyThreadSafetyMode.PublicationOnly); _readAndExecuteSafeLazy = new Lazy <int>(() => new Random().Next(), LazyThreadSafetyMode.ExecutionAndPublication); }
public void FastAtomicLazy_should_produce_value() { var fal = new FastLazy <int>(() => 2); var value = fal.Value; Assert.Equal(2, value); Assert.True(fal.IsValueCreated); }
public void FastAtomicLazy_must_be_threadsafe_AnyRef() { for (var c = 0; c < 100000; c++) // try this 100000 times { var values = new ConcurrentBag <string>(); var fal = new FastLazy <string>(() => Faker.Generators.Strings.GenerateAlphaNumericString()); var result = Parallel.For(0, 1000, i => values.Add(fal.Value)); // 1000 concurrent operations SpinWait.SpinUntil(() => result.IsCompleted); var value = values.First(); Assert.NotNull(value); Assert.True(values.All(x => x.Equals(value))); } }
public void FastAtomicLazy_must_be_threadsafe() { for (var c = 0; c < 100000; c++) // try this 100000 times { var values = new ConcurrentBag <int>(); var fal = new FastLazy <int>(() => new Random().Next(1, Int32.MaxValue)); var result = Parallel.For(0, 1000, i => values.Add(fal.Value)); // 1000 concurrent operations SpinWait.SpinUntil(() => result.IsCompleted); var value = values.First(); Assert.NotEqual(0, value); Assert.True(values.All(x => x.Equals(value))); } }
public MethodInfo this[Type type] { get { FastLazy <MethodInfo> result = null; if (this.methods.TryGetValue(type, out result)) { return(result.Value); } return(null); } }
public DbTableInfo( string tableName, Type entityType, MemberInfo identityField, PropertyInfo[] properties, IKeyInfo primaryKeyInfo, IKeyInfo[] uniqueKeys, IKeyInfo[] foreignKeys, object[] constraintFactories) { this.TableName = tableName; this.EntityType = entityType; this.IdentityField = identityField; this.Properties = properties; this.ConstraintFactories = constraintFactories; this.PrimaryKeyInfo = primaryKeyInfo; this.UniqueKeys = uniqueKeys; this.ForeignKeys = foreignKeys; this.initializer = new FastLazy <Func <object[], object> >(CreateEntityInitializer); }
public DbTableInfo( string tableName, Type entityType, MemberInfo identityField, PropertyInfo[] properties, IKeyInfo primaryKeyInfo, IKeyInfo[] uniqueKeys, IKeyInfo[] foreignKeys, object[] constraintFactories) { this.TableName = tableName; this.EntityType = entityType; this.IdentityField = identityField; this.Properties = properties; this.ConstraintFactories = constraintFactories; this.PrimaryKeyInfo = primaryKeyInfo; this.UniqueKeys = uniqueKeys; this.ForeignKeys = foreignKeys; this.initializer = new FastLazy<Func<object[], object>>(CreateEntityInitializer); }
public void FastAtomicLazy_only_single_value_creation_attempt_AnyRef() { int attempts = 0; Func <string> slowValueFactory = () => { Interlocked.Increment(ref attempts); Thread.Sleep(100); return(Faker.Generators.Strings.GenerateAlphaNumericString()); }; var values = new ConcurrentBag <string>(); var fal = new FastLazy <string>(slowValueFactory); var result = Parallel.For(0, 1000, i => values.Add(fal.Value)); // 1000 concurrent operations SpinWait.SpinUntil(() => result.IsCompleted); var value = values.First(); Assert.NotNull(value); Assert.True(values.All(x => x.Equals(value))); Assert.Equal(1000, values.Count); Assert.Equal(1, attempts); }
public void FastAtomicLazy_only_single_value_creation_attempt() { int attempts = 0; Func <int> slowValueFactory = () => { Interlocked.Increment(ref attempts); Thread.Sleep(100); return(new Random().Next(1, Int32.MaxValue)); }; var values = new ConcurrentBag <int>(); var fal = new FastLazy <int>(slowValueFactory); var result = Parallel.For(0, 1000, i => values.Add(fal.Value)); // 1000 concurrent operations SpinWait.SpinUntil(() => result.IsCompleted); var value = values.First(); Assert.NotEqual(0, value); Assert.True(values.All(x => x.Equals(value))); Assert.Equal(1000, values.Count); Assert.Equal(1, attempts); }
/// <summary> /// Initializes a new instance of the <see cref="Serializer" /> class. /// </summary> /// <param name="system">The actor system to associate with this serializer. </param> protected Serializer(ExtendedActorSystem system) { this.system = system; _value = new FastLazy <int>(() => SerializerIdentifierHelper.GetSerializerIdentifierFromConfig(GetType(), system)); }
/// <summary> /// Initializes a new instance of the <see cref="ActorPath" /> class. /// </summary> /// <param name="address"> The address. </param> /// <param name="name"> The name. </param> protected ActorPath(Address address, string name) { Name = name; Address = address; _elements = new FastLazy <ActorPath, IList <string> >(FillElementsFunc, this); }
public LazyExecutorServiceDelegate(string id, ExecutorServiceFactory executorServiceFactory) { _id = id; _executorServiceFactory = executorServiceFactory; _executor = new FastLazy <ExecutorService>(() => executorServiceFactory.Produce(_id)); }
public LazyExecutorServiceDelegate(string id, ExecutorServiceFactory executorServiceFactory) { _id = id; _executorServiceFactory = executorServiceFactory; _executor = new FastLazy<ExecutorService>(() => executorServiceFactory.Produce(_id)); }
/// <summary> /// Prevents a default instance of the <see cref="LinqMethodProvider" /> class from /// being created. /// </summary> private LinqMethodProvider() { this.select = CreateLazy(CreateSelect); this.selectMany = CreateLazy(CreateSelectMany); this.selectManyWithResultSelector = CreateLazy(CreateSelectManyWithResultSelector); this.count = CreateLazy(CreateCount); this.where = CreateLazy(CreateWhere); this.take = CreateLazy(CreateTake); this.skip = CreateLazy(CreateSkip); this.groupBy = CreateLazy(CreateGroupBy); this.orderBy = CreateLazy(CreateOrderBy); this.orderByDescending = CreateLazy(CreateOrderByDescending); this.thenBy = CreateLazy(CreateThenBy); this.thenByDescending = CreateLazy(CreateThenByDescending); this.first = CreateLazy(CreateFirst); this.firstOrDefault = CreateLazy(CreateFirstOrDefault); this.any = CreateLazy(CreateAny); this.defaultIfEmpty = CreateLazy(CreateDefaultIfEmpty); this.asQueryable = CreateLazy(CreateAsQueryable); this.distinct = CreateLazy(CreateDistinct); this.except = CreateLazy(CreateExcept); this.intersect = CreateLazy(CreateIntersect); this.union = CreateLazy(CreateUnion); this.concat = CreateLazy(CreateConcat); this.sum = new MethodInfoGroup( Tuple.Create(typeof(int), CreateLazy(CreateSumInt)), Tuple.Create(typeof(int?), CreateLazy(CreateSumNInt)), Tuple.Create(typeof(long), CreateLazy(CreateSumLong)), Tuple.Create(typeof(long?), CreateLazy(CreateSumNLong)), Tuple.Create(typeof(float), CreateLazy(CreateSumFloat)), Tuple.Create(typeof(float?), CreateLazy(CreateSumNFloat)), Tuple.Create(typeof(double), CreateLazy(CreateSumDouble)), Tuple.Create(typeof(double?), CreateLazy(CreateSumNDouble)), Tuple.Create(typeof(decimal), CreateLazy(CreateSumDecimal)), Tuple.Create(typeof(decimal?), CreateLazy(CreateSumNDecimal))); this.min = new MethodInfoGroup( Tuple.Create(typeof(int), CreateLazy(CreateMinInt)), Tuple.Create(typeof(int?), CreateLazy(CreateMinNInt)), Tuple.Create(typeof(long), CreateLazy(CreateMinLong)), Tuple.Create(typeof(long?), CreateLazy(CreateMinNLong)), Tuple.Create(typeof(float), CreateLazy(CreateMinFloat)), Tuple.Create(typeof(float?), CreateLazy(CreateMinNFloat)), Tuple.Create(typeof(double), CreateLazy(CreateMinDouble)), Tuple.Create(typeof(double?), CreateLazy(CreateMinNDouble)), Tuple.Create(typeof(decimal), CreateLazy(CreateMinDecimal)), Tuple.Create(typeof(decimal?), CreateLazy(CreateMinNDecimal))); this.max = new MethodInfoGroup( Tuple.Create(typeof(int), CreateLazy(CreateMaxInt)), Tuple.Create(typeof(int?), CreateLazy(CreateMaxNInt)), Tuple.Create(typeof(long), CreateLazy(CreateMaxLong)), Tuple.Create(typeof(long?), CreateLazy(CreateMaxNLong)), Tuple.Create(typeof(float), CreateLazy(CreateMaxFloat)), Tuple.Create(typeof(float?), CreateLazy(CreateMaxNFloat)), Tuple.Create(typeof(double), CreateLazy(CreateMaxDouble)), Tuple.Create(typeof(double?), CreateLazy(CreateMaxNDouble)), Tuple.Create(typeof(decimal), CreateLazy(CreateMaxDecimal)), Tuple.Create(typeof(decimal?), CreateLazy(CreateMaxNDecimal))); this.average = new MethodInfoGroup( Tuple.Create(typeof(int), CreateLazy(CreateAvgInt)), Tuple.Create(typeof(int?), CreateLazy(CreateAvgNInt)), Tuple.Create(typeof(long), CreateLazy(CreateAvgLong)), Tuple.Create(typeof(long?), CreateLazy(CreateAvgNLong)), Tuple.Create(typeof(float), CreateLazy(CreateAvgFloat)), Tuple.Create(typeof(float?), CreateLazy(CreateAvgNFloat)), Tuple.Create(typeof(double), CreateLazy(CreateAvgDouble)), Tuple.Create(typeof(double?), CreateLazy(CreateAvgNDouble)), Tuple.Create(typeof(decimal), CreateLazy(CreateAvgDecimal)), Tuple.Create(typeof(decimal?), CreateLazy(CreateAvgNDecimal))); this.minGeneric = CreateLazy(CreateMinGeneric); this.maxGeneric = CreateLazy(CreateMaxGeneric); this.averageGeneric = CreateLazy(CreateAvgGeneric); }
public void FastAtomicLazy_should_indicate_no_value_has_been_produced() { var fal = new FastLazy <int>(() => 2); Assert.False(fal.IsValueCreated); }