private static object BindList(string ParentKey, string ParentType, Dictionary <string, string> Parameters, Dictionary <string, ParameterBinding> Bindings, DataContext dataContext) { ParameterBinding binding; if (!Bindings.TryGetValue(ParentKey, out binding)) { return(null); } string BindingString = binding.Binding; if (string.IsNullOrWhiteSpace(BindingString)) { return(null); } Type keytype = Data.TypeCache.GetType(binding.KeyType); Type collectiontype = Data.TypeCache.GetType(ParentType); try { var value = Lib.Helper.JsonHelper.Deserialize(BindingString, collectiontype); if (value != null) { var list = value as System.Collections.IList; var count = list.Count; for (int i = 0; i < count; i++) { var item = list[i]; if (item != null) { object KeyBack; string stritem = item.ToString(); if (IsValueBinding(stritem)) { string key = GetBindingKey(stritem); KeyBack = GetValue(key, binding.KeyType, dataContext); list[i] = TypeHelper.ChangeType(KeyBack, keytype); } } } return(list); } } catch (Exception) { } string bkey = GetBindingKey(BindingString); var valueback = GetValue(bkey, binding.FullTypeName, dataContext); if (valueback != null && valueback.GetType() == collectiontype) { return(valueback); } return(null); }
public Type EmitEntityType(string entityTypeName, IDictionary <string, Type> entityPropertyDic, Type parentInterfaceType) { string name = string.Format("{0}.{1}", this.assemblyName, entityTypeName); TypeBuilder builder = this.moduleBuilder.DefineType(name, TypeAttributes.Serializable | TypeAttributes.Public); if (parentInterfaceType != null) { builder.AddInterfaceImplementation(parentInterfaceType); } List <FieldBuilder> list = new List <FieldBuilder>(); foreach (string str2 in entityPropertyDic.Keys) { PropertyInfo property = parentInterfaceType.GetProperty(str2); Type type = entityPropertyDic[str2]; FieldBuilder item = builder.DefineField("m_" + str2, type, FieldAttributes.Private); list.Add(item); item.SetConstant(TypeHelper.ChangeType(type, TypeHelper.GetDefaultValue(type))); PropertyBuilder builder3 = builder.DefineProperty(str2, PropertyAttributes.None, type, null); MethodBuilder methodInfoBody = builder.DefineMethod("get", MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public, type, Type.EmptyTypes); ILGenerator generator = methodInfoBody.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldfld, item); generator.Emit(OpCodes.Ret); if ((property != null) && property.CanRead) { MethodInfo getMethod = property.GetGetMethod(); builder.DefineMethodOverride(methodInfoBody, getMethod); } MethodBuilder builder5 = builder.DefineMethod("set", MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public, null, new Type[] { type }); ILGenerator generator2 = builder5.GetILGenerator(); generator2.Emit(OpCodes.Ldarg_0); generator2.Emit(OpCodes.Ldarg_1); generator2.Emit(OpCodes.Stfld, item); generator2.Emit(OpCodes.Ret); if ((property != null) && property.CanWrite) { MethodInfo setMethod = property.GetSetMethod(); builder.DefineMethodOverride(builder5, setMethod); } builder3.SetGetMethod(methodInfoBody); builder3.SetSetMethod(builder5); } ILGenerator iLGenerator = builder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes).GetILGenerator(); iLGenerator.Emit(OpCodes.Ldarg_0); iLGenerator.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[0])); foreach (FieldBuilder builder2 in list) { if (builder2.FieldType == typeof(string)) { iLGenerator.Emit(OpCodes.Ldarg_0); iLGenerator.Emit(OpCodes.Ldstr, ""); iLGenerator.Emit(OpCodes.Stfld, builder2); } } iLGenerator.Emit(OpCodes.Ret); return(builder.CreateType()); }
public void ChangeType_ReturnsNullIfTypeAllowsNulls() { // Act var actual = TypeHelper.ChangeType(null, typeof(int?)); // Assert Assert.Null(actual); }
protected void OnChangeEventArgs(ChangeEventArgs input) { Value = (TValue)TypeHelper.ChangeType(input.Value, typeof(TValue)); if (ValueChanged.HasDelegate) { _ = ValueChanged.InvokeAsync(Value); } SetFieldValue(Value); }
public void ChangeType_ReturnsValueIfTypesMatch() { // Act var actual = TypeHelper.ChangeType(3, typeof(int)); // Assert Assert.Equal(typeof(int), actual.GetType()); Assert.Equal(3, actual); }
public void ChangeType_ReturnsConvertedTypeWhenThereIsAConverterFromTheType() { // Act var actual = TypeHelper.ChangeType("3", typeof(int)); // Assert Assert.Equal(typeof(int), actual.GetType()); Assert.Equal(3, actual); }
/// <summary> /// copy object to another object /// </summary> /// <param name="copyFrom"></param> /// <param name="instance"></param> /// <returns></returns> private static object Copy(object copyFrom, object instance) { if (copyFrom == null) { return(instance); } #region map method to Action/Func field //GetMethods doesn't return extension method. var fromMethods = copyFrom.GetType().GetMethods().ToList(); //var extensionMethods = GetExtensionMethods(typeof(KscriptContextExtension).Assembly,copyFrom.GetType()); //fromMethods.AddRange(extensionMethods); var fields = instance.GetType().GetFields().ToList(); foreach (var field in fields) { var matchMethod = fromMethods.Find(m => IsSameMethod(field, m)); if (matchMethod == null) { continue; } var delegateMethod = matchMethod.CreateDelegate(field.FieldType, copyFrom); field.SetValue(instance, delegateMethod); } #endregion #region map properties var fromProperties = copyFrom.GetType().GetProperties().ToList(); var properties = instance.GetType().GetProperties().ToList(); foreach (var prop in properties) { var matchProp = fromProperties.Find(p => p.Name.Equals(prop.Name, StringComparison.OrdinalIgnoreCase)); if (matchProp == null) { continue; } var value = matchProp.GetValue(copyFrom); if (prop.PropertyType == matchProp.PropertyType) { prop.SetValue(instance, value); } else { var matchPropertyInstance = Activator.CreateInstance(prop.PropertyType); matchPropertyInstance = Copy(value, matchPropertyInstance); //need convert type prop.SetValue(instance, TypeHelper.ChangeType(matchPropertyInstance, prop.PropertyType)); } } #endregion return(TypeHelper.ChangeType(instance, instance.GetType())); }
public T GetValue <T>(string name) { object val = GetValue(name); if (val != null) { return(TypeHelper.ChangeType <T>(val)); } return(default(T)); }
/// <summary> /// This type supports the Fluorine infrastructure and is not intended to be used directly from your code. /// </summary> /// <param name="context">An ITypeDescriptorContext that provides a format context.</param> /// <param name="culture">A CultureInfo object. If a null reference (Nothing in Visual Basic) is passed, the current culture is assumed.</param> /// <param name="value">The Object to convert.</param> /// <param name="destinationType">The Type to convert the value parameter to.</param> /// <returns>An Object that represents the converted value.</returns> public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { if (destinationType == null) { throw new ArgumentNullException("destinationType"); } if (destinationType.IsArray) { return((value as JavaScriptArray).ToArray()); } if (destinationType == typeof(ArrayList)) { return(value as ArrayList); } if (destinationType == typeof(IList)) { return(value as IList); } //generic interface Type typeGenericICollection = destinationType.GetInterface("System.Collections.Generic.ICollection`1"); if (typeGenericICollection != null) { object obj = TypeHelper.CreateInstance(destinationType); MethodInfo miAddCollection = destinationType.GetMethod("Add"); if (miAddCollection != null) { ParameterInfo[] parameters = miAddCollection.GetParameters(); if (parameters != null && parameters.Length == 1) { Type parameterType = parameters[0].ParameterType; IList list = (IList)value; for (int i = 0; i < list.Count; i++) { miAddCollection.Invoke(obj, new object[] { TypeHelper.ChangeType(list[i], parameterType) }); } return(obj); } } } Type typeIList = destinationType.GetInterface("System.Collections.IList"); if (typeIList != null) { object obj = TypeHelper.CreateInstance(destinationType); IList list = obj as IList; for (int i = 0; i < (value as IList).Count; i++) { list.Add((value as IList)[i]); } return(obj); } return(base.ConvertTo(context, culture, value, destinationType)); }
private static void ConfigObject(XmlNode objNode, ref object target) { foreach (XmlAttribute attribute in objNode.Attributes) { ReflectionHelper.SetProperty(target, attribute.Name, attribute.Value); } foreach (XmlNode node in objNode.ChildNodes) { if (node.Attributes["value"] != null) { ReflectionHelper.SetProperty(target, node.Attributes["name"].Value, node.Attributes["value"].Value); } else { XmlNode node2 = node.ChildNodes[0]; if (node2.Name == "object") { object obj2 = Activator.CreateInstance(ReflectionHelper.GetType(node2.Attributes["type"].Value)); ConfigObject(node2, ref obj2); ReflectionHelper.SetProperty(target, node.Attributes["name"].Value, obj2); } else if (node2.Name == "list") { object obj4; Type type = ReflectionHelper.GetType(node2.Attributes["element-type"].Value); Type type3 = typeof(List <>).MakeGenericType(new Type[] { type }); object obj3 = Activator.CreateInstance(type3); if (TypeHelper.IsSimpleType(type)) { foreach (XmlNode node3 in node2.ChildNodes) { obj4 = TypeHelper.ChangeType(type, node3.InnerText); type3.GetMethod("Add").Invoke(obj3, new object[] { obj4 }); } } else { foreach (XmlNode node3 in node2.ChildNodes) { Type type4 = type; if (node3.Attributes["type"] != null) { type4 = ReflectionHelper.GetType(node3.Attributes["type"].Value); } obj4 = Activator.CreateInstance(type4); ConfigObject(node3, ref obj4); type3.GetMethod("Add").Invoke(obj3, new object[] { obj4 }); } } ReflectionHelper.SetProperty(target, node.Attributes["name"].Value, obj3); } } } }
protected override void FormItem_OnReset(object value, bool requireRerender) { if (value == null) { SelectedValue = default; } else { SelectedValue = (TValue)TypeHelper.ChangeType(value, typeof(TValue)); } }
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) { object obj2; IList list; int num; if (destinationType == null) { throw new ArgumentNullException("destinationType"); } if (destinationType.IsArray) { return((value as JavaScriptArray).ToArray()); } if (destinationType == typeof(ArrayList)) { return(value as ArrayList); } if (destinationType == typeof(IList)) { return(value as IList); } if (destinationType.GetInterface("System.Collections.Generic.ICollection`1") != null) { obj2 = TypeHelper.CreateInstance(destinationType); MethodInfo method = destinationType.GetMethod("Add"); if (method != null) { ParameterInfo[] parameters = method.GetParameters(); if ((parameters != null) && (parameters.Length == 1)) { Type parameterType = parameters[0].ParameterType; list = (IList)value; for (num = 0; num < list.Count; num++) { method.Invoke(obj2, new object[] { TypeHelper.ChangeType(list[num], parameterType) }); } return(obj2); } } } if (destinationType.GetInterface("System.Collections.IList") != null) { obj2 = TypeHelper.CreateInstance(destinationType); list = obj2 as IList; for (num = 0; num < (value as IList).Count; num++) { list.Add((value as IList)[num]); } return(obj2); } return(base.ConvertTo(context, culture, value, destinationType)); }
/// <summary> /// This type supports the Fluorine infrastructure and is not intended to be used directly from your code. /// </summary> /// <param name="context">An ITypeDescriptorContext that provides a format context.</param> /// <param name="culture">A CultureInfo object. If a null reference (Nothing in Visual Basic) is passed, the current culture is assumed.</param> /// <param name="value">The Object to convert.</param> /// <param name="destinationType">The Type to convert the value parameter to.</param> /// <returns>An Object that represents the converted value.</returns> public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { if (destinationType == null) { throw new ArgumentNullException("destinationType"); } JavaScriptObject javaScriptObject = value as JavaScriptObject; if (destinationType == typeof(object) || destinationType == typeof(JavaScriptObject)) { return(value); } if (destinationType == typeof(Hashtable)) { return(new Hashtable(javaScriptObject)); } if (destinationType == typeof(ASObject)) { return(new ASObject(javaScriptObject)); } if (ReflectionUtils.ImplementsInterface(destinationType, "System.Collections.Generic.IDictionary`2")) { return(TypeHelper.ChangeType(javaScriptObject, destinationType)); } if (ReflectionUtils.ImplementsInterface(destinationType, "System.Collections.IDictionary")) { return(TypeHelper.ChangeType(javaScriptObject, destinationType)); } object newObject = Activator.CreateInstance(destinationType); #if !(NET_1_1) foreach (KeyValuePair <string, object> entry in value as JavaScriptObject) #else foreach (DictionaryEntry entry in value as JavaScriptObject) #endif { string memberName = entry.Key as string; MemberInfo memberInfo = ReflectionUtils.GetMember(destinationType, memberName, MemberTypes.Field | MemberTypes.Property); if (memberInfo != null) { object memberValue = TypeHelper.ChangeType(entry.Value, ReflectionUtils.GetMemberUnderlyingType(memberInfo)); ReflectionUtils.SetMemberValue(memberInfo, newObject, memberValue); } } return(newObject); }
public void ChangeTypeTest() { var test = new MockGenericType { EnumMockEnum = EnumMockEnum.EnumMockEnum }; var result = TypeHelper.ChangeType(nameof(EnumMockEnum.EnumMockEnum2), test.EnumMockEnum.GetType()); Assert.Equal(EnumMockEnum.EnumMockEnum2, result); var result2 = TypeHelper.ChangeType(EnumMockEnum.EnumMockEnum2, test.EnumMockEnum.GetType()); Assert.Equal(EnumMockEnum.EnumMockEnum2, result2); }
protected virtual void OnChangeEventArgs(ChangeEventArgs input) { try { Value = (TValue)TypeHelper.ChangeType(input.Value, typeof(TValue)); } catch (FormatException) when(ThrowOnInvalidValue) { } if (ValueChanged.HasDelegate) { _ = ValueChanged.InvokeAsync(Value); } SetFieldValue(Value, true); }
private CheckBoxOption <TModel, TValue> ConvertModelItem(TModel modelItem) { if (!ModelItemIsSimpleType) { return(null); } Status status = CheckBox.Status.Checked; if (IsChecked != null) { status = IsChecked(modelItem) ? Status.Checked : Status.UnChecked; } if (IsIndeterminate != null) { status = IsIndeterminate(modelItem) ? Status.Indeterminate : Status.UnChecked; } if (SelectedItems != null) { status = SelectedItems.Contains(modelItem) ? Status.Checked : Status.UnChecked; } var label = string.Empty; if (Label != null) { label = Label(modelItem); } else if (ModelItemIsSimpleType) { label = Convert.ToString(modelItem); } var option = new CheckBoxOption <TModel, TValue>() { Status = status, Value = Value == null ? (TValue)TypeHelper.ChangeType(label, typeof(TValue)) : Value(modelItem), IsDisabled = false, Label = label, Model = modelItem }; return(option); }
protected override void FormItem_OnReset(object value, bool requireRerender) { if (value == null) { Value = default; } else { Value = (TValue)TypeHelper.ChangeType(value, typeof(TValue)); } if (ValueChanged.HasDelegate) { _ = ValueChanged.InvokeAsync(Value); } else { StateHasChanged(); } }
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) { if (destinationType == null) { throw new ArgumentNullException("destinationType"); } JavaScriptObject d = value as JavaScriptObject; if ((destinationType == typeof(object)) || (destinationType == typeof(JavaScriptObject))) { return(value); } if (destinationType == typeof(Hashtable)) { return(new Hashtable(d)); } if (destinationType == typeof(ASObject)) { return(new ASObject(d)); } if (ReflectionUtils.ImplementsInterface(destinationType, "System.Collections.Generic.IDictionary`2")) { return(TypeHelper.ChangeType(d, destinationType)); } if (ReflectionUtils.ImplementsInterface(destinationType, "System.Collections.IDictionary")) { return(TypeHelper.ChangeType(d, destinationType)); } object target = Activator.CreateInstance(destinationType); foreach (KeyValuePair <string, object> pair in value as JavaScriptObject) { string key = pair.Key; MemberInfo member = ReflectionUtils.GetMember(destinationType, key, MemberTypes.Property | MemberTypes.Field); if (member != null) { object obj4 = TypeHelper.ChangeType(pair.Value, ReflectionUtils.GetMemberUnderlyingType(member)); ReflectionUtils.SetMemberValue(member, target, obj4); } } return(target); }
public void ResultReceived(IPendingServiceCall call) { //Unwrap flex messages if (call.Result is ErrorMessage) { StatusFunction statusFunction = _responder.GetType().GetProperty("Status").GetValue(_responder, null) as StatusFunction; if (statusFunction != null) { statusFunction(new Fault(call.Result as ErrorMessage)); } } else if (call.Result is AcknowledgeMessage) { AcknowledgeMessage ack = call.Result as AcknowledgeMessage; Delegate resultFunction = _responder.GetType().GetProperty("Result").GetValue(_responder, null) as Delegate; if (resultFunction != null) { ParameterInfo[] arguments = resultFunction.Method.GetParameters(); object result = TypeHelper.ChangeType(ack.body, arguments[0].ParameterType); resultFunction.DynamicInvoke(result); } } else if (call.IsSuccess) { Delegate resultFunction = _responder.GetType().GetProperty("Result").GetValue(_responder, null) as Delegate; if (resultFunction != null) { ParameterInfo[] arguments = resultFunction.Method.GetParameters(); object result = TypeHelper.ChangeType(call.Result, arguments[0].ParameterType); resultFunction.DynamicInvoke(result); } } else { StatusFunction statusFunction = _responder.GetType().GetProperty("Status").GetValue(_responder, null) as StatusFunction; if (statusFunction != null) { statusFunction(new Fault(call.Result)); } } }
public async Task IntegrationTestApiServiceWorkflowClientCreateAndAction() { using (var client = new WorkflowClient(BaseApiAddress)) { var createRequest = new CreateWorkflowRequestContract <PhoneCallWorkflow>(ArgumentContract.Create("CanDial", true)); var createResponse = await client.CreateAsync(createRequest); var workflowId = createResponse.WorkflowId; await client.ActionAsync(new ActionWorkflowRequestContract(workflowId, "Call Dialed")); await client.ActionAsync(new ActionWorkflowRequestContract(workflowId, "No Answer")); var waitResponse = await client.WaitAsync(workflowId); Assert.AreEqual( PhoneStates.Disconnected, TypeHelper.ChangeType <PhoneStates>(waitResponse.WorkflowState)); Assert.AreEqual("Hello World!", waitResponse.GetArgument <string>("Message")); } }
protected override void FormItem_OnReset(object value, bool requireRerender) { RequireRender = true; if (CheckBoxGroup != null) { if (CheckBoxGroup.SelectedItems.Contains(TypeHelper.ChangeType <TValue>(value))) { Status = Status.Checked; } else { Status = Status.UnChecked; } if (StatusChanged.HasDelegate) { _ = StatusChanged.InvokeAsync(Status); } else { CheckBoxGroup.MarkAsRequireRender(); } return; } if (TypeHelper.Equal(Value, TypeHelper.ChangeType <TValue>(value))) { Status = Status.Checked; } else { Status = Status.UnChecked; } if (StatusChanged.HasDelegate) { _ = StatusChanged.InvokeAsync(Status); } }
private void BeginResponseFlexCall(IAsyncResult ar) { try { AmfRequestData amfRequestData = ar.AsyncState as AmfRequestData; if (amfRequestData != null) { HttpWebResponse response = (HttpWebResponse)amfRequestData.Request.EndGetResponse(ar); if (response != null) { //Get response and deserialize Stream responseStream = response.GetResponseStream(); if (responseStream != null) { AMFDeserializer amfDeserializer = new AMFDeserializer(responseStream); AMFMessage responseMessage = amfDeserializer.ReadAMFMessage(); AMFBody responseBody = responseMessage.GetBodyAt(0); for (int i = 0; i < responseMessage.HeaderCount; i++) { AMFHeader header = responseMessage.GetHeaderAt(i); if (header.Name == AMFHeader.RequestPersistentHeader) _netConnection.AddHeader(header.Name, header.MustUnderstand, header.Content); } object message = responseBody.Content; if (message is ErrorMessage) { /* ASObject status = new ASObject(); status["level"] = "error"; status["code"] = "NetConnection.Call.Failed"; status["description"] = (result as ErrorMessage).faultString; status["details"] = result; _netConnection.RaiseNetStatus(status); */ if (amfRequestData.Call != null) { PendingCall call = amfRequestData.Call; call.Result = message; call.Status = Messaging.Rtmp.Service.Call.STATUS_INVOCATION_EXCEPTION; amfRequestData.Callback.ResultReceived(call); } if (amfRequestData.Responder != null) { StatusFunction statusFunction = amfRequestData.Responder.GetType().GetProperty("Status").GetValue(amfRequestData.Responder, null) as StatusFunction; if (statusFunction != null) statusFunction(new Fault(message as ErrorMessage)); } } else if (message is AcknowledgeMessage) { AcknowledgeMessage ack = message as AcknowledgeMessage; if (_netConnection.ClientId == null && ack.HeaderExists(MessageBase.FlexClientIdHeader)) _netConnection.SetClientId(ack.GetHeader(MessageBase.FlexClientIdHeader) as string); if (amfRequestData.Call != null) { PendingCall call = amfRequestData.Call; call.Result = ack.body; call.Status = Messaging.Rtmp.Service.Call.STATUS_SUCCESS_RESULT; amfRequestData.Callback.ResultReceived(call); } if (amfRequestData.Responder != null) { Delegate resultFunction = amfRequestData.Responder.GetType().GetProperty("Result").GetValue(amfRequestData.Responder, null) as Delegate; if (resultFunction != null) { ParameterInfo[] arguments = resultFunction.Method.GetParameters(); object result = TypeHelper.ChangeType(ack.body, arguments[0].ParameterType); resultFunction.DynamicInvoke(result); } } } } else _netConnection.RaiseNetStatus("Could not aquire ResponseStream"); } else _netConnection.RaiseNetStatus("Could not aquire HttpWebResponse"); } } catch (Exception ex) { _netConnection.RaiseNetStatus(ex); } }
/// <summary> /// This type supports the infrastructure and is not intended to be used directly from your code. /// </summary> /// <param name="context">An ITypeDescriptorContext that provides a format context.</param> /// <param name="culture">A CultureInfo object. If a null reference (Nothing in Visual Basic) is passed, the current culture is assumed.</param> /// <param name="value">The Object to convert.</param> /// <param name="destinationType">The Type to convert the value parameter to.</param> /// <returns>An Object that represents the converted value.</returns> public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { ASObject aso = value as ASObject; if (!ReflectionUtils.IsInstantiatableType(destinationType)) { return(null); } object instance = TypeHelper.CreateInstance(destinationType); if (instance != null) { foreach (string memberName in aso.Keys) { object val = aso[memberName]; //MemberInfo mi = ReflectionUtils.GetMember(destinationType, key, MemberTypes.Field | MemberTypes.Property); //if (mi != null) // ReflectionUtils.SetMemberValue(mi, result, aso[key]); PropertyInfo propertyInfo = null; try { propertyInfo = destinationType.GetProperty(memberName); } catch (AmbiguousMatchException) { //To resolve the ambiguity, include BindingFlags.DeclaredOnly to restrict the search to members that are not inherited. propertyInfo = destinationType.GetProperty(memberName, BindingFlags.DeclaredOnly | BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance); } if (propertyInfo != null) { try { val = TypeHelper.ChangeType(val, propertyInfo.PropertyType); if (propertyInfo.CanWrite && propertyInfo.GetSetMethod() != null) { if (propertyInfo.GetIndexParameters() == null || propertyInfo.GetIndexParameters().Length == 0) { propertyInfo.SetValue(instance, val, null); } else { string msg = __Res.GetString(__Res.Reflection_PropertyIndexFail, string.Format("{0}.{1}", destinationType.FullName, memberName)); throw new FluorineException(msg); } } else { //string msg = __Res.GetString(__Res.Reflection_PropertyReadOnly, string.Format("{0}.{1}", type.FullName, memberName)); } } catch (Exception ex) { string msg = __Res.GetString(__Res.Reflection_PropertySetFail, string.Format("{0}.{1}", destinationType.FullName, memberName), ex.Message); throw new FluorineException(msg); } } else { FieldInfo fi = destinationType.GetField(memberName, BindingFlags.Public | BindingFlags.Instance); try { if (fi != null) { val = TypeHelper.ChangeType(val, fi.FieldType); fi.SetValue(instance, val); } else { //string msg = __Res.GetString(__Res.Reflection_MemberNotFound, string.Format("{0}.{1}", destinationType.FullName, memberName)); } } catch (Exception ex) { string msg = __Res.GetString(__Res.Reflection_FieldSetFail, string.Format("{0}.{1}", destinationType.FullName, memberName), ex.Message); throw new FluorineException(msg); } } } } return(instance); }
private void BeginResponseFlashCall(IAsyncResult ar) { try { AmfRequestData amfRequestData = ar.AsyncState as AmfRequestData; if (amfRequestData != null) { HttpWebResponse response = (HttpWebResponse)amfRequestData.Request.EndGetResponse(ar); if (response != null) { //Get response and deserialize Stream responseStream = response.GetResponseStream(); if (responseStream != null) { AMFDeserializer amfDeserializer = new AMFDeserializer(responseStream); AMFMessage responseMessage = amfDeserializer.ReadAMFMessage(); AMFBody responseBody = responseMessage.GetBodyAt(0); for (int i = 0; i < responseMessage.HeaderCount; i++) { AMFHeader header = responseMessage.GetHeaderAt(i); if (header.Name == AMFHeader.RequestPersistentHeader) _netConnection.AddHeader(header.Name, header.MustUnderstand, header.Content); } if (amfRequestData.Call != null) { PendingCall call = amfRequestData.Call; call.Result = responseBody.Content; call.Status = responseBody.Target.EndsWith(AMFBody.OnStatus) ? Messaging.Rtmp.Service.Call.STATUS_INVOCATION_EXCEPTION : Messaging.Rtmp.Service.Call.STATUS_SUCCESS_RESULT; amfRequestData.Callback.ResultReceived(call); } if (amfRequestData.Responder != null) { if (responseBody.Target.EndsWith(AMFBody.OnStatus)) { StatusFunction statusFunction = amfRequestData.Responder.GetType().GetProperty("Status").GetValue(amfRequestData.Responder, null) as StatusFunction; if (statusFunction != null) statusFunction(new Fault(responseBody.Content)); } else { Delegate resultFunction = amfRequestData.Responder.GetType().GetProperty("Result").GetValue(amfRequestData.Responder, null) as Delegate; if (resultFunction != null) { ParameterInfo[] arguments = resultFunction.Method.GetParameters(); object result = TypeHelper.ChangeType(responseBody.Content, arguments[0].ParameterType); resultFunction.DynamicInvoke(result); } } } } else _netConnection.RaiseNetStatus("Could not aquire ResponseStream"); } else _netConnection.RaiseNetStatus("Could not aquire HttpWebResponse"); } } catch (Exception ex) { _netConnection.RaiseNetStatus(ex); } }
/// <summary> /// ConfigObject 使用objNode的各个子节点配置target的对应的属性 /// </summary> private static void ConfigObject(XmlNode objNode, ref object target) { foreach (XmlAttribute attr in objNode.Attributes) { ReflectionHelper.SetProperty(target, attr.Name, attr.Value); } foreach (XmlNode childNode in objNode.ChildNodes) { if (childNode.Attributes["value"] != null) { ReflectionHelper.SetProperty(target, childNode.Attributes["name"].Value, childNode.Attributes["value"].Value); } else { XmlNode childProNode = childNode.ChildNodes[0]; if (childProNode.Name == "object") { Type proType = ReflectionHelper.GetType(childProNode.Attributes["type"].Value); object proObj = Activator.CreateInstance(proType); SpringFox.ConfigObject(childProNode, ref proObj); ReflectionHelper.SetProperty(target, childNode.Attributes["name"].Value, proObj); } else if (childProNode.Name == "list") { Type listElementType = ReflectionHelper.GetType(childProNode.Attributes["element-type"].Value); Type closedGenericListType = typeof(List <>).MakeGenericType(listElementType); object list = Activator.CreateInstance(closedGenericListType); //ISimpleList simpleList = (ISimpleList)SpringFox.DynamicProxyCreator.CreateDynamicProxy<ISimpleList>(list); #region Add object into list if (TypeHelper.IsSimpleType(listElementType)) { foreach (XmlNode elementNode in childProNode.ChildNodes) { object element = TypeHelper.ChangeType(listElementType, elementNode.InnerText); closedGenericListType.GetMethod("Add").Invoke(list, new object[] { element }); //simpleList.Add(element); } } else { foreach (XmlNode elementNode in childProNode.ChildNodes) { Type curElementType = listElementType; if (elementNode.Attributes["type"] != null) { curElementType = ReflectionHelper.GetType(elementNode.Attributes["type"].Value); } object element = Activator.CreateInstance(curElementType); SpringFox.ConfigObject(elementNode, ref element); closedGenericListType.GetMethod("Add").Invoke(list, new object[] { element }); //simpleList.Add(element); } } #endregion ReflectionHelper.SetProperty(target, childNode.Attributes["name"].Value, list); } } } }
public void ChangeType_ThrowsIfTypeDoesNotAllowNulls() { // Act & Assert ExceptionAssert.Throws <InvalidCastException>(() => TypeHelper.ChangeType(null, typeof(int))); }
public void ChangeType_ThrowsIfTypeIsNull() { // Act & Assert ExceptionAssert.ThrowsArgNull(() => TypeHelper.ChangeType(new object(), null), "type"); }
public void ChangeType_ThrowWhenThereIsNoConverterForEither() { // Act & Assert ExceptionAssert.Throws <InvalidOperationException>(() => TypeHelper.ChangeType(false, typeof(MockClass))); }
internal void SetMember(object instance, string memberName, object value) { if (instance is ASObject) { ((ASObject)instance)[memberName] = value; return; } Type type = instance.GetType(); //PropertyInfo propertyInfo = type.GetProperty(memberName); PropertyInfo propertyInfo = null; try { propertyInfo = type.GetProperty(memberName); } catch (AmbiguousMatchException) { //To resolve the ambiguity, include BindingFlags.DeclaredOnly to restrict the search to members that are not inherited. propertyInfo = type.GetProperty(memberName, BindingFlags.DeclaredOnly | BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance); } if (propertyInfo != null) { try { if (propertyInfo.PropertyType == typeof(TimeSpan) || (propertyInfo.PropertyType == typeof(TimeSpan?) && value != null)) { value = Util.Convert.ToTimeSpan(value); } else { value = TypeHelper.ChangeType(value, propertyInfo.PropertyType); } if (propertyInfo.CanWrite) { if (propertyInfo.GetIndexParameters() == null || propertyInfo.GetIndexParameters().Length == 0) { propertyInfo.SetValue(instance, value, null); } else { string msg = __Res.GetString(__Res.Reflection_PropertyIndexFail, string.Format("{0}.{1}", type.FullName, memberName)); if (!_faultTolerancy) { throw new AMFException(msg); } else { _lastError = new AMFException(msg); } } } else { string msg = __Res.GetString(__Res.Reflection_PropertyReadOnly, string.Format("{0}.{1}", type.FullName, memberName)); } } catch (Exception ex) { string msg = __Res.GetString(__Res.Reflection_PropertySetFail, string.Format("{0}.{1}", type.FullName, memberName), ex.Message); if (!_faultTolerancy) { throw new AMFException(msg); } else { _lastError = new AMFException(msg); } } } else { FieldInfo fi = type.GetField(memberName, BindingFlags.Public | BindingFlags.Instance); try { if (fi != null) { if (fi.FieldType == typeof(TimeSpan)) { value = Util.Convert.ToTimeSpan(value); } else { value = TypeHelper.ChangeType(value, fi.FieldType); } fi.SetValue(instance, value); } else { string msg = __Res.GetString(__Res.Reflection_MemberNotFound, string.Format("{0}.{1}", type.FullName, memberName)); } } catch (Exception ex) { string msg = __Res.GetString(__Res.Reflection_FieldSetFail, string.Format("{0}.{1}", type.FullName, memberName), ex.Message); if (!_faultTolerancy) { throw new AMFException(msg); } else { _lastError = new AMFException(msg); } } } }
internal void SetMember(object instance, string memberName, object value) { if (instance is ASObject) { ((ASObject)instance)[memberName] = value; } else { string str; Exception exception; Type type = instance.GetType(); PropertyInfo property = null; try { property = type.GetProperty(memberName); } catch (AmbiguousMatchException) { property = type.GetProperty(memberName, BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); } if (property != null) { try { value = TypeHelper.ChangeType(value, property.PropertyType); if (property.CanWrite) { if ((property.GetIndexParameters() == null) || (property.GetIndexParameters().Length == 0)) { property.SetValue(instance, value, null); } else { str = __Res.GetString("Reflection_PropertyIndexFail", new object[] { string.Format("{0}.{1}", type.FullName, memberName) }); if (log.get_IsErrorEnabled()) { log.Error(str); } if (!this._faultTolerancy) { throw new FluorineException(str); } this._lastError = new FluorineException(str); } } else { str = __Res.GetString("Reflection_PropertyReadOnly", new object[] { string.Format("{0}.{1}", type.FullName, memberName) }); if (log.get_IsWarnEnabled()) { log.Warn(str); } } } catch (Exception exception2) { exception = exception2; str = __Res.GetString("Reflection_PropertySetFail", new object[] { string.Format("{0}.{1}", type.FullName, memberName), exception.Message }); if (log.get_IsErrorEnabled()) { log.Error(str, exception); } if (!this._faultTolerancy) { throw new FluorineException(str); } this._lastError = new FluorineException(str); } } else { FieldInfo field = type.GetField(memberName, BindingFlags.Public | BindingFlags.Instance); try { if (field != null) { value = TypeHelper.ChangeType(value, field.FieldType); field.SetValue(instance, value); } else { str = __Res.GetString("Reflection_MemberNotFound", new object[] { string.Format("{0}.{1}", type.FullName, memberName) }); if (log.get_IsWarnEnabled()) { log.Warn(str); } } } catch (Exception exception3) { exception = exception3; str = __Res.GetString("Reflection_FieldSetFail", new object[] { string.Format("{0}.{1}", type.FullName, memberName), exception.Message }); if (log.get_IsErrorEnabled()) { log.Error(str, exception); } if (!this._faultTolerancy) { throw new FluorineException(str); } this._lastError = new FluorineException(str); } } } }