Exemplo n.º 1
0
        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;
        }
Exemplo n.º 2
0
 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;
            }
Exemplo n.º 5
0
        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;
        }
Exemplo n.º 6
0
        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>();
        }
Exemplo n.º 9
0
 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);
			}
		}
Exemplo n.º 12
0
		/// <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;
		}
Exemplo n.º 13
0
        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);

        }
Exemplo n.º 14
0
        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;
        }
Exemplo n.º 15
0
        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;
            }
        }
Exemplo n.º 16
0
        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;
        }
Exemplo n.º 18
0
		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);
		}
Exemplo n.º 21
0
		protected override string CreateMessage(Type dtoType)
		{
			var requestObj = ReflectionUtils.PopulateObject(dtoType.CreateInstance());
			return DataContractSerializer.Instance.Parse(requestObj, true);
		}
Exemplo n.º 22
0
 internal static object CreateInstanceInternal(Type type)
 {
     return(type.CreateInstance());
 }
 public static IGraph<int> CreateEmptyGraph(Type type)
 {
     return type.CreateInstance() as IGraph<int>;
 }  
Exemplo n.º 24
0
        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
        }
Exemplo n.º 25
0
		/// <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;
 }
Exemplo n.º 27
0
		public static IExtensionInfoProvider CreateProvider(
			IServiceProvider serviceProvider,
			Type extensionType)
		{
			return (IExtensionInfoProvider)extensionType.CreateInstance(serviceProvider);
		}
Exemplo n.º 28
0
        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;


        }
Exemplo n.º 29
0
 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
 }
Exemplo n.º 30
0
 protected override string CreateMessage(Type dtoType)
 {
     var requestObj = AutoMappingUtils.PopulateWith(dtoType.CreateInstance());
     return JsonDataContractSerializer.Instance.SerializeToString(requestObj);
 }
Exemplo n.º 31
0
        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;
        }