private void RegisterReadModelIndexes() { /*var indexes = from @type in this.GetType().Assembly.GetTypes() * where * @type.Namespace != null && @type.Namespace.Contains("ReadModel") && [email protected] && * typeof(AbstractIndexCreationTask).IsAssignableFrom(@type) * select @type; * * foreach (var task in indexes.Select(index => (AbstractIndexCreationTask)FastActivator.Create(index))) * { * task.Execute(this.factory.ReadModel); * }*/ var transformers = from @type in this.GetType().Assembly.GetTypes() where [email protected] && typeof(AbstractTransformerCreationTask).IsAssignableFrom(@type) select @type; foreach ( var task in transformers.Select( transformer => (AbstractTransformerCreationTask)FastActivator.Create(transformer))) { task.Execute(this.factory.ReadModel); } }
public void DefaultConstructor(int iterations) { for (int i = 0; i < iterations; i++) { ClassWithDefaultConstructor item = FastActivator <ClassWithDefaultConstructor> .Create(); } }
public void SingleArgumentConstructor(int iterations) { for (int i = 0; i < iterations; i++) { ClassWithOneConstructorArg item = FastActivator <ClassWithOneConstructorArg> .Create(47); } }
public void The_generic_arguments_should_be_used_to_build_the_type() { var obj = FastActivator.Create(typeof(ClassWithOneGenericArgument <>), new[] { typeof(int) }); obj.ShouldNotBeNull(); obj.ShouldBeAnInstanceOf <ClassWithOneGenericArgument <int> >(); }
protected virtual UnsubscribeAction Connect <TComponent, TMessage>(ISubscriberContext context) where TMessage : class where TComponent : class, Observes <TMessage, TComponent>, ISaga { MessageRouterConfigurator routerConfigurator = MessageRouterConfigurator.For(context.Pipeline); var router = routerConfigurator.FindOrCreate <TMessage>(); var instance = (Observes <TMessage, TComponent>) FastActivator <TComponent> .Create(Guid.Empty); Expression <Func <TComponent, TMessage, bool> > selector = instance.GetBindExpression(); var repository = context.Builder.GetInstance <ISagaRepository <TComponent> >(); var policy = new ExistingSagaPolicy <TComponent, TMessage>(x => false); var sink = new PropertySagaMessageSink <TComponent, TMessage>(context, context.Data as IServiceBus, repository, policy, selector); if (sink == null) { throw new ConfigurationException("Could not build the message sink for " + typeof(TComponent).FullName); } var result = router.Connect(sink); UnsubscribeAction remove = context.SubscribedTo <TMessage>(); return(() => result() && (router.SinkCount == 0) && remove()); }
private static IObjectSerializer CreateEnumerableSerializerFor(Type type) { if (type.IsArray) { return((IObjectSerializer)FastActivator.Create(typeof(ArraySerializer <>).MakeGenericType(type.GetElementType()))); } Type[] genericArguments = type.GetDeclaredGenericArguments().ToArray(); if (genericArguments == null || genericArguments.Length == 0) { Type elementType = type.IsArray ? type.GetElementType() : typeof(object); Type serializerType = typeof(ArraySerializer <>).MakeGenericType(elementType); return((IObjectSerializer)FastActivator.Create(serializerType)); } if (type.ImplementsGeneric(typeof(IDictionary <,>))) { Type serializerType = typeof(DictionarySerializer <,>).MakeGenericType(genericArguments); return((IObjectSerializer)FastActivator.Create(serializerType)); } if (type.ImplementsGeneric(typeof(IList <>)) || type.ImplementsGeneric(typeof(IEnumerable <>))) { Type serializerType = typeof(ListSerializer <>).MakeGenericType(genericArguments[0]); return((IObjectSerializer)FastActivator.Create(serializerType)); } throw new InvalidOperationException("enumerations not yet supported"); }
public MakeMCEuropeanHestonEngine <RNG, S> withAbsoluteTolerance(double tolerance) { Utils.QL_REQUIRE(samples_ == null, () => "number of samples already set"); Utils.QL_REQUIRE(FastActivator <RNG> .Create().allowsErrorEstimate != 0, () => "chosen random generator policy does not allow an error estimate"); tolerance_ = tolerance; return(this); }
/// <summary> /// Returns a collection of instances /// of a certain type /// </summary> public static IEnumerable <T> Populate <T>(int count) { for (var i = 0; i < count; i++) { yield return(FastActivator.Create <T>()); } }
public void DynamicGenerateCodeConstructor() { for (int i = 0; i < IterationCount; i++) { FastActivator <Node> .Create(); } }
public static UnsubscribeAction ConnectEndpoint(this IMessagePipeline pipeline, Type messageType, IEndpoint endpoint) { object sink = FastActivator.Create(typeof(EndpointMessageSink <>).MakeGenericType(messageType), new object[] { endpoint }); return(pipeline.FastInvoke <IMessagePipeline, UnsubscribeAction>("ConnectToRouter", sink)); }
public static GameAction Create(int actionId) { GameAction gameAction = null; string name = string.Format(ActionFormat, actionId); try { var type = (Type)lookupType[name]; lock (lookupType) { if (type == null) { type = Type.GetType(name); lookupType[name] = type; } } if (type != null) { gameAction = FastActivator.Create(type) as GameAction; } } catch (Exception ex) { UnityEngine.Debug.LogError("GameAction create error:" + ex); } return(gameAction); }
// factory public IRNG make_sequence_generator(int dimension, ulong seed) { URSG g = (URSG)FastActivator <URSG> .Create().factory(dimension, seed); return(icInstance != null ? new InverseCumulativeRsg <URSG, IC>(g, icInstance) : new InverseCumulativeRsg <URSG, IC>(g)); }
public void Load() { var interceptorNodes = section.TryGetNodes("interceptors/interceptor"); foreach (var node in interceptorNodes) { var entityAttr = node.Attributes.TryGetValue("entity"); var typeAttr = node.Attributes.TryGetValue("type"); try { if (String.IsNullOrEmpty(entityAttr)) { RegisterInterceptor((IRepositoryFrameworkInterceptor)FastActivator.Create(typeAttr)); } else { RegisterInterceptor(Type.GetType(entityAttr), (IRepositoryFrameworkInterceptor)FastActivator.Create(typeAttr)); } } catch (Exception ex) { throw new PlatformException("加载拦截器错误。entity:{0}, type:{1}。\r\n详细错误:\r\n{2} ", entityAttr, typeAttr, ex); } } }
void Create() { try { _controllerChannel = new OutboundChannel(_controllerAddress, _controllerPipeName); Type type = FindBootstrapperImplementationType(_bootstrapperType); _log.DebugFormat("[{0}] Creating bootstrapper: {1}", _serviceName, type.ToShortTypeName()); object bootstrapper = FastActivator.Create(type); Type serviceType = bootstrapper.GetType() .GetInterfaces() .First() .GetGenericArguments() .First(); _log.DebugFormat("[{0}] Creating configurator for service type: {1}", _serviceName, serviceType.ToShortTypeName()); InitializeAndCreateService(serviceType, bootstrapper); } catch (Exception ex) { SendFault(ex); } }
static IConsumerConnector ConsumerConnectorFactory(Type type) { var args = new object[] {}; var connector = (IConsumerConnector)FastActivator.Create(typeof(ConsumerConnector <>), new[] { type }, args); return(connector); }
public ObservesSagaSubscriptionConnector(ISagaRepository <TSaga> sagaRepository) : base(sagaRepository, new ExistingOrIgnoreSagaPolicy <TSaga, TMessage>(x => false)) { var instance = (Observes <TMessage, TSaga>) FastActivator <TSaga> .Create(Guid.Empty); _selector = instance.GetBindExpression(); }
private static IObjectSerializer CreateSerializerFor(Type type) { if (type.IsEnum) { return((IObjectSerializer)FastActivator.Create(typeof(EnumSerializer <>).MakeGenericType(type))); } if (typeof(IEnumerable).IsAssignableFrom(type)) { return(CreateEnumerableSerializerFor(type)); } if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>)) { Type nullableType = type.GetGenericArguments().First(); return(_serializers.Retrieve(nullableType, () => CreateSerializerFor(nullableType))); } Type serializerType = typeof(ObjectSerializer <>).MakeGenericType(type); var serializer = (IObjectSerializer)FastActivator.Create(serializerType); return(serializer); }
/// <summary> /// 注册元数据定义 /// </summary> /// <param name="assembly"></param> public void RegisterDefineMetadata(Assembly assembly) { if (assembly == null) { throw new ArgumentNullException("assembly"); } Type[] types = assembly.GetExportedTypes(); foreach (Type type in types) { var v = type.GetInterface(typeof(ICacheMetadataProvider).FullName); if (v != null) { var active = FastActivator.Create(type); var metadata = ((ICacheMetadataProvider)active).GetCacheMetadata(); if (metadatas.ContainsKey(metadata.EntityType)) { throw new PlatformException("重复的类型定义。\r\nEntityType:{0}, DefineType:{1}", metadata.EntityType.FullName, type.FullName); } //验证方法virtual EntityUtil.CheckVirtualType(metadata.EntityType); metadatas.Add(metadata.EntityType, metadata); } } }
public static void Init(IEnumerable <string> assemblyStrings) { var mappings = new List <Type>(); var baseType = typeof(MongoMap); foreach (var assemblyString in assemblyStrings) { try { var assembly = Assembly.Load(assemblyString); if (!assembly.IsDynamic) { mappings.AddRange( assembly.GetExportedTypes() .Where(t => t.IsClass && !t.IsAbstract && t.IsSubclassOf(baseType)) .ToList() ); } } catch (System.IO.FileNotFoundException ex) { } catch (Exception ex) { throw ex; } } foreach (var type in mappings) { FastActivator.Create(type); } }
/// <summary> /// 注册类型的分区策略 /// </summary> /// <param name="entityType"></param> /// <param name="shardStragegyType"></param> /// <param name="attributes"></param> public IShardStrategy RegisterShardStragety(Type entityType, Type shardStragegyType, IDictionary <string, string> attributes = null) { if (entityType == null) { throw new ArgumentNullException("entityType"); } if (shardStragegyType == null) { throw new ArgumentNullException("shardStragegyType"); } IShardStrategy strategy = (IShardStrategy)FastActivator.Create(shardStragegyType); if (strategy == null) { throw new ArgumentNullException("strategy"); } if (strategy is AbstractShardStrategy && attributes != null) { ((AbstractShardStrategy)strategy).Init(attributes); } if (stategies.ContainsKey(entityType)) { stategies[entityType] = strategy; } else { stategies.Add(entityType, strategy); } return(strategy); }
public object Deserialize(IDeserializerContext context) { T instance = FastActivator <T> .Create(); if (context.IsEmptyElement) { context.Read(); return(instance); } if (!context.Read()) { return(instance); } while (context.NodeType != XmlNodeType.EndElement && context.NodeType != XmlNodeType.None) { if (context.NodeType == XmlNodeType.Element) { ReadProperty(context, instance); continue; } if (!context.Read()) { break; } } context.ExitElement(); return(instance); }
public void TwoArgumentConstructor(int iterations) { for (int i = 0; i < iterations; i++) { ClassWithTwoConstructorArgs item = FastActivator <ClassWithTwoConstructorArgs> .Create(47, "The Name"); } }
/// <summary> /// Populates a new collection /// of instances of a certain type /// </summary> public static IEnumerable <object> Populate(this Type type, int count) { for (var i = 0; i < count; i++) { yield return(FastActivator.Create(type)); } }
public void Should_copy_the_arguments_into_the_class() { object arguments = FastActivator <MoveCommandArguments> .Create(); var properties = arguments.GetType() .GetProperties(BindingFlags.Instance | BindingFlags.Public) .Where(x => x.GetGetMethod(true) != null) .Where(x => x.GetSetMethod(true) != null) .Select(x => new FastProperty(x)); properties .Each(property => { object value = Elements.GetDefinitionElement(property.Property.PropertyType, property.Property.Name); if (value != null) { property.Set(arguments, value); return; } }); var test = (MoveCommandArguments)arguments; Assert.AreEqual("source.txt", test.From); Assert.AreEqual("destination.txt", test.To); Assert.IsTrue(test.Overwrite); }
public PiecewiseDefaultCurve(Date referenceDate, List <CdsHelper> instruments, DayCounter dayCounter, List <Handle <Quote> > jumps, List <Date> jumpDates, double accuracy) : this(referenceDate, instruments, dayCounter, jumps, jumpDates, accuracy, FastActivator <Interpolator> .Create(), FastActivator <BootStrap> .Create()) { }
/// <summary> /// Creates the provider by using the factory (if present) or directly instantiating by type name /// </summary> /// <returns></returns> public T CreateInstance() { //check if we have a factory if (this.factoryInstance == null) { var type = this.Factory; if (type != null) { this.factoryInstance = (IProviderFactory <T>)FastActivator.Create(type); this.factoryInstance.Initialize(this.parameters); } } // no factory, use the provider type if (this.factoryInstance == null) { var type = this.Type; if (type == null) { return(null); } return((T)FastActivator.Create(type)); } return(factoryInstance.Create()); }
public void testBMACurveConsistency <T, I, B>(CommonVars vars) where T : ITraits <YieldTermStructure>, new () where I : IInterpolationFactory, new () where B : IBootStrap <PiecewiseYieldCurve>, new () { testBMACurveConsistency <T, I, B>(vars, FastActivator <I> .Create(), 1.0e-7); }
public MakeMCDiscreteArithmeticASEngine <RNG, S> withTolerance(double tolerance) { Utils.QL_REQUIRE(samples_ == null, () => "number of samples already set"); Utils.QL_REQUIRE(FastActivator <RNG> .Create().allowsErrorEstimate != 0, () => "chosen random generator policy " + "does not allow an error estimate"); tolerance_ = tolerance; return(this); }
public override void Consume(TMessage message) { base.Consume(message); var reply = FastActivator <TReplyMessage> .Create(message.CorrelationId); Bus.Publish(reply); }
public override void Consume(TMessage message) { base.Consume(message); var reply = FastActivator <TReplyMessage> .Create(message.CorrelationId); ContextStorage.Context().Respond(reply); }