private void RegisterObjectFactoryMethod(ITemplate factory, MethodInfo method, FactoryMethodAttribute attrib) { Type objectType = method.ReturnType; if (method.GetParameters().Length != 0) { throw ExceptionHelper.FactoryParameterCountException(); } if (attrib.FactoryId != null) { FactoryDelegate factoryDelegate = CreateMethodFactoryDelegate(factory, method); RegisterObjectFactoryMethod(attrib.FactoryId, factoryDelegate, attrib.InstanceMode); } else if (attrib.RegisterAs == FactoryType.DefaultForType) { FactoryDelegate factoryDelegate = CreateMethodFactoryDelegate(factory, method); Type defaultType = method.ReturnType; RegisterObjectFactoryMethod(defaultType, factoryDelegate, attrib.InstanceMode); } else { string objectId = method.Name; FactoryDelegate factoryDelegate = CreateMethodFactoryDelegate(factory, method); RegisterObjectFactoryMethod(objectId, factoryDelegate, attrib.InstanceMode); } }
public void GetTypeFactory_ArgsMismatchInBuilding_ReturnsNull() { FactoryDelegate factory = DynamicMethodGenerator.GetTypeFactory( typeof(Example), typeof(string), typeof(string), typeof(string)); Assert.Null(factory); }
public static T GetFromParentOrCurrent<T>(FactoryDelegate<T> fd, FactoryInfo<T> fi, IResolverContext r) { var id = fi.Id; for (var s = r.CurrentScope; s != null; s = s.Parent) if (s.TryGet(out var res, id)) return (T)res; return fd(r); }
public void GetTypeFactory_1MillionInstantiationsAlt_PerformsInAround50ms() { FactoryDelegate factory = DynamicMethodGenerator.GetTypeFactory(typeof(Example), Type.EmptyTypes); for (long i = 0; i < MaxCount; i++) { Example instance = (Example)factory(); } }
private ObjectFactoryInfo CreateObjectFactory(string displayName, FactoryDelegate factoryDelegate, InstanceMode instanceMode) { ObjectFactoryInfo factory = new ObjectFactoryInfo(); factory.FactoryDelegate = factoryDelegate; factory.InstanceMode = instanceMode; factory.DisplayName = displayName; return(factory); }
public override DataPresenter With(FactoryDelegate <DataReader> createDataReader) { Log.Enter(nameof(FactoryDelegate <DataReader>)); _createDataReader = createDataReader; Log.Exit(); return(this); }
public void GetTypeFactory_NullCtorInput_ThrowsArgumentNullException() { ArgumentNullException ex = Assert.Throws <ArgumentNullException>( delegate() { FactoryDelegate factory = DynamicMethodGenerator.GetTypeFactory((ConstructorInfo)null); }); Assert.Equal("ctor", ex.ParamName); }
public void GetTypeFactory_NullTypeInputAlt_ThrowsArgumentNullException() { ArgumentNullException ex = Assert.Throws <ArgumentNullException>( delegate() { FactoryDelegate factory = DynamicMethodGenerator.GetTypeFactory((Type)null, Type.EmptyTypes); }); Assert.Equal("type", ex.ParamName); }
private FactoryDelegate CreateMethodFactoryDelegate(ITemplate factory, MethodInfo method) { ConstantExpression instance = Expression.Constant(factory); MethodCallExpression call = Expression.Call(instance, method); Expression body = Expression.TypeAs(call, typeof(object)); LambdaExpression lambda = Expression.Lambda(typeof(FactoryDelegate), body); FactoryDelegate factoryDelegate = (FactoryDelegate)lambda.Compile(); return(factoryDelegate); }
/// <summary> /// Register the given factory delegate to be called when the container is /// asked to resolve <typeparamref name="=TTypeToBuild"/> and <paramref name="name"/>. /// </summary> /// <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam> /// <param name="name">The name that will be used when requesting to resolve this type.</param> /// <param name="factoryMethod">Delegate to invoke to create the instance.</param> /// <returns>The container extension object this method was invoked on.</returns> public IStaticFactoryConfiguration RegisterFactory <TTypeToBuild>( string name, FactoryDelegate factoryMethod) { FactoryBuildPlanDelegate planDelegate = delegate { return(factoryMethod(Container)); }; Context.Policies.Set <IBuildPlanPolicy>( new FactoryDelegateBuildPlanPolicy(planDelegate), NamedTypeBuildKey.Make <TTypeToBuild>(name)); return(this); }
FactoryDelegate this [string s] { set { var = value; } get { return(var); } }
/// <summary> /// Creates the default thread local. /// </summary> /// <returns></returns> public static IThreadLocal <T> CreateDefaultThreadLocal <T>(FactoryDelegate <T> factoryDelegate) where T : class { var localFactory = DefaultThreadLocalFactory; if (localFactory == null) { throw new ApplicationException("default thread local factory is not set"); } return(localFactory.CreateThreadLocal(factoryDelegate)); }
public ObjectPool(FactoryDelegate factory, string containerN, int quantity = 5) { _objects = new Stack <GameObject>(); _factory = factory; _containerGameObject = GameObject.FindGameObjectWithTag(containerN); if (quantity >= 0) { for (int i = 0; i < quantity; i++) { _objects.Push(Create()); } } }
public void GetTypeFactory_ArgsMissingWhenCalling_ThrowsArgumentNullException() { FactoryDelegate factory = DynamicMethodGenerator.GetTypeFactory( typeof(Example), typeof(string), typeof(string), typeof(string), typeof(int), typeof(int), typeof(int), typeof(string), typeof(string), typeof(string)); Assert.NotNull(factory); TypeLoadException ex = Assert.Throws <TypeLoadException>( delegate() { var actual = (Example)factory("alpha", "bravo", "charlie", -1, -2, -3); }); }
public void GetTypeFactory_ArgsTypeMismatchWhenCalling_ThrowsArgumentNullException() { FactoryDelegate factory = DynamicMethodGenerator.GetTypeFactory( typeof(Example), typeof(string), typeof(string), typeof(string), typeof(int), typeof(int), typeof(int), typeof(string), typeof(string), typeof(string)); Assert.NotNull(factory); InvalidCastException ex = Assert.Throws <InvalidCastException>( delegate() { var actual = (Example)factory(1, 2, 3, 4, 5, 6, 7, 8, 9); }); }
partial static void CompileToDelegate(Expression expression, ref FactoryDelegate result) { var method = new DynamicMethod(string.Empty, typeof(object), _factoryDelegateArgTypes, typeof(Container).Module, skipVisibility: true); var il = method.GetILGenerator(); var emitted = EmittingVisitor.TryVisit(expression, il); if (emitted) { il.Emit(OpCodes.Ret); result = (FactoryDelegate)method.CreateDelegate(typeof(FactoryDelegate)); } }
/// <summary> /// Get service of given type. /// </summary> /// <param name="serviceType"></param> /// <param name="context"></param> /// <returns></returns> public virtual object GetService ( Type serviceType, ServiceContext context) { Trace.WriteLine("in RemotingServer.GetService"); if (Paused) { throw new ServicePausedException(); } FactoryDelegate factory = _map [serviceType]; object service = factory(); return(service); }
static partial void CompileToDelegate(Expression expression, ref FactoryDelegate result) { var method = new DynamicMethod(string.Empty, typeof(object), _factoryDelegateArgTypes, typeof(Container).Module, skipVisibility: true); var il = method.GetILGenerator(); var emitted = EmittingVisitor.TryVisit(expression, il); if (emitted) { il.Emit(OpCodes.Ret); result = (FactoryDelegate)method.CreateDelegate(typeof(FactoryDelegate)); } }
/// <summary> /// Initializes a new instance of the <see cref="XperThreadLocal{T}"/> class. /// </summary> /// <param name="factory">The factory.</param> public XperThreadLocal(FactoryDelegate <T> factory) { _primeIndex = 0; var tableSize = Prime.HashPrimes[_primeIndex]; _hashIndex = new int[tableSize]; for (int ii = 0; ii < tableSize; ii++) { _hashIndex[ii] = -1; } _nodeTable = new Node[tableSize]; _valueFactory = factory; _wLock = new SlimLock(); }
/// <summary> /// Register a new factory with the registery. Replaces an existing /// factory if the scheme is already registered. /// </summary> static public void Register(string scheme, FactoryDelegate factory) { if (_registry == null) { _registry = new Dictionary <string, FactoryDelegate>(16); } // Register Scheme if (!_registry.ContainsKey(scheme)) { _registry.Add(scheme, factory); } else { _registry[scheme] = factory; } }
public IFoo GetOrCreate2(IResolverContext ctx, FactoryDelegate <Func <string, IFoo> > fooFactory, string address) { // fancy ensuring that we have a single new Scope created and stored var scopeEntry = _scopes.GetEntryOrDefault(address); if (scopeEntry == null) { Ref.Swap(ref _scopes, address, (x, a) => x.AddOrKeep(a)); scopeEntry = _scopes.GetEntryOrDefault(address); } lock (scopeEntry) if (scopeEntry.Value == null || scopeEntry.Value.IsDisposed) { scopeEntry.Value = ctx.OpenScope(address); } return(fooFactory(scopeEntry.Value).Invoke(address)); }
public void GetTypeFactory_CtorNoArgsAlt_ReturnsCorrectlyInstantiatedObject() { var expected = new Example(); FactoryDelegate factory = DynamicMethodGenerator.GetTypeFactory(typeof(Example), Type.EmptyTypes); Assert.NotNull(factory); var actual = (Example)factory(); var getters = from m in typeof(Example).GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy) let g = DynamicMethodGenerator.GetGetter(m) where (g != null) select g; foreach (GetterDelegate getter in getters) { // assert all of the fields and properties are equal Assert.Equal(getter(expected), getter(actual)); } }
public override void Dispose() { Log.Enter(); Log.Info($"Terminating DataReader session: {_dataReaderSession != null}"); _dataReaderSession?.Dispose(); _dataReaderSession = null; _createDataReader = null; Log.Info($"Disposing data provider: {_dataProvider != null}"); _dataProvider?.Dispose(); _dataProvider = null; Log.Info($"Disposing ESPlayer: {_esPlayer != null}"); _esPlayer?.Dispose(); _esPlayer = null; ErrorHandler = null; EosHandler = null; Log.Exit(); }
private static void _Add ( Type intf, Type implementor) { MethodInfo miFound = null; foreach ( MethodInfo mi in implementor.GetMethods ( BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)) { if (mi.GetCustomAttributes ( typeof(FactoryMethodAttribute), false) != null) { miFound = mi; break; } } if (miFound == null) { throw new ArgumentException("implementor"); } FactoryDelegate fd = (FactoryDelegate) Delegate.CreateDelegate ( typeof(FactoryDelegate), null, miFound, true); _map [intf] = fd; }
public void GetTypeFactory_CtorExtraArgs_IgnoresAndReturnsCorrectlyInstantiatedObject() { var expected = new Example("alpha", "bravo", "charlie", -1, -2, -3, "deer", "sun", "myself"); FactoryDelegate factory = DynamicMethodGenerator.GetTypeFactory( typeof(Example), typeof(string), typeof(string), typeof(string), typeof(int), typeof(int), typeof(int), typeof(string), typeof(string), typeof(string)); Assert.NotNull(factory); var actual = (Example)factory("alpha", "bravo", "charlie", -1, -2, -3, "deer", "sun", "myself", 4, 5, 6, "extra", false); var getters = from m in typeof(Example).GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy) let g = DynamicMethodGenerator.GetGetter(m) where (g != null) select g; foreach (GetterDelegate getter in getters) { // assert all of the fields and properties are equal Assert.Equal(getter(expected), getter(actual)); } }
/// <summary> /// Create a thread local object of the specified type param. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="factory"></param> /// <returns></returns> public IThreadLocal <T> CreateThreadLocal <T>(FactoryDelegate <T> factory) where T : class { return(new FastThreadLocal <T>(factory)); }
/// <summary> /// Initializes a new instance of the <see cref="FastThreadLocal<T>"/> class. /// </summary> /// <param name="factory">The factory.</param> public FastThreadLocal(FactoryDelegate <T> factory) { _instanceId = AllocateIndex(); _dataFactory = factory; }
public static T Set(FactoryDelegate <T> factoryMethod) { factory = factoryMethod; return(Instance); }
/// <summary> /// Initializes a new instance of the <see cref="SystemThreadLocal<T>"/> class. /// </summary> /// <param name="factory">The factory used to create values when not found.</param> public SystemThreadLocal(FactoryDelegate <T> factory) { m_dataStoreSlot = Thread.AllocateDataSlot(); m_dataFactory = factory; }
FactoryDelegate this [string s] { set { var = value; } get { return var; } }
partial static void CompileToMethod(Expression<FactoryDelegate> factoryExpression, Rules rules, ref FactoryDelegate result) { if (!rules.FactoryDelegateCompilationToDynamicAssembly) return; result.ThrowIf(result != null); var typeName = "Factory" + Interlocked.Increment(ref _typeId); var typeBuilder = GetDynamicAssemblyModuleBuilder().DefineType(typeName, TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Abstract); var methodBuilder = typeBuilder.DefineMethod( "GetService", MethodAttributes.Public | MethodAttributes.Static, typeof(object), new[] { typeof(AppendableArray), typeof(IResolverContextProvider), typeof(IScope) }); factoryExpression.CompileToMethod(methodBuilder); var dynamicType = typeBuilder.CreateType(); result = (FactoryDelegate)Delegate.CreateDelegate(typeof(FactoryDelegate), dynamicType.GetMethod("GetService")); }
/// <summary> /// Creates a thread local instance. /// </summary> /// <returns></returns> public static IThreadLocal <T> Create <T>(FactoryDelegate <T> factoryDelegate) where T : class { return(CreateDefaultThreadLocal(factoryDelegate)); }
public abstract DataPresenter With(FactoryDelegate <DataReader> createDataReader);