/// <summary> /// Creates an instance of <paramref name="type"/>. /// </summary> /// <param name="type">The <see cref="Type"/> of object to create</typeparam> /// <returns>An instance of <paramref name="type"/>.</returns> public static object CreateInstance(Type type) { Guard.ArgumentNotNull(type, "type"); ConstructorDelegate _activator = null; if (!_activators.TryGetValue(type, out _activator)) { var _constructor = type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, EMPTY_PARAMETER_TYPE, null); if (_constructor == null) { _constructor = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, EMPTY_PARAMETER_TYPE, null); } _activator = CreateConstructorDelegate(_constructor); lock (_lock) { // double check and add if (!_activators.ContainsKey(type)) { _activators.Add(type, _activator); } } } // and return return(_activator()); }
/// <summary> /// Initializes a new instance of the <see cref="Constructor"/> class. /// </summary> /// <param name="delegate">The delegate.</param> public Constructor(ConstructorDelegate @delegate) { ConstructorDelegate = @delegate; ParameterLength = 0; Parameters = Array.Empty <Type>(); ParameterNullable = Array.Empty <bool>(); }
private static ReadOnlyDictionary <string, Constructor> BuildControllerMap() { var attribType = typeof(StateControllerNameAttribute); var constructortypes = new[] { typeof(StateSystem), typeof(string), typeof(TextSection) }; var controllermap = new Dictionary <string, Constructor>(StringComparer.OrdinalIgnoreCase); foreach (var t in Assembly.GetCallingAssembly().GetTypes()) { if (t.IsSubclassOf(typeof(StateController)) == false || Attribute.IsDefined(t, attribType) == false) { continue; } var attrib = (StateControllerNameAttribute)Attribute.GetCustomAttribute(t, attribType); foreach (var name in attrib.Names) { if (controllermap.ContainsKey(name)) { Log.Write(LogLevel.Warning, LogSystem.StateSystem, "Duplicate definition found for state controller - {0}.", name); } else { controllermap.Add(name, ConstructorDelegate.FastConstruct(t, constructortypes)); } } } return(new ReadOnlyDictionary <string, Constructor>(controllermap)); }
/// <summary> /// Регистрация нового объекта игрового уровня. /// </summary> /// <param name='levelObject'> /// Игровой объект. /// </param> public void Register(String name, ConstructorDelegate constructorDelegate) { if (m_AllDelegates.ContainsKey(name) || null == constructorDelegate) { return; } m_AllDelegates.Add(name, constructorDelegate); }
public void Set <T>(ConstructorDelegate <T> constructor) where T : class { if (deps.ContainsKey(typeof(T))) { return; } var dep = new Dependency <T>(constructor()); deps.Add(typeof(T), dep); }
public UndoableObservableCollection(ObservableCollection <SourceT> source, ConstructorDelegate ctor) { _ctor = ctor; _source = source; // Initialize from source this.AddRange(source.Select(s => _ctor(s))); _source.CollectionChanged += source_CollectionChanged; }
/// <summary> /// Возвращает объект игрового уровня по его описателю. /// </summary> /// <returns> /// Объект игрового уровня, либо null, если соответствующего описателю объекта не найдено. /// </returns> /// <param name='sObjectDescriptor'> /// Описатель объекта. /// </param> public SelfRegistrable GetObjectByDescriptor(String name) { if (!m_AllDelegates.ContainsKey(name)) { return(null); } ConstructorDelegate constructorDelegate = m_AllDelegates[name]; return(constructorDelegate()); }
/// <summary> /// Creates a new instance of the safe constructor wrapper. /// </summary> /// <param name="constructorInfo">Constructor to wrap.</param> public SafeConstructor(ConstructorInfo constructorInfo) { _constructorInfo = constructorInfo; try { _constructor = DynamicReflectionManager.CreateConstructor(constructorInfo); } catch { _isOptimized = false; } }
public Base Create <U>() where U : Base { ConstructorInfo ci = currentType.GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null); DynamicMethod dm = new DynamicMethod("CreateInstance", typeof(Base), Type.EmptyTypes, typeof(ClassReference)); ILGenerator il = dm.GetILGenerator(); il.Emit(OpCodes.Newobj, ci); il.Emit(OpCodes.Ret); ConstructorDelegate del = (ConstructorDelegate)dm.CreateDelegate(typeof(ConstructorDelegate)); return(del()); }
public static List <T> Map <T>(DataTable source) where T : class { List <T> mappedList = new List <T>(); using (SqlDataMappingInfo <T> propMap = new SqlDataMappingInfo <T>()) { try { IEnumerable <PropertyInfo> properties = typeof(T).GetProperties(); if (properties != null && properties.Count() > 0) { properties = properties.Where(pi => pi.CanWrite); } if (properties == null || properties.Count() == 0) { return(null); } foreach (PropertyInfo prop in properties) { propMap.Add(prop, source.Columns); } } catch (Exception) { } var constructor = new ConstructorDelegate <T>(() => (T)Activator.CreateInstance(typeof(T))); //CreateConstructor<T>(); foreach (DataRow row in source.Rows) { T map = constructor();// (T)Activator.CreateInstance(typeof(T)); #region set properties foreach (SqlMappingInfo <T> mapping in propMap.Values) //(PropertyInfo propInfo in properties) { if (mapping?.SetValue == null || row.IsNull(mapping.ColumnNumber)) { continue; } mapping.SetValue(map, row[mapping.ColumnNumber]); } #endregion set properties mappedList.Add(map); } } return(mappedList); }
/// <summary> /// Obtains cached constructor info or creates a new entry, if none is found. /// </summary> private static ConstructorDelegate GetOrCreateDynamicConstructor(ConstructorInfo constructorInfo) { ConstructorDelegate method = (ConstructorDelegate)constructorCache[constructorInfo]; if (method == null) { method = DynamicReflectionManager.CreateConstructor(constructorInfo); lock (constructorCache) { constructorCache[constructorInfo] = method; } } return(method); }
public void ForObjectWithoutParametarlessConstructorExceptionIsThrown() { bool error = false; try { ConstructorDelegate.GetConstructor <Models.NoValidCtor>(); } catch (Exception) { error = true; } Assert.True(error); }
ConstructorDelegate GetConstructor(string typeName) { Type t = Type.GetType(typeName); ConstructorInfo ctor = t.GetConstructor(new Type[0]); string methodName = t.Name + "Ctor"; DynamicMethod dm = new DynamicMethod(methodName, t, new Type[0], typeof(Activator)); ILGenerator lgen = dm.GetILGenerator(); lgen.Emit(OpCodes.Newobj, ctor); lgen.Emit(OpCodes.Ret); ConstructorDelegate creator = (ConstructorDelegate)dm.CreateDelegate(typeof(ConstructorDelegate)); return(creator); }
///<summary> /// Creates a new delegate for the specified constructor. ///</summary> ///<param name="constructorInfo">the constructor to create the delegate for</param> ///<returns>delegate that can be used to invoke the constructor.</returns> public static ConstructorDelegate CreateConstructor(ConstructorInfo constructorInfo) { Guard.ArgumentNotNull(constructorInfo, "You cannot create a dynamic constructor for a null value."); bool skipVisibility = true; //!IsPublic(constructorInfo); System.Reflection.Emit.DynamicMethod dmGetter; Type[] argumentTypes = new Type[] { typeof(object[]) }; dmGetter = CreateDynamicMethod(constructorInfo.Name, typeof(object), argumentTypes, constructorInfo, skipVisibility); ILGenerator il = dmGetter.GetILGenerator(); EmitInvokeConstructor(il, constructorInfo, false); ConstructorDelegate ctor = (ConstructorDelegate)dmGetter.CreateDelegate(typeof(ConstructorDelegate)); return(ctor); }
protected ConstructorDelegate GetConstructor(string typeName) { // 获得 type 的默认构造函数的引用 Type t = Type.GetType(typeName); ConstructorInfo ctor = t.GetConstructor(new Type[0]); // 创建 dynamic method string methodName = t.Name + "Ctor"; // api compatibility level 要到 .net 4.x DynamicMethod dm = new DynamicMethod(methodName, t, new Type[0], typeof(Activator)); ILGenerator ilGenerator = dm.GetILGenerator(); ilGenerator.Emit(OpCodes.Newobj, ctor); ilGenerator.Emit(OpCodes.Ret); ConstructorDelegate creator = (ConstructorDelegate)dm.CreateDelegate(typeof(ConstructorDelegate)); return(creator); }
protected ConstructorDelegate GetConstructor(string TypeName) { //Get the defaul constructor of the type Type t = Type.GetType(TypeName); ConstructorInfo ctor = t.GetConstructor(new Type[0]); // create a new dynamic method that constructs and returns the type string methodName = t.Name + "Ctor"; DynamicMethod dm = new DynamicMethod(methodName, t, new Type[0], typeof(Activator)); ILGenerator lgen = dm.GetILGenerator(); lgen.Emit(OpCodes.Newobj, ctor); lgen.Emit(OpCodes.Ret); //add delegate to dictionary and return ConstructorDelegate creator = (ConstructorDelegate)dm.CreateDelegate(typeof(ConstructorDelegate)); //return a delegate to the method return(creator); }
// Creates a new GObject wrapper // Actual assignment of the wrapper's pointer is // deferred until either InitWrapper() is called or the // Handle is requested (in which case a new object is // created). public Object() { // If we are not wrapping an existing GObject type, // then we are a subclass by definition isSubclass = IsManaged(this.GetType()); // If not a subclass, register type // TODO: Is this necessary or just a waste or CPU time? if (!isSubclass) { GType.Register(ResolveGType(this.GetType()), this.GetType()); } if (isSubclass) { // Make sure we initialise the class Console.WriteLine("Class Initialisation goes here!"); } defaultConstructor = delegate() { return(g_object_new_with_properties(GType.Object, 0, IntPtr.Zero, null)); }; }
static ConstructorDelegate GetConstructor <T>() { Type t = typeof(T); if (_constructorCache.ContainsKey(t)) { return(_constructorCache[t]); } ConstructorInfo ctor = t.GetConstructor(new Type[0]); string methodName = t.Name + "Ctor"; DynamicMethod dm = new DynamicMethod(methodName, t, new Type[0], typeof(Activator)); ILGenerator lgen = dm.GetILGenerator(); lgen.Emit(OpCodes.Newobj, ctor); lgen.Emit(OpCodes.Ret); ConstructorDelegate creator = (ConstructorDelegate)dm.CreateDelegate(typeof(ConstructorDelegate)); _constructorCache[t] = creator; return(creator); }
/// <summary> /// Creates a new instance of the safe constructor wrapper. /// </summary> /// <param name="constructorInfo">Constructor to wrap.</param> public SafeConstructor(ConstructorInfo constructorInfo) { this.constructorInfo = constructorInfo; this.constructor = GetOrCreateDynamicConstructor(constructorInfo); }
/// <summary> /// Initializes a new instance of <see cref="TypeAccessor"/>. /// </summary> /// <param name="type">The type to access.</param> /// <param name="propertyFilter">A filter to filter out properties to access.</param> public TypeAccessor(Type type, Func <PropertyInfo, bool> propertyFilter = null) { Type = type; _ctor = CreateConstructor(Type); _propertyAccessors = CreatePropertyAccessors(Type, propertyFilter); }
public virtual void EachConstructor(ConstructorDelegate constructorDelegate) { foreach (ConstructorInfo constructor in ClassType.GetConstructors(bindingFlag)) { constructorDelegate.Invoke(constructor); } }
private static void CreateByLocalConstructor() { ConstructorDelegate de = GetConstructor <StringBuilder>(); StringBuilder builder = de() as StringBuilder; }
public static List <T> Map <T>(SqlDataReader source) where T : class { List <T> mappedList = new List <T>(); if (source == null || !source.HasRows) { return(mappedList); } //Dictionary<PropertyInfo, string> propertyMap = new Dictionary<PropertyInfo, string>(); //Dictionary<PropertyInfo, Action<T, object>> setMap = new Dictionary<PropertyInfo, Action<T, object>>(); using (SqlDataMappingInfo <T> propMap = new SqlDataMappingInfo <T>()) { try { string[] columns = new string[source.FieldCount]; for (int i = 0; i < source.FieldCount; ++i) { columns[i] = source.GetName(i).ToUpper().Trim(); } IEnumerable <PropertyInfo> properties = typeof(T).GetProperties(); if (properties != null && properties.Count() > 0) { properties = properties.Where(pi => pi.CanWrite); } if (properties == null || properties.Count() == 0) { return(null); } foreach (PropertyInfo prop in properties) { propMap.Add(prop, columns); } } catch (Exception) { } var constructor = new ConstructorDelegate <T>(() => (T)Activator.CreateInstance(typeof(T))); do { while (source.Read()) { T map = constructor(); //(T)Activator.CreateInstance(typeof(T)); #region set properties foreach (SqlMappingInfo <T> mapping in propMap.Values) //(PropertyInfo propInfo in properties) { if (mapping?.SetValue == null || source.IsDBNull(mapping.ColumnNumber)) { continue; } mapping.SetValue(map, source.GetValue(mapping.ColumnNumber)); } #endregion set properties mappedList.Add(map); } } while (source.NextResult()); } return(mappedList); }
/// <summary> /// Creates an instance of a type using the constructor. /// </summary> /// <typeparam name="T">Type of class.</typeparam> /// <param name="type">Type of class.</param> /// <returns>Created object instance.</returns> internal static T Create <T>(Type type) where T : class { ConstructorDelegate creator = CreateConstructorDelegate(type); return(creator() as T); }
/// <summary> /// Регистрация делегата для создания объекта в фабрике объектов под указанным именем. /// </summary> /// <param name='name'> /// Имя, под которым будет вызываться новый объект из фабрики объектов. /// </param> /// <param name='ctor'> /// Делегат для создания объекта, который необходимо зарегистрировать. /// </param> static public void Register(String name, ConstructorDelegate constructorDelegate) { m_RegistrableFactory.Register(name, constructorDelegate); }
private Clonable CloneImpl(ref List<CloneDelegate> cloneDelegates, Dictionary<Type, DynamicMethod> cloneMethods) { if (cloneDelegates == null) { cloneDelegates = new List<CloneDelegate>(); for (var klass = GetType(); klass != null && cloneMethods.ContainsKey(klass); klass = klass.BaseType) cloneDelegates.Add((CloneDelegate)cloneMethods[klass].CreateDelegate(typeof(CloneDelegate), this)); } if (_constructorDelegate == null) _constructorDelegate = (ConstructorDelegate)g_constructors[GetType()].CreateDelegate(typeof(ConstructorDelegate), this); var clone = _constructorDelegate(); for (int i = 0; i < cloneDelegates.Count; ++i) cloneDelegates[i](clone); clone.Cloned(); return clone; }