public NodeFamily() { type = typeof(T); activator = ObjectActivatorHelpers.GetActivator <T>(); var fields = type.GetFields(); foreach (var field in fields) { if (field.IsInitOnly || field.IsLiteral || field.IsStatic || !field.IsPublic) { continue; } fieldTypes.Add(field); fieldSet.Add(field); } ConstituentTypes = new ConstituentTypes(fieldSet.Select(f => f.FieldType)); isTuple = type.Name.StartsWith(TUPLE_NAME); if (isTuple) { genericTypeArguments = type.GenericTypeArguments; } }
internal static T GetDefaultInstance <T>() { ConstructorInfo ctor = typeof(T).GetConstructors().First(); ObjectActivator <T> createdActivator = GetActivator <T>(ctor); return(createdActivator(null)); }
// -------------------------------------------------- void Start() { itemActivatorObject = GameObject.Find("ObjectActivatorManager"); activationScript = itemActivatorObject.GetComponent <ObjectActivator>(); StartCoroutine("AddToList"); }
static ObjectActivator <T> GetActivator <T>(ConstructorInfo ctor) { Type type = ctor.DeclaringType; ParameterInfo[] paramsInfo = ctor.GetParameters(); ParameterExpression param = Expression.Parameter(typeof(object[]), "args"); Expression[] argsExp = new Expression[paramsInfo.Length]; for (int i = 0; i < paramsInfo.Length; i++) { Expression index = Expression.Constant(i); Type paramType = paramsInfo[i].ParameterType; Expression paramAccessorExp = Expression.ArrayIndex(param, index); Expression paramCastExp = Expression.Convert(paramAccessorExp, paramType); argsExp[i] = paramCastExp; } NewExpression newExp = Expression.New(ctor, argsExp); LambdaExpression lambda = Expression.Lambda(typeof(ObjectActivator <T>), newExp, param); ObjectActivator <T> compiled = (ObjectActivator <T>)lambda.Compile(); return(compiled); }
/// <summary> /// Initializes a new instance of the <see cref="ZipEntryNameSubscriptionDataSourceReader"/> class /// </summary> /// <param name="config">The subscription's configuration</param> /// <param name="date">The date this factory was produced to read data for</param> /// <param name="isLiveMode">True if we're in live mode, false for backtesting</param> public ZipEntryNameSubscriptionDataSourceReader(SubscriptionDataConfig config, DateTime date, bool isLiveMode) { _config = config; _date = date; _isLiveMode = isLiveMode; _factory = _factory = (BaseData)ObjectActivator.GetActivator(config.Type).Invoke(new object[] { config.Type }); }
public void IsFasterThanRawReflection() { int count = 100000; var data = new TradeBar(DateTime.Now, Symbols.SPY, 1m, 2m, 3m, 4m, 5); var stopwatch = Stopwatch.StartNew(); for (int i = 0; i < count; i++) { var clone = Clone(data); } stopwatch.Stop(); var elapsed1 = stopwatch.Elapsed; Console.WriteLine(elapsed1.TotalMilliseconds); stopwatch.Reset(); stopwatch.Start(); for (int i = 0; i < count; i++) { var clone = ObjectActivator.Clone(data); } stopwatch.Stop(); var elapsed2 = stopwatch.Elapsed; Console.WriteLine(elapsed2.TotalMilliseconds); Assert.Less(elapsed2, elapsed1); }
public static TInterface NewInstance <TInterface>(Type objectType, params object[] args) { ConstructorInfo ctor = objectType.GetConstructors().First(); ObjectActivator <TInterface> createdActivator = GetActivator <TInterface>(ctor); return(createdActivator(args)); }
private bool Register(Type itemType) { if (itemType.IsInterface || itemType.IsAbstract || itemType.IsValueType || !typeof(TBaseObj).IsAssignableFrom(itemType)) { //throw new Exception("Cannot register this Type!"); return(false); } ConcurrentDictionary <string, ObjectActivator <TBaseObj> > creatorSigs = new ConcurrentDictionary <string, ObjectActivator <TBaseObj> >(); foreach (ConstructorInfo ctorInfo in itemType.GetConstructors()) { string sig = GenerateSignature(ctorInfo.GetParameters().Select(p => p.ParameterType).ToArray()); ObjectActivator <TBaseObj> createdActivator = GenerateObjectActivator <TBaseObj>(ctorInfo); creatorSigs[sig] = createdActivator; } if (!m_activatorCache.TryAdd(itemType.FullName, creatorSigs)) { //throw new Exception("Could not add Activator to ActivatorCache!"); return(false); } return(true); }
/// <summary> /// Initializes a new instance of the <see cref="TextSubscriptionFactory"/> class /// </summary> /// <param name="config">The subscription's configuration</param> /// <param name="date">The date this factory was produced to read data for</param> /// <param name="isLiveMode">True if we're in live mode, false for backtesting</param> public TextSubscriptionFactory(SubscriptionDataConfig config, DateTime date, bool isLiveMode) { _date = date; _config = config; _isLiveMode = isLiveMode; _factory = (BaseData)ObjectActivator.GetActivator(config.Type).Invoke(new object[0]); }
private AccountUser CreateBasicUser() { return(ObjectActivator.CreateInstance <AccountUser>() .Set(x => x.AccountId, AccountId) .Set(x => x.Created, Removed.AddDays(-10)) .Set(x => x.UserRef, UserRef)); }
public virtual object HandleVlvRequest(DirectoryConnection connection, int maxSize, ILinqToLdapLogger log) { if (Options.YieldNoResults) { var enumerator = Options.GetEnumerator(); var bindingAttr = new[] { 0, null, 0, enumerator }; return(ObjectActivator.CreateGenericInstance(typeof(VirtualListView <>), Options.GetEnumeratorReturnType(), bindingAttr, null)); } if (GetControl <SortRequestControl>(SearchRequest.Controls) == null) { throw new InvalidOperationException("Virtual List Views require a sort operation. Please include an OrderBy in your query."); } var skip = Options.SkipSize.GetValueOrDefault(); if (GetControl <VlvRequestControl>(SearchRequest.Controls) == null) { VlvRequestControl vlvRequest = new VlvRequestControl(0, Options.TakeSize.GetValueOrDefault(maxSize) - 1, skip + 1) { IsCritical = false }; SearchRequest.Controls.Add(vlvRequest); } if (log != null && log.TraceEnabled) { log.Trace(SearchRequest.ToLogString()); } var response = connection.SendRequest(SearchRequest) as SearchResponse; response.AssertSuccess(); AssertSortSuccess(response.Controls); var vlvResponse = GetControl <VlvResponseControl>(response.Controls); if (vlvResponse == null) { throw new InvalidOperationException("The server does not support Virtual List Views. Skip cannot be used. Please use standard paging."); } var parameters = new[] { vlvResponse.ContentCount, vlvResponse.ContextId, vlvResponse.TargetPosition, Options.GetEnumerator(response.Entries) }; return(ObjectActivator.CreateGenericInstance(typeof(VirtualListView <>), Options.GetEnumeratorReturnType(), parameters, null)); }
/// <summary> /// Gets all holdings for the account /// </summary> /// <returns>The current holdings from the account</returns> public override List <Holding> GetAccountHoldings() { var holdings = _accountHoldings.Select(x => (Holding)ObjectActivator.Clone(x.Value)).ToList(); // fire up tasks to resolve the conversion rates so we can do them in parallel var tasks = holdings.Select(local => { // we need to resolve the conversion rate for non-USD currencies if (local.Type != SecurityType.Forex) { // this assumes all non-forex are us denominated, we should add the currency to 'holding' local.ConversionRate = 1m; return(null); } // if quote currency is in USD don't bother making the request string currency = local.Symbol.Substring(3); if (currency == "USD") { local.ConversionRate = 1m; return(null); } // this will allow us to do this in parallel return(Task.Factory.StartNew(() => local.ConversionRate = GetUsdConversion(currency))); }).Where(x => x != null).ToArray(); Task.WaitAll(tasks, 5000); return(holdings); }
public AbstractFieldNameTranslator GetFieldNameTranslator(ISearchIndex index) { SolrFieldMap fieldMap = index.Configuration.FieldMap as SolrFieldMap; SolrIndexSchema schema = index.Schema as SolrIndexSchema; ISettings instance = index.Locator.GetInstance <ISettings>(); SolrIndexConfiguration configuration = index.Configuration as SolrIndexConfiguration; Assert.IsNotNull(fieldMap, "FieldMap is null."); Assert.IsNotNull(schema, "SolrSchema is null."); Assert.IsNotNull(instance, "Settings is null."); Assert.IsNotNull(configuration, "This constructor requires SolrIndexConfiguration."); TemplateFieldTypeResolverFactory typeResolverFactory = configuration.TemplateFieldTypeResolverFactory; Assert.IsNotNull(typeResolverFactory, "normalizerFactory is null."); TemplateFieldTypeResolver fieldTypeResolver = typeResolverFactory.Create(); Assert.IsNotNull(fieldTypeResolver, "FieldTypeResolver is null."); SolrFieldConfigurationResolver configurationResolver = new SolrFieldConfigurationResolver(fieldMap, schema, fieldTypeResolver); var ctor = typeof(SolrFieldNameTranslator).Assembly .GetType("Sitecore.ContentSearch.SolrProvider.FieldNames.CultureContextGuard") .GetConstructors().First(); ICultureContextGuard cultureContextGuard = ObjectActivator.GetActivator <ICultureContextGuard>(ctor).Invoke(); return(new SynthesisSolrFieldNameTranslator(fieldMap, schema, instance, configurationResolver, new ExtensionStripHelper(fieldMap, schema), typeResolverFactory, cultureContextGuard)); }
public void CreateMultipleCtor() { ActivatorTestClassMultipleCtors obj; Type type = typeof(ActivatorTestClassMultipleCtors); ObjectActivator <ActivatorTestClassMultipleCtors> activator1 = type.CreateActivator <ActivatorTestClassMultipleCtors>(typeof(int), typeof(int)); ObjectActivator <ActivatorTestClassMultipleCtors> activator2 = type.CreateActivator <ActivatorTestClassMultipleCtors>(typeof(int)); ObjectActivator <ActivatorTestClassMultipleCtors> activator3 = type.CreateActivator <ActivatorTestClassMultipleCtors>(); obj = activator1(123, 123); Assert.IsNotNull(obj); Assert.AreEqual(246, obj.TestThis()); obj = activator2(123); Assert.IsNotNull(obj); Assert.AreEqual(246, obj.TestThis()); obj = activator3(); Assert.IsNotNull(obj); Assert.AreEqual(2, obj.TestThis()); }
// http://rogeralsing.com/2008/02/28/linq-expressions-creating-objects/ public static ObjectActivator GetActivator(ConstructorInfo ctor) { // Type type = ctor.DeclaringType; ParameterInfo[] paramsInfo = ctor.GetParameters(); //create a single param of type object[] ParameterExpression param = Expression.Parameter(typeof(object[]), "args"); Expression[] argsExp = new Expression[paramsInfo.Length]; //pick each arg from the params array //and create a typed expression of them for (int i = 0; i < paramsInfo.Length; i++) { Expression index = Expression.Constant(i); Type paramType = paramsInfo[i].ParameterType; Expression paramAccessorExp = Expression.ArrayIndex(param, index); Expression paramCastExp = Expression.Convert(paramAccessorExp, paramType); argsExp[i] = paramCastExp; } //make a NewExpression that calls the //ctor with the args we just created NewExpression newExp = Expression.New(ctor, argsExp); LambdaExpression lambda = Expression.Lambda(typeof(ObjectActivator), newExp, param); //compile it ObjectActivator compiled = (ObjectActivator)lambda.Compile(); return(compiled); }
public static void Run() { CodeTimer.Initialize(); var type = typeof(MessageTest <CmdTest>); var ctor = type.GetConstructors()[2]; ObjectActivator <object> createdActivator = ActivatorHelper.GetActivator <object>(ctor); var input = new CmdTest(); var header = new MessageHeaderTest(); object tmpObj = null; var count = 1000000; CodeTimer.Time("new instance", count, () => { tmpObj = new MessageTest <CmdTest>(input, header); }); CodeTimer.Time("exp tree", count, () => { tmpObj = createdActivator(input, header); }); CodeTimer.Time("Activator.CreateInstance", count, () => { tmpObj = Activator.CreateInstance(type, input, header); }); CodeTimer.Time("exp tree2", count, () => { tmpObj = ActivatorHelper.CreateInstance(type, input, header); }); }
public static TObject NewInstance <TObject>(params object[] args) { ConstructorInfo ctor = typeof(TObject).GetConstructors().First(); ObjectActivator <TObject> createdActivator = GetActivator <TObject>(ctor); return(createdActivator(args)); }
public void ClonesBaseDataDerivedTypes() { BaseData data = new IndicatorDataPoint(Symbols.SPY, DateTime.Now, 1m); BaseData clone = ObjectActivator.Clone(data) as BaseData; Assert.IsNotNull(clone); Assert.IsInstanceOf(data.GetType(), clone); Assert.AreEqual(data.Symbol, clone.Symbol); Assert.AreEqual(data.Time, clone.Time); Assert.AreEqual(data.Value, clone.Value); data = new TradeBar(DateTime.Now, Symbols.SPY, 1m, 2m, 3m, 4m, 5); var bar = ObjectActivator.Clone(data) as TradeBar; Assert.IsNotNull(clone); Assert.IsInstanceOf(data.GetType(), bar); Assert.AreEqual(data.Symbol, bar.Symbol); Assert.AreEqual(data.Time, bar.Time); Assert.AreEqual(data.Value, bar.Value); Assert.AreEqual(((TradeBar)data).Open, bar.Open); Assert.AreEqual(((TradeBar)data).High, bar.High); Assert.AreEqual(((TradeBar)data).Low, bar.Low); Assert.AreEqual(((TradeBar)data).Close, bar.Close); Assert.AreEqual(data.Price, bar.Price); }
/// <summary> /// Creates an enumerator to read the specified request. /// </summary> /// <param name="request">The subscription request to be read</param> /// <param name="dataProvider">Provider used to get data when it is not present on disk</param> /// <returns>An enumerator reading the subscription request</returns> public IEnumerator <BaseData> CreateEnumerator(SubscriptionRequest request, IDataProvider dataProvider) { var config = request.Configuration; // frontier value used to prevent emitting duplicate time stamps between refreshed enumerators // also provides some immediate fast-forward to handle spooling through remote files quickly var frontier = Ref.Create(DateTime.MinValue); var lastSourceRefreshTime = DateTime.MinValue; var sourceFactory = (BaseData)ObjectActivator.GetActivator(config.Type).Invoke(new object[] { config.Type }); // this is refreshing the enumerator stack for each new source var refresher = new RefreshEnumerator <BaseData>(() => { // rate limit the refresh of this enumerator stack var utcNow = _timeProvider.GetUtcNow(); var minimumTimeBetweenCalls = GetMinimumTimeBetweenCalls(config.Increment); if (utcNow - lastSourceRefreshTime < minimumTimeBetweenCalls) { return(Enumerable.Empty <BaseData>().GetEnumerator()); } lastSourceRefreshTime = utcNow; var localDate = utcNow.ConvertFromUtc(config.ExchangeTimeZone).Date; var source = sourceFactory.GetSource(config, localDate, true); // fetch the new source and enumerate the data source reader var enumerator = EnumerateDataSourceReader(config, dataProvider, frontier, source, localDate); if (SourceRequiresFastForward(source)) { // apply fast forward logic for file transport mediums var maximumDataAge = GetMaximumDataAge(config.Increment); enumerator = new FastForwardEnumerator(enumerator, _timeProvider, config.ExchangeTimeZone, maximumDataAge); } else { // rate limit calls to this enumerator stack enumerator = new RateLimitEnumerator <BaseData>(enumerator, _timeProvider, minimumTimeBetweenCalls); } if (source.Format == FileFormat.Collection) { // unroll collections into individual data points after fast forward/rate limiting applied enumerator = enumerator.SelectMany(data => { var collection = data as BaseDataCollection; return(collection?.Data.GetEnumerator() ?? new List <BaseData> { data }.GetEnumerator()); }); } return(enumerator); }); // prevent calls to the enumerator stack if current is in the future var timeZoneOffsetProvider = new TimeZoneOffsetProvider(request.Security.Exchange.TimeZone, request.StartTimeUtc, request.EndTimeUtc); return(new FrontierAwareEnumerator(refresher, _timeProvider, timeZoneOffsetProvider)); }
public void PythonCustomDataTypes_AreAddedToSubscriptions_Successfully() { var pythonPath = new System.IO.DirectoryInfo("RegressionAlgorithms"); Environment.SetEnvironmentVariable("PYTHONPATH", pythonPath.FullName); var qcAlgorithm = new AlgorithmPythonWrapper("Test_CustomDataAlgorithm"); // Initialize contains the statements: // self.AddData(Nifty, "NIFTY") // self.AddData(QuandlFuture, "SCF/CME_CL1_ON", Resolution.Daily) qcAlgorithm.Initialize(); var niftySubscription = qcAlgorithm.SubscriptionManager.Subscriptions.FirstOrDefault(x => x.Symbol.Value == "NIFTY"); Assert.IsNotNull(niftySubscription); var niftyFactory = (BaseData)ObjectActivator.GetActivator(niftySubscription.Type).Invoke(new object[] { niftySubscription.Type }); Assert.DoesNotThrow(() => niftyFactory.GetSource(niftySubscription, DateTime.UtcNow, false)); var quandlSubscription = qcAlgorithm.SubscriptionManager.Subscriptions.FirstOrDefault(x => x.Symbol.Value == "SCF/CME_CL1_ON"); Assert.IsNotNull(quandlSubscription); var quandlFactory = (BaseData)ObjectActivator.GetActivator(quandlSubscription.Type).Invoke(new object[] { quandlSubscription.Type }); Assert.DoesNotThrow(() => quandlFactory.GetSource(quandlSubscription, DateTime.UtcNow, false)); }
public static Object CreateInstance(Type type, params object[] args) { var ctorCount = 0; if (args != null) { ctorCount = args.Length; } var key = type.FullName + "." + ctorCount.ToString(); if (CacheMap.ContainsKey(key)) { return(CacheMap[key].Invoke(args)); } else { var ctor = type.GetConstructors()[ctorCount]; ObjectActivator <Object> createdActivator = GetActivator <Object>(ctor); CacheMap.AddOrUpdate(key, createdActivator, (k, oldValue) => createdActivator); return(createdActivator.Invoke(args)); } }
private static ObjectActivator CreateObjectActivator(ConstructorInfo ctorInfo, ParameterInfo[] parameters) { //create a single param of type object[] ParameterExpression param = Expression.Parameter(typeof(object[]), "args"); Expression[] argsExp = new Expression[parameters.Length]; //pick each arg from the params array and create a typed expression of them for (int i = 0; i < parameters.Length; i++) { Expression index = Expression.Constant(i); Type paramType = parameters[i].ParameterType; Expression paramAccessorExp = Expression.ArrayIndex(param, index); Expression paramCastExp = Expression.Convert(paramAccessorExp, paramType); argsExp[i] = paramCastExp; } // Make a NewExpression that calls the ctor with the args we just created NewExpression newExp = Expression.New(ctorInfo, argsExp); // Create a lambda with the New expression as body and our param object[] as arg LambdaExpression lambda = Expression.Lambda(typeof(ObjectActivator), newExp, param); // Compile it ObjectActivator compiled = (ObjectActivator)lambda.Compile(); return(compiled); }
/// <summary> /// Creates a type with a given name /// </summary> /// <param name="type">Python object</param> /// <returns>Type object</returns> private Type CreateType(PyObject type) { PythonActivator pythonType; if (!_pythonActivators.TryGetValue(type.Handle, out pythonType)) { AssemblyName an; using (Py.GIL()) { an = new AssemblyName(type.Repr().Split('\'')[1]); } var typeBuilder = AppDomain.CurrentDomain .DefineDynamicAssembly(an, AssemblyBuilderAccess.Run) .DefineDynamicModule("MainModule") .DefineType(an.Name, TypeAttributes.Class, typeof(DynamicData)); pythonType = new PythonActivator(typeBuilder.CreateType(), type); ObjectActivator.AddActivator(pythonType.Type, pythonType.Factory); // Save to prevent future additions _pythonActivators.Add(type.Handle, pythonType); } return(pythonType.Type); }
public void FinalizeInstanceWithDependencyDefined() { ObjectActivatorTests.TestActivator <IActivatorTest, ActivatorTest>(container => { // Arrange... // ... register more items into the container... var newBuilder = new ContainerBuilder(); newBuilder .RegisterType <ActivatorWithDependencyTest>() .As <IDependentActivatorTest>(); newBuilder .RegisterType <ObjectPortal <IDependentActivatorTest> >() .As <IObjectPortal <IDependentActivatorTest> >(); // ... append new registrations to the container given by the TestActivator Action... newBuilder.Update(container); // ... still arranging... var activator = new ObjectActivator(container); var obj = activator.CreateInstance(typeof(IDependentActivatorTest)); activator.InitializeInstance(obj); // Act... activator.FinalizeInstance(obj); // Assert... ActivatorWithDependencyTest target = (ActivatorWithDependencyTest)obj; var aDependency = target.GetType().GetProperty("ADependency", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).GetValue(target, null); Assert.IsNull(aDependency); }); }
/// <summary> /// Create new Integration Event /// </summary> /// <param name="data"></param> /// <param name="eventName"></param> /// <param name="typeOfEvent"></param> /// <returns></returns> public static IntegrationEvent CreateEventInstance(object data, Type typeOfEvent) { try { //find the contructor with one parameter which take object data type bool isCorrectConstructor(ConstructorInfo c) { var parameters = c.GetParameters(); if (parameters.Length == 1) { var firstParameter = parameters.FirstOrDefault(); if (firstParameter?.ParameterType == data.GetType()) { return(true); } } return(false); } ConstructorInfo ctor = (typeOfEvent.GetConstructors().First(isCorrectConstructor)); ObjectActivator createdActivator = GetActivator(ctor); IntegrationEvent instance = createdActivator(data); return(instance); } catch (Exception) { return(new DefaultIntegrationEvent(data, typeOfEvent.Name)); } }
public void PythonCustomDataTypes_AreAddedToSubscriptions_Successfully() { var qcAlgorithm = new AlgorithmPythonWrapper("Test_CustomDataAlgorithm"); qcAlgorithm.SubscriptionManager.SetDataManager(new DataManagerStub(qcAlgorithm)); // Initialize contains the statements: // self.AddData(Nifty, "NIFTY") // self.AddData(CustomPythonData, "IBM", Resolution.Daily) qcAlgorithm.Initialize(); var niftySubscription = qcAlgorithm.SubscriptionManager.Subscriptions.FirstOrDefault(x => x.Symbol.Value == "NIFTY"); Assert.IsNotNull(niftySubscription); var niftyFactory = (BaseData)ObjectActivator.GetActivator(niftySubscription.Type).Invoke(new object[] { niftySubscription.Type }); Assert.DoesNotThrow(() => niftyFactory.GetSource(niftySubscription, DateTime.UtcNow, false)); var customDataSubscription = qcAlgorithm.SubscriptionManager.Subscriptions.FirstOrDefault(x => x.Symbol.Value == "IBM"); Assert.IsNotNull(customDataSubscription); Assert.IsTrue(customDataSubscription.IsCustomData); Assert.AreEqual("custom_data.CustomPythonData", customDataSubscription.Type.ToString()); var customDataFactory = (BaseData)ObjectActivator.GetActivator(customDataSubscription.Type).Invoke(new object[] { customDataSubscription.Type }); Assert.DoesNotThrow(() => customDataFactory.GetSource(customDataSubscription, DateTime.UtcNow, false)); }
public IDataSource CreateLocalDataSourceConnection(ConnectionProperties dataConnection, string pdatasourcename, string ClassDBHandlerName) { ErrorObject.Flag = Errors.Ok; IDataSource ds = null; ConnectionDriversConfig package = null; if (ConfigEditor.DataDriversClasses.Where(x => x.classHandler == ClassDBHandlerName).Any()) { package = ConfigEditor.DataDriversClasses.Where(x => x.classHandler == ClassDBHandlerName).FirstOrDefault(); string packagename = ConfigEditor.DataSourcesClasses.Where(x => x.className == package.classHandler).FirstOrDefault().PackageName; Type adc = assemblyHandler.GetType(packagename); ConstructorInfo ctor = adc.GetConstructors().First(); ObjectActivator <IDataSource> createdActivator = GetActivator <IDataSource>(ctor); //create an instance: ds = createdActivator(dataConnection.ConnectionName, Logger, this, dataConnection.DatabaseType, ErrorObject); } try { if (ds != null) { ds.Dataconnection.ConnectionProp = dataConnection; ds.Dataconnection.DataSourceDriver = package; ds.Dataconnection.ReplaceValueFromConnectionString(); ILocalDB dB = (ILocalDB)ds; DataSources.Add(ds); AddLogMessage("Fail", $"Success Created Local Database {pdatasourcename}", DateTime.Now, -1, "", Errors.Failed); return(ds); } else { AddLogMessage("Fail", "Could Find DataSource Drivers", DateTime.Now, 0, pdatasourcename, Errors.Failed); return(null); } // bool ok= dB.CreateDB(); // if (ok) // { // ds.ConnectionStatus = ds.Dataconnection.OpenConnection(); //if (ds.ConnectionStatus == ConnectionState.Open) //{ // ConfigEditor.DataConnections.Add(dataConnection); //}else //{ // return null; //} } catch (Exception ex) { AddLogMessage("Fail", $"Error in Opening Connection (Check DLL for Connection drivers,connect string, Datasource down,Firewall, .. etc)({ex.Message})", DateTime.Now, -1, "", Errors.Failed); return(null); } }
/// <summary> /// Initializes a new instance of the <see cref="CollectionSubscriptionDataSourceReader"/> class /// </summary> /// <param name="dataCacheProvider">Used to cache data for requested from the IDataProvider</param> /// <param name="config">The subscription's configuration</param> /// <param name="date">The date this factory was produced to read data for</param> /// <param name="isLiveMode">True if we're in live mode, false for backtesting</param> public CollectionSubscriptionDataSourceReader(IDataCacheProvider dataCacheProvider, SubscriptionDataConfig config, DateTime date, bool isLiveMode) { _dataCacheProvider = dataCacheProvider; _date = date; _config = config; _isLiveMode = isLiveMode; _factory = (BaseData)ObjectActivator.GetActivator(config.Type).Invoke(new object[] { config.Type }); }
public ObjectCreator(Type type) { _objectActivator = DelegateFactory.CreateCtor(type); _setters = type .GetTypeInfo() .GetProperties() .ToDictionary(x => x.Name, x => DelegateFactory.CreatePropertySetter(x), StringComparer.OrdinalIgnoreCase); }
public SeedAccountUsersJobTestsFixture AddUserOwnerRoleToReadStore() { ReadStoreUsers.Add(ObjectActivator.CreateInstance <AccountUser>() .Set(x => x.UserRef, UserOwnerRole.User.Ref) .Set(x => x.AccountId, UserOwnerRole.AccountId)); return(this); }
public static void SetPool(ObjectActivator <T> objectGenerator) { if (_objectPools != null) { return; } _objectPools = new ObjectPool <T>(objectGenerator); }
public object GetReceivedMessage(object[] obj) { if (activator == null) { var genericType = typeof(ReceivedMessage<>).MakeGenericType(MessageType); //object receivedMessage = Activator.CreateInstance(gt, new object[] { state.Message, msg, values }); ConstructorInfo ctor = genericType.GetConstructors().First(); activator = ReflectionHelper.GetActivator(ctor); } //create an instance: return activator(obj); }
public TypeActivators(Type type) { var ctors = type.GetConstructors(); var parameterlessCtor = ctors.Where(x => x.GetParameters().Length == 0).SingleOrDefault(); if (parameterlessCtor != default(ConstructorInfo)) { singleActivator = BuildActivator(parameterlessCtor).Value; } foreach (ConstructorInfo ctor in type.GetConstructors()) { var fpCtor = ctor; var activator = BuildActivator(fpCtor); var newValue = new ConcurrentDictionary<ConstructorInfo, ObjectActivator>(); newValue.TryAdd(fpCtor, activator.Value); Func<int, ConcurrentDictionary<ConstructorInfo, ObjectActivator>, ConcurrentDictionary<ConstructorInfo, ObjectActivator>> updateAction = (key, val) => { val.AddOrUpdate(fpCtor, activator.Value, (k, v) => activator.Value); return val; }; typeActivators.AddOrUpdate(activator.Key, newValue, updateAction); } }
public ConstructorDefinition(object[] argValues, ObjectActivator objectActivator) { this.objectActivator = objectActivator; this.contructorArgValues = argValues; }
/// <summary> /// Sets the constructor to use /// </summary> /// <param name="constructor"></param> public virtual void SetConstructor(ConstructorInfo constructor) { Constructor = constructor; _parameters = new ConstructorParameter[Constructor.GetParameters().Length]; _factoryMethod = GetCreateDelegate(); }