private static object DeserializeArray(BinaryReader sourceReader, Type elementType, int elementSize, int elementCount) { var arrayDataAddress = sourceReader.BaseStream.Position; var fields = elementType.Fields( Flags.Public | Flags.NonPublic | Flags.Instance); List<FieldDelegateInformation> fieldMethods; var item = elementType.CreateInstance(); ProcessFieldTypes(fields, out fieldMethods); var array = elementType.MakeArrayType().CreateInstance(elementCount); for (var i = 0; i < elementCount; ++i) { var element = elementType.CreateInstance(); sourceReader.BaseStream.Position = arrayDataAddress + i * elementSize; InvokeFields(sourceReader, element, fields, fieldMethods); array.SetElement(i, element); } return array; }
private static ModelInterfaceExtenders GetModelInterfaceExtenders(Type moduleType) { var modelInterfaceExtenders = new ModelInterfaceExtenders(); if (typeof(XpandModuleBase).IsAssignableFrom(moduleType)){ XpandModuleBase.CallMonitor.Clear(); ((XpandModuleBase)moduleType.CreateInstance()).ExtendModelInterfaces(modelInterfaceExtenders); } if (typeof(IModelExtender).IsAssignableFrom(moduleType)) ((IModelExtender) moduleType.CreateInstance()).ExtendModelInterfaces(modelInterfaceExtenders); return modelInterfaceExtenders; }
public ExactContractJsonConverterAttribute(Type jsonConverter) { if (typeof(JsonConverter).IsAssignableFrom(jsonConverter)) { Converter = jsonConverter.CreateInstance<JsonConverter>(); } }
public bool Convert(Type targetType, object owner, ref object value) { if (!(value is object[]) || !targetType.IsArray) return false; if (targetType == typeof(object[])) return true; var values = ((object[])value); var array = (Array)targetType.CreateInstance(values.Length); var elementType = array.GetType().GetElementType(); for (int i = 0; i < values.Length; i++) { object element = values[i]; try { if (TryConvert(elementType, owner, ref element)) array.SetValue(element, i); else return false; } catch (ImmediateStop) { return false; } } value = array; return true; }
private static GroupViewModel CreateGroupFromClass(GroupViewModel parent, Type classType, Func<ComfoBoxClient> clientFunc) { var group = new GroupViewModel(classType.Name); parent.Add(group); foreach (var subType in classType.GetNestedTypes()) { CreateGroupFromClass(group, subType, clientFunc); } var instance = classType.CreateInstance(); foreach (var propertyInfo in classType.Properties(Flags.Default)) { var propertyValue = instance.GetPropertyValue(propertyInfo.Name) as IItemValue; if (propertyValue != null && propertyValue.IsReadOnly) { group.Add(new ReadOnlyItemViewModel(propertyInfo.Name, clientFunc) {Item = propertyValue}); } else if (propertyValue is AnalogValue || propertyValue is AnalogValue) { group.Add(new AnalogValueItemViewModel(propertyInfo.Name, clientFunc) {Item = propertyValue}); } else if (propertyValue is DateValue) { group.Add(new ReadOnlyItemViewModel(propertyInfo.Name, clientFunc) {Item = propertyValue}); } else { var enumItem = propertyValue as IEnumValue; group.Add(new EnumItemViewModel(propertyInfo.Name, clientFunc) {Item = propertyValue}); } } return group; }
public static object HandleException(Exception ex, Type type) { if (ex is SerializationException && ex.Message.Contains("does not have any serializable fields nor properties")) return type.CreateInstance(); throw ex; }
/// <summary> /// Initializes a new instance of the <see cref="ReturnsResourceAttribute"/> class. /// </summary> /// <param name="resourceType">The type of the resource this controller action returns.</param> public ReturnsResourceAttribute(Type resourceType) { if (!resourceType.IsSubclassOf(typeof(ApiResource))) { throw new ArgumentException("Resource types must inherit from Saule.ApiResource"); } Resource = resourceType.CreateInstance<ApiResource>(); }
public ReturnsResourceAttribute(Type resourceType) { if (!typeof(ApiResource).GetTypeInfo().IsAssignableFrom(resourceType.GetTypeInfo())) { throw new ArgumentException("Resource types must implement from Saule.IApiResource"); } Resource = resourceType.CreateInstance<ApiResource>(); }
public static ICodeTemplate CreateDefaultTemplate(TemplateType templateType, Session session, Type codeTemplateType, CodeDomProvider codeDomProvider) { var defaultTemplate = CodeTemplateQuery.FindDefaultTemplate(templateType, session, codeTemplateType,codeDomProvider); if (defaultTemplate== null) { defaultTemplate = (ICodeTemplate)codeTemplateType.CreateInstance(session); defaultTemplate.IsDefault = true; defaultTemplate.TemplateType=templateType; defaultTemplate.CodeDomProvider=codeDomProvider; defaultTemplate.SetDefaults(); } return defaultTemplate; }
// <inheritdoc /> public void Process(Type type) { if (!(typeof(IComponentManualRegister)).IsAssignableFrom(type)) { return; } if (!type.IsConcreteType()) { return; } type.CreateInstance<IComponentManualRegister>().Register(_componentRegistry); }
public void AddNodeProcessor(Type type) { if (type.Is<IXmlNodeProcessor>()) { var processor = type.CreateInstance<IXmlNodeProcessor>(); foreach(var nodeType in processor.AcceptNodeTypes) { RegisterProcessor(nodeType, processor); } } else { throw new XmlProcessorException("{0} does not implement IElementProcessor interface", type.FullName); } }
/// <summary> /// Creates the target type instance. /// </summary> /// <param name = "type">The type.</param> /// <param name = "configuration">The configuration.</param> /// <returns></returns> private object CreateInstance(Type type, IConfiguration configuration) { type = ObtainImplementation(type, configuration); var constructor = ChooseConstructor(type); object[] args = null; if (constructor != null) { args = ConvertConstructorParameters(constructor, configuration); } var instance = type.CreateInstance<object>(args); return instance; }
public static object ChangeType(object value, Type conversionType, CultureInfo cultureInfo) { if (value == DBNull.Value) value = null; if (value == null || value.Equals("")) { if (conversionType == typeof(DateTime)) return typeof(Nullable).IsAssignableFrom(conversionType) ? (object)null : DateTime.MinValue; if (conversionType == typeof(int) || conversionType == typeof(double)) return typeof(Nullable).IsAssignableFrom(conversionType) ? (object)null : 0; if (conversionType == typeof(bool)) return typeof(Nullable).IsAssignableFrom(conversionType) ? (object)null : false; if (typeof(IEnumerable).IsAssignableFrom(conversionType) && string.IsNullOrEmpty(value + "")) return null; if (conversionType.IsValueType) return conversionType.CreateInstance(); } else if (typeof(Enum).IsAssignableFrom(conversionType)) return Enum.Parse(conversionType, (string)value); else if ((value + "").IsGuid() && conversionType == typeof(Guid)) return new Guid(value.ToString()); else if (value.GetType() == conversionType) return value; else { var o = value as XPBaseObject; if (o != null) { if (conversionType == typeof(int)) return o.ClassInfo.KeyProperty.GetValue(o); if (conversionType == typeof(string)) return o.ClassInfo.KeyProperty.GetValue(o).ToString(); return value; } if (conversionType == typeof(DateTime)) { if ((value + "").Length > 0) { var val = (value + "").Val(); if (val > 0) return new DateTime(val); } } else if (value.GetType() != conversionType) { if (conversionType.IsNullableType()) { return ChangeType(value, conversionType.GetGenericArguments()[0], cultureInfo); } if (conversionType.IsGenericType) { return value; } } } return Convert.ChangeType(value, conversionType, cultureInfo); }
public static object Build(Type requestType, RequestContext requestContext) { var message = requestType.CreateInstance(); var properties = requestType.Properties(Flags.InstanceAnyVisibility); var queryStringValues = ConvertToRouteValueDictionary(requestContext.HttpContext.Request.QueryString); var formValues = ConvertToRouteValueDictionary(requestContext.HttpContext.Request.Form); foreach (var property in properties) { var propertyValue = RetrieveValue(property.Name, property.PropertyType, requestContext, queryStringValues, formValues); if (propertyValue == null) { continue; } message.SetPropertyValue(property.Name, propertyValue); } return message; }
public override Object Deserialize(Type t, Json json) { var m_deserialize = t.GetMethods(BF.All).AssertSingle(m => m.Name == "Deserialize" && ( Seq.Equal(m.Params(), typeof(Json)) || (Seq.Equal(m.Params(), typeof(Object)) && m.GetParameters()[0].HasAttr<DynamicAttribute>()))); if (m_deserialize.IsStatic) { (m_deserialize.Ret() != typeof(void)).AssertTrue(); return m_deserialize.Invoke(null, json.MkArray()); } else { var a_json = t.AttrOrNull<JsonAttribute>(); var default_ctor = a_json == null ? true : a_json.DefaultCtor; var instance = default_ctor ? t.CreateInstance() : t.CreateUninitialized(); (m_deserialize.Ret() == typeof(void)).AssertTrue(); m_deserialize.Invoke(instance, json.MkArray()); return instance; } }
private static void ExecuteCacheApi( Type type ) { List<int> range = Enumerable.Range( 0, 10 ).ToList(); // Let's cache the getter for the static InstanceCount MemberGetter count = type.DelegateForGetFieldValue( "InstanceCount" ); // Now cache the 2-arg constructor of Person and playaround with the delegate returned var currentInstanceCount = (int) count( null ); ConstructorInvoker ctor = type.DelegateForCreateInstance( new[] { typeof(int), typeof(string) } ); range.ForEach( i => { object obj = ctor( i, "_" + i ); AssertTrue( ++currentInstanceCount == (int) count( null ) ); AssertTrue( i == (int) obj.GetFieldValue( "id" ) ); AssertTrue( "_" + i == obj.GetPropertyValue( "Name" ).ToString() ); } ); // Getter/setter MemberSetter nameSetter = type.DelegateForSetPropertyValue( "Name" ); MemberGetter nameGetter = type.DelegateForGetPropertyValue( "Name" ); object person = ctor( 1, "John" ); AssertTrue( "John" == (string) nameGetter( person ) ); nameSetter( person, "Jane" ); AssertTrue( "Jane" == (string) nameGetter( person ) ); // Invoke method person = type.CreateInstance(); MethodInvoker walk = type.DelegateForCallMethod( "Walk", new[] { typeof(int) } ); range.ForEach( i => walk( person, i ) ); AssertTrue( range.Sum() == (int) person.GetFieldValue( "milesTraveled" ) ); // Map properties var ano = new { Id = 4, Name = "Doe" }; ObjectMapper mapper = ano.GetType().DelegateForMap( type ); mapper( ano, person ); AssertTrue( 4 == (int) person.GetPropertyValue( "Id" ) ); AssertTrue( "Doe" == (string) person.GetPropertyValue( "Name" ) ); }
private object HydrateStructure(Type targetType, BinaryReader reader) { if (targetType.IsSystemClass()) throw new SerializationException(string.Format("Type '{0}' is not supported.", targetType.Name)); var hydrated = targetType.CreateInstance(); foreach (var property in targetType.GetProperties()) { if (property.GetSetMethod() == null || property.MustIgnore()) continue; var arrayDefinition = property.GetArrayDefinition(); var constantStringLength = property.GetConstantLengthString(); var value = Deserialize(property.PropertyType, arrayDefinition, constantStringLength, reader); property.SetValue(hydrated, value, null); } return hydrated; }
private IHydraTask CreateTask(Type taskType) { var task = taskType.CreateInstance<IHydraTask>(); var settings = new HydraTaskSettings { Id = Guid.NewGuid(), WorkingFrom = TimeSpan.Zero, WorkingTo = TimeHelper.LessOneDay, IsDefault = true, TaskType = taskType.GetTypeName(false), }; _entityRegistry.TasksSettings.Add(settings); _entityRegistry.TasksSettings.DelayAction.WaitFlush(); InitTask(task, settings); var allSec = _entityRegistry.Securities.ReadById(Core.Extensions.AllSecurityId); task.Settings.Securities.Add(task.ToTaskSecurity(allSec)); task.Settings.Securities.DelayAction.WaitFlush(); return task; }
private void AddInstaller(Dictionary<Type, IWindsorInstaller> cache, Type type) { if (cache.ContainsKey(type) == false) { var installerInstance = type.CreateInstance<IWindsorInstaller>(); cache.Add(type, installerInstance); } }
private Func<IHandler[], IHandler> ExtractBinder(Type scopeRootBinderType, string name) { var filterMethod = scopeRootBinderType.FindMembers(MemberTypes.Method, BindingFlags.Instance | BindingFlags.Public, IsBindMethod, null) .FirstOrDefault(); if (filterMethod == null) { throw new InvalidOperationException( string.Format( "Type {0} which was designated as 'scopeRootBinderType' for component {1} does not have any public instance method matching signature of 'IHandler Method(IHandler[] pickOne)' and can not be used as scope root binder.", scopeRootBinderType.Name, name)); } var instance = scopeRootBinderType.CreateInstance<object>(); return (Func<IHandler[], IHandler>) Delegate.CreateDelegate(typeof(Func<IHandler[], IHandler>), instance, (MethodInfo)filterMethod); }
protected override string CreateMessage(Type dtoType) { var requestObj = ReflectionUtils.PopulateObject(dtoType.CreateInstance()); return DataContractSerializer.Instance.Parse(requestObj, true); }
internal static object CreateInstanceInternal(Type type) { return(type.CreateInstance()); }
public static IGraph<int> CreateEmptyGraph(Type type) { return type.CreateInstance() as IGraph<int>; }
private ScriptRuntimeScope CreateRuntimeScope(ScriptSettupInfo settupInfo, string amsKey, Type type) { #if STATIC return type.CreateInstance<ScriptRuntimeScope>(settupInfo); #else return _context.GetInstance(amsKey, type.FullName, settupInfo) as ScriptRuntimeScope; #endif }
/// <summary> /// Performs custom instantiation of given <param name="installerType"/> /// </summary> /// <remarks> /// Default implementation uses public parameterless constructor to create the instance. /// </remarks> public virtual IWindsorInstaller CreateInstance(Type installerType) { return installerType.CreateInstance<IWindsorInstaller>(); }
private static object ParseObject(HandlerData handlerData, Type paramType) { var paramValues = handlerData.Params; var obj = paramType.CreateInstance(); foreach (PropertyInfo prop in paramType.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)) { if (paramValues.ContainsKey(prop.Name) && (prop.PropertyType.IsValueType || typeof(string) == prop.PropertyType)) { object value; var val = paramValues[prop.Name]; if (prop.PropertyType == typeof(bool)) { value = val.ToBool(); } else { value = Convert.ChangeType(val, prop.PropertyType); } prop.SetValue(obj, value, null); } } return obj; }
public static IExtensionInfoProvider CreateProvider( IServiceProvider serviceProvider, Type extensionType) { return (IExtensionInfoProvider)extensionType.CreateInstance(serviceProvider); }
public static XPBaseObject GetXpObjectByKeyValue(UnitOfWork uow, string value, Type type, string prop) { if (string.IsNullOrEmpty(value)) return null; if (!type.IsSubclassOf(typeof(XPBaseObject))) return null; // var keyPropertyName = prop; var item = (XPBaseObject)uow.FindObject( type, new BinaryOperator(prop, value), true); if (item != null) return item; //var nestedUow = uow.BeginNestedUnitOfWork(); item = (XPBaseObject)type.CreateInstance(uow); var firstOrDefault = item.ClassInfo .PersistentProperties .OfType<XPMemberInfo>() .FirstOrDefault(p => p.Name == prop); if (firstOrDefault != null) firstOrDefault. SetValue(item, value); item.Save(); //uow.CommitChanges(); return item; }
protected static object CreateContentTypeRequest(IHttpRequest httpReq, Type requestType, string contentType) { try { if (!string.IsNullOrEmpty(contentType) && httpReq.ContentLength > 0) { var deserializer = EndpointHost.AppHost.ContentTypeFilters.GetStreamDeserializer(contentType); if (deserializer != null) { return deserializer(requestType, httpReq.InputStream); } } } catch (Exception ex) { var msg = "Could not deserialize '{0}' request using {1}'\nError: {2}" .Fmt(contentType, requestType, ex); throw new SerializationException(msg); } return requestType.CreateInstance(); //Return an empty DTO, even for empty request bodies }
protected override string CreateMessage(Type dtoType) { var requestObj = AutoMappingUtils.PopulateWith(dtoType.CreateInstance()); return JsonDataContractSerializer.Instance.SerializeToString(requestObj); }
public static dynamic Deserialize(this BinaryReader sourceReader, Type type) { var streamPosition = sourceReader.BaseStream.Position; var item = type.CreateInstance(); var fields = type.Fields( Flags.Public | Flags.NonPublic | Flags.Instance); List<FieldDelegateInformation> fieldMethods; ProcessFieldTypes(fields, out fieldMethods); InvokeFields(sourceReader, item, fields, fieldMethods); return item; }