internal static TaskClientCodeException CreateWithNonSerializableInnerException( TaskClientCodeException e, SerializationException serializationException) { var nonSerializableTaskException = NonSerializableTaskException.UnableToSerialize(e.InnerException, serializationException); return new TaskClientCodeException( e.TaskId, e.ContextId, string.Format("Unable to serialize Task control message. TaskClientCodeException message: {0}", e.Message), nonSerializableTaskException); }
internal static SerializationException GetSerializationException(string propertyName, string propertyValueString, Type propertyType, Exception e) { var serializationException = new SerializationException(String.Format("Failed to set property '{0}' with '{1}'", propertyName, propertyValueString), e); if (propertyName != null) { serializationException.Data.Add("propertyName", propertyName); } if (propertyValueString != null) { serializationException.Data.Add("propertyValueString", propertyValueString); } if (propertyType != null) { serializationException.Data.Add("propertyType", propertyType); } return serializationException; }
private void ThrowErrorOrWriteWarning(Exception e) { if (!PSSessionConfigurationData.IsServerManager) { this.InternalDelete(); this.serializationErrorHasOccured = true; SerializationException serializationException = new SerializationException(Resources.SerializationErrorException, e); throw serializationException; } else { object[] message = new object[1]; message[0] = e.Message; string str = string.Format(CultureInfo.CurrentCulture, Resources.SerializationWarning, message); this.WriteWarning(str); return; } }
public object PopulateFromMap(object instance, IDictionary<string, string> keyValuePairs, List<string> ignoredWarningsOnPropertyNames = null) { var errors = new List<RequestBindingError>(); string propertyName = null; string propertyTextValue = null; PropertySerializerEntry propertySerializerEntry = null; if (instance == null) instance = type.CreateInstance(); foreach (var pair in keyValuePairs.Where(x => !string.IsNullOrEmpty(x.Value))) { try { propertyName = pair.Key; propertyTextValue = pair.Value; if (!propertySetterMap.TryGetValue(propertyName, out propertySerializerEntry)) { if (propertyName == "v") { int version; var hasVersion = instance as IHasVersion; if (hasVersion != null && int.TryParse(pair.Value, out version)) { hasVersion.Version = version; } continue; } var ignoredProperty = propertyName.ToLowerInvariant(); if (ignoredWarningsOnPropertyNames == null || !ignoredWarningsOnPropertyNames.Contains(ignoredProperty)) { Log.WarnFormat("Property '{0}' does not exist on type '{1}'", ignoredProperty, type.FullName); } continue; } if (propertySerializerEntry.PropertySetFn == null) { Log.WarnFormat("Could not set value of read-only property '{0}' on type '{1}'", propertyName, type.FullName); continue; } if (propertySerializerEntry.PropertyType == typeof (bool)) { //InputExtensions.cs#530 MVC Checkbox helper emits extra hidden input field, generating 2 values, first is the real value propertyTextValue = propertyTextValue.LeftPart(','); } var value = propertySerializerEntry.PropertyParseStringFn(propertyTextValue); if (value == null) { Log.WarnFormat("Could not create instance on '{0}' for property '{1}' with text value '{2}'", instance, propertyName, propertyTextValue); continue; } propertySerializerEntry.PropertySetFn(instance, value); } catch (Exception ex) { var error = new RequestBindingError(); if (propertyName != null) error.PropertyName = propertyName; if (propertyTextValue != null) error.PropertyValueString = propertyTextValue; if (propertySerializerEntry != null && propertySerializerEntry.PropertyType != null) error.PropertyType = propertySerializerEntry.PropertyType; errors.Add(error); } } if (errors.Count > 0) { var serializationException = new SerializationException("Unable to bind to request '{0}'".Fmt(type.Name)); serializationException.Data.Add("errors", errors); throw serializationException; } return instance; }
public static TwitterApiException CreateFromException(SerializationException ex, string responseText) => new TwitterApiException("Invalid JSON", responseText, ex);
public static string Convert(SerializationException e) { return (e.Message); }
private NonSerializableTaskException(Exception originalException, SerializationException serializationException) : base(GetNonSerializableExceptionMessage(originalException), serializationException) { }
public object PopulateFromMap(object instance, IDictionary<string, string> keyValuePairs) { string propertyName = null; string propertyTextValue = null; PropertySerializerEntry propertySerializerEntry = null; try { if (instance == null) instance = ReflectionUtils.CreateInstance(type); foreach (var pair in keyValuePairs) { propertyName = pair.Key; propertyTextValue = pair.Value; if (!propertySetterMap.TryGetValue(propertyName, out propertySerializerEntry)) { if (propertyName != "format" && propertyName != "callback" && propertyName != "debug") { Log.WarnFormat("Property '{0}' does not exist on type '{1}'", propertyName, type.FullName); } continue; } var value = propertySerializerEntry.PropertyParseStringFn(propertyTextValue); if (value == null) { Log.WarnFormat("Could not create instance on '{0}' for property '{1}' with text value '{2}'", instance, propertyName, propertyTextValue); continue; } propertySerializerEntry.PropertySetFn(instance, value); } return instance; } catch (Exception ex) { var serializationException = new SerializationException("KeyValueDataContractDeserializer: Error converting to type: " + ex.Message, ex); if (propertyName != null) { serializationException.Data.Add("propertyName", propertyName); } if (propertyTextValue != null) { serializationException.Data.Add("propertyValueString", propertyTextValue); } if (propertySerializerEntry != null && propertySerializerEntry.PropertyType != null) { serializationException.Data.Add("propertyType", propertySerializerEntry.PropertyType); } throw serializationException; } }
private void ParseXml(XmlTextReader reader) { bool success = false; try { try { while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { string s = reader.LocalName; if (reader.LocalName.Equals(ResXResourceWriter.AssemblyStr)) { ParseAssemblyNode(reader, false); } else if (reader.LocalName.Equals(ResXResourceWriter.DataStr)) { ParseDataNode(reader, false); } else if (reader.LocalName.Equals(ResXResourceWriter.ResHeaderStr)) { ParseResHeaderNode(reader); } else if (reader.LocalName.Equals(ResXResourceWriter.MetadataStr)) { ParseDataNode(reader, true); } } } success = true; } catch (SerializationException se) { Point pt = GetPosition(reader); string newMessage = SR.GetString(SR.SerializationException, reader[ResXResourceWriter.TypeStr], pt.Y, pt.X, se.Message); XmlException xml = new XmlException(newMessage, se, pt.Y, pt.X); SerializationException newSe = new SerializationException(newMessage, xml); throw newSe; } catch (TargetInvocationException tie) { Point pt = GetPosition(reader); string newMessage = SR.GetString(SR.InvocationException, reader[ResXResourceWriter.TypeStr], pt.Y, pt.X, tie.InnerException.Message); XmlException xml = new XmlException(newMessage, tie.InnerException, pt.Y, pt.X); TargetInvocationException newTie = new TargetInvocationException(newMessage, xml); throw newTie; } catch (XmlException e) { throw new ArgumentException(SR.GetString(SR.InvalidResXFile, e.Message), e); } catch (Exception e) { if (ClientUtils.IsSecurityOrCriticalException(e)) { throw; } else { Point pt = GetPosition(reader); XmlException xmlEx = new XmlException(e.Message, e, pt.Y, pt.X); throw new ArgumentException(SR.GetString(SR.InvalidResXFile, xmlEx.Message), xmlEx); } } } finally { if (!success) { resData = null; resMetadata = null; } } bool validFile = false; if (object.Equals(resHeaderMimeType, ResXResourceWriter.ResMimeType)) { Type readerType = typeof(ResXResourceReader); Type writerType = typeof(ResXResourceWriter); string readerTypeName = resHeaderReaderType; string writerTypeName = resHeaderWriterType; if (readerTypeName != null &&readerTypeName.IndexOf(',') != -1) { readerTypeName = readerTypeName.Split(new char[] {','})[0].Trim(); } if (writerTypeName != null && writerTypeName.IndexOf(',') != -1) { writerTypeName = writerTypeName.Split(new char[] {','})[0].Trim(); } // Don't check validity, since our reader/writer classes are in System.Web.Compilation, // while the file format has them in System.Resources. #if SYSTEM_WEB validFile = true; #else if (readerTypeName != null && writerTypeName != null && readerTypeName.Equals(readerType.FullName) && writerTypeName.Equals(writerType.FullName)) { validFile = true; } #endif } if (!validFile) { resData = null; resMetadata = null; throw new ArgumentException(SR.GetString(SR.InvalidResXFileReaderWriterTypes)); } }
public void Save_Wraps_SerializationException_As_IOException() { // Arrange var testBundle = new SettingsRepositoryTestBundle(); var mockLog = new Mock<ILog>(); var settings = new SettingsRoot(); var testException = new SerializationException("test exception"); IOException thrownException = null; testBundle.MockLogProvider.Setup(x => x.GetLogger(It.IsAny<Type>())).Returns(mockLog.Object); testBundle.MockXmlSerializer.Setup(x => x.Serialize(It.IsAny<TextWriter>(), It.IsAny<object>())).Throws(testException); // Act try { testBundle.SettingsManager.Save(settings); } catch (IOException ex) { thrownException = ex; } // Assert testBundle.MockXmlSerializer.Verify(x => x.Serialize(It.IsAny<TextWriter>(), It.IsAny<object>()), Times.Once); Assert.IsNotNull(thrownException); }
object IDesignerSerializationManager.CreateInstance(Type type, ICollection arguments, string name, bool addToContainer) { this.CheckSession(); if (((name != null) && (this.instancesByName != null)) && this.instancesByName.ContainsKey(name)) { Exception exception = new SerializationException(System.Design.SR.GetString("SerializationManagerDuplicateComponentDecl", new object[] { name })) { HelpLink = "SerializationManagerDuplicateComponentDecl" }; throw exception; } object obj2 = this.CreateInstance(type, arguments, name, addToContainer); if ((name != null) && (!(obj2 is IComponent) || !this.RecycleInstances)) { if (this.instancesByName == null) { this.instancesByName = new Hashtable(); this.namesByInstance = new Hashtable(new ReferenceComparer()); } this.instancesByName[name] = obj2; this.namesByInstance[obj2] = name; } return obj2; }
protected virtual object CreateInstance(Type type, ICollection arguments, string name, bool addToContainer) { object[] array = null; if ((arguments != null) && (arguments.Count > 0)) { array = new object[arguments.Count]; arguments.CopyTo(array, 0); } object obj2 = null; if (this.RecycleInstances && (name != null)) { if (this.instancesByName != null) { obj2 = this.instancesByName[name]; } if (((obj2 == null) && addToContainer) && (this.Container != null)) { obj2 = this.Container.Components[name]; } if (((obj2 != null) && this.ValidateRecycledTypes) && (obj2.GetType() != type)) { obj2 = null; } } if ((((obj2 == null) && addToContainer) && typeof(IComponent).IsAssignableFrom(type)) && (((array == null) || (array.Length == 0)) || ((array.Length == 1) && (array[0] == this.Container)))) { IDesignerHost service = this.GetService(typeof(IDesignerHost)) as IDesignerHost; if ((service != null) && (service.Container == this.Container)) { bool flag = false; if ((!this.PreserveNames && (name != null)) && (this.Container.Components[name] != null)) { flag = true; } if ((name == null) || flag) { obj2 = service.CreateComponent(type); } else { obj2 = service.CreateComponent(type, name); } } } if (obj2 == null) { try { try { obj2 = TypeDescriptor.CreateInstance(this.provider, type, null, array); } catch (MissingMethodException exception) { Type[] typeArray = new Type[array.Length]; for (int i = 0; i < array.Length; i++) { if (array[i] != null) { typeArray[i] = array[i].GetType(); } } object[] args = new object[array.Length]; foreach (ConstructorInfo info in TypeDescriptor.GetReflectionType(type).GetConstructors(BindingFlags.CreateInstance | BindingFlags.Public | BindingFlags.Instance)) { ParameterInfo[] parameters = info.GetParameters(); if ((parameters != null) && (parameters.Length == typeArray.Length)) { bool flag2 = true; for (int j = 0; j < typeArray.Length; j++) { if ((typeArray[j] == null) || parameters[j].ParameterType.IsAssignableFrom(typeArray[j])) { args[j] = array[j]; } else { if (array[j] is IConvertible) { try { args[j] = ((IConvertible) array[j]).ToType(parameters[j].ParameterType, null); goto Label_0217; } catch (InvalidCastException) { } } flag2 = false; break; Label_0217:; } } if (flag2) { obj2 = TypeDescriptor.CreateInstance(this.provider, type, null, args); break; } } } if (obj2 == null) { throw exception; } } } catch (MissingMethodException) { StringBuilder builder = new StringBuilder(); foreach (object obj3 in array) { if (builder.Length > 0) { builder.Append(", "); } if (obj3 != null) { builder.Append(obj3.GetType().Name); } else { builder.Append("null"); } } Exception exception2 = new SerializationException(System.Design.SR.GetString("SerializationManagerNoMatchingCtor", new object[] { type.FullName, builder.ToString() })) { HelpLink = "SerializationManagerNoMatchingCtor" }; throw exception2; } if ((!addToContainer || !(obj2 is IComponent)) || (this.Container == null)) { return obj2; } bool flag3 = false; if ((!this.PreserveNames && (name != null)) && (this.Container.Components[name] != null)) { flag3 = true; } if ((name == null) || flag3) { this.Container.Add((IComponent) obj2); return obj2; } this.Container.Add((IComponent) obj2, name); } return obj2; }
private Hashtable CreateResourceSet(IResourceReader reader, CultureInfo culture) { Hashtable hashtable = new Hashtable(); try { IDictionaryEnumerator enumerator = reader.GetEnumerator(); while (enumerator.MoveNext()) { string key = (string) enumerator.Key; object obj2 = enumerator.Value; hashtable[key] = obj2; } } catch (Exception exception) { Exception exception2; string message = exception.Message; if ((message == null) || (message.Length == 0)) { message = exception.GetType().Name; } if (culture == CultureInfo.InvariantCulture) { exception2 = new SerializationException(System.Design.SR.GetString("SerializerResourceExceptionInvariant", new object[] { message }), exception); } else { exception2 = new SerializationException(System.Design.SR.GetString("SerializerResourceException", new object[] { culture.ToString(), message }), exception); } this.manager.ReportError(exception2); } return hashtable; }
/// <summary> /// Converts the given <see cref="Stream"/> into a list of <see cref="RelayMessage"/>. /// </summary> /// <param name="stream">The given <see cref="Stream"/></param> /// <param name="evaluateMethod">A method to evaluate each <see cref="RelayMessage"/> as it's deserialized.</param> /// <returns>A list of <see cref="RelayMessage"/>.</returns> public static List<RelayMessage> ReadRelayMessageList(Stream stream, Action<RelayMessage> evaluateMethod) { BinaryReader bread = new BinaryReader(stream); CompactBinaryReader br = new CompactBinaryReader(bread); int objectCount = br.ReadInt32(); List<RelayMessage> messages = new List<RelayMessage>(objectCount); for (int i = 0; i < objectCount; i++) { RelayMessage nextMessage = new RelayMessage(); try { br.Read<RelayMessage>(nextMessage, false); } catch (SerializationException exc) { //try and add some context to this object //Id and TypeId most likely got correctly deserialized so we're providing that much string message = string.Format("Deserialization failed for RelayMessage of Id='{0}', ExtendedId='{1}', TypeId='{2}' and StreamLength='{3}'", nextMessage.Id, Algorithm.ToHex(nextMessage.ExtendedId), nextMessage.TypeId, stream.Length); SerializationException newException = new SerializationException(message, exc); throw newException; } messages.Add(nextMessage); if (evaluateMethod != null) evaluateMethod(nextMessage); } return messages; }
private NonSerializableEvaluatorException(string exceptionString, SerializationException serializationException) : base(exceptionString, serializationException) { }
// used by the client internal IMessage FormatResponse(ISoapMessage soapMsg, IMethodCallMessage mcm) { IMessage rtnMsg; if(soapMsg.MethodName == "Fault") { // an exception was thrown by the server Exception e = new SerializationException(); int i = Array.IndexOf(soapMsg.ParamNames, "detail"); if(_serverFaultExceptionField != null) // todo: revue this 'cause it's not safe e = (Exception) _serverFaultExceptionField.GetValue( soapMsg.ParamValues[i]); rtnMsg = new ReturnMessage((System.Exception)e, mcm); } else { object rtnObject = null; //RemMessageType messageType; // Get the output of the function if it is not *void* if(_methodCallInfo.ReturnType != typeof(void)){ int index = Array.IndexOf(soapMsg.ParamNames, "return"); rtnObject = soapMsg.ParamValues[index]; if(rtnObject is IConvertible) rtnObject = Convert.ChangeType( rtnObject, _methodCallInfo.ReturnType); } object[] outParams = new object [_methodCallParameters.Length]; int n=0; // check if there are *out* parameters foreach(ParameterInfo paramInfo in _methodCallParameters) { if(paramInfo.ParameterType.IsByRef || paramInfo.IsOut) { int index = Array.IndexOf(soapMsg.ParamNames, paramInfo.Name); object outParam = soapMsg.ParamValues[index]; if(outParam is IConvertible) outParam = Convert.ChangeType (outParam, paramInfo.ParameterType.GetElementType()); outParams[n] = outParam; } else outParams [n] = null; n++; } Header[] headers = new Header [2 + (soapMsg.Headers != null ? soapMsg.Headers.Length : 0)]; headers [0] = new Header ("__Return", rtnObject); headers [1] = new Header ("__OutArgs", outParams); if (soapMsg.Headers != null) soapMsg.Headers.CopyTo (headers, 2); rtnMsg = new MethodResponse (headers, mcm); } return rtnMsg; }
internal static NonSerializableTaskException UnableToSerialize(Exception originalException, SerializationException serializationException) { return new NonSerializableTaskException(originalException, serializationException); }
public override object Deserialize(IDesignerSerializationManager manager, object codeObject) { if ((manager == null) || (codeObject == null)) { throw new ArgumentNullException((manager == null) ? "manager" : "codeObject"); } object obj2 = null; using (CodeDomSerializerBase.TraceScope("RootCodeDomSerializer::Deserialize")) { if (!(codeObject is CodeTypeDeclaration)) { throw new ArgumentException(System.Design.SR.GetString("SerializerBadElementType", new object[] { typeof(CodeTypeDeclaration).FullName })); } bool caseInsensitive = false; CodeDomProvider service = manager.GetService(typeof(CodeDomProvider)) as CodeDomProvider; if (service != null) { caseInsensitive = (service.LanguageOptions & LanguageOptions.CaseInsensitive) != LanguageOptions.None; } CodeTypeDeclaration declaration = (CodeTypeDeclaration) codeObject; CodeTypeReference reference = null; Type type = null; foreach (CodeTypeReference reference2 in declaration.BaseTypes) { Type type2 = manager.GetType(CodeDomSerializerBase.GetTypeNameFromCodeTypeReference(manager, reference2)); if ((type2 != null) && !type2.IsInterface) { reference = reference2; type = type2; break; } } if (type == null) { Exception exception = new SerializationException(System.Design.SR.GetString("SerializerTypeNotFound", new object[] { reference.BaseType })) { HelpLink = "SerializerTypeNotFound" }; throw exception; } if (type.IsAbstract) { Exception exception2 = new SerializationException(System.Design.SR.GetString("SerializerTypeAbstract", new object[] { type.FullName })) { HelpLink = "SerializerTypeAbstract" }; throw exception2; } ResolveNameEventHandler handler = new ResolveNameEventHandler(this.OnResolveName); manager.ResolveName += handler; if (!(manager is DesignerSerializationManager)) { manager.AddSerializationProvider(new CodeDomSerializationProvider()); } obj2 = manager.CreateInstance(type, null, declaration.Name, true); this.nameTable = new HybridDictionary(declaration.Members.Count, caseInsensitive); this.statementTable = new HybridDictionary(declaration.Members.Count, caseInsensitive); this.initMethod = null; RootContext context = new RootContext(new CodeThisReferenceExpression(), obj2); manager.Context.Push(context); try { foreach (CodeTypeMember member in declaration.Members) { if (member is CodeMemberField) { if (string.Compare(member.Name, declaration.Name, caseInsensitive, CultureInfo.InvariantCulture) != 0) { this.nameTable[member.Name] = member; } } else if ((this.initMethod == null) && (member is CodeMemberMethod)) { CodeMemberMethod method = (CodeMemberMethod) member; if ((string.Compare(method.Name, this.InitMethodName, caseInsensitive, CultureInfo.InvariantCulture) == 0) && (method.Parameters.Count == 0)) { this.initMethod = method; } } } if (this.initMethod != null) { foreach (CodeStatement statement in this.initMethod.Statements) { CodeVariableDeclarationStatement statement2 = statement as CodeVariableDeclarationStatement; if (statement2 != null) { this.nameTable[statement2.Name] = statement; } } } if (this.nameTable[declaration.Name] != null) { this.nameTable[declaration.Name] = obj2; } if (this.initMethod != null) { this.FillStatementTable(this.initMethod, declaration.Name); } PropertyDescriptor descriptor = manager.Properties["SupportsStatementGeneration"]; if (((descriptor != null) && (descriptor.PropertyType == typeof(bool))) && ((bool) descriptor.GetValue(manager))) { foreach (string str in this.nameTable.Keys) { CodeDomSerializerBase.OrderedCodeStatementCollection statements = (CodeDomSerializerBase.OrderedCodeStatementCollection) this.statementTable[str]; if (statements != null) { bool flag2 = false; foreach (CodeStatement statement3 in statements) { object obj3 = statement3.UserData["GeneratedStatement"]; if (((obj3 == null) || !(obj3 is bool)) || !((bool) obj3)) { flag2 = true; break; } } if (!flag2) { this.statementTable.Remove(str); } } } } IContainer container = (IContainer) manager.GetService(typeof(IContainer)); if (container != null) { foreach (object obj4 in container.Components) { base.DeserializePropertiesFromResources(manager, obj4, designTimeProperties); } } object[] array = new object[this.statementTable.Values.Count]; this.statementTable.Values.CopyTo(array, 0); Array.Sort(array, StatementOrderComparer.Default); foreach (CodeDomSerializerBase.OrderedCodeStatementCollection statements2 in array) { string name = statements2.Name; if ((name != null) && !name.Equals(declaration.Name)) { this.DeserializeName(manager, name); } } CodeStatementCollection statements3 = (CodeStatementCollection) this.statementTable[declaration.Name]; if ((statements3 != null) && (statements3.Count > 0)) { foreach (CodeStatement statement4 in statements3) { base.DeserializeStatement(manager, statement4); } } return obj2; } finally { manager.ResolveName -= handler; this.initMethod = null; this.nameTable = null; this.statementTable = null; manager.Context.Pop(); } } return obj2; }
//a private helper function to handle serialization exceptions that denotes missing fields, //checks if the DeserializationDefaultValueAttribute or the DeserializationOldNameAttribute //were defined over the new field and if so handle the field. private void handleSerializationException(SerializationException ex, FieldInfo fieldInfo, Object obj , SerializationInfo info, Type t) { //this is ugly...for some reason they did not defined a MemberNotFoundSerializationException //so to make sure this is indeed this exception and not an actual error we need to check the message //and compare strings. if(!ex.Message.EndsWith("not found.")) throw ex; //check to see if the custume attribute DeserializationDefaultValueAttribute was placed on this new field //and if so set it's default value in the field Object[] fieldAttributes = fieldInfo.GetCustomAttributes(true); foreach(Object attribute in fieldAttributes) { //see if this is a DeserializationDefaultValueAttribute if(attribute.GetType() == typeof(DeserializationDefaultValueAttribute)) { //set the Default Value in the field fieldInfo.SetValue(obj, ((DeserializationDefaultValueAttribute)attribute).DefaultValue); } //see if this is a DeserializationOldNameAttribute if(attribute.GetType() == typeof(DeserializationOldNameAttribute)) { object storedValue; //get the old name field value //check if this is a private field and if so append the class name to access the field if(fieldInfo.Attributes == FieldAttributes.Public) storedValue = info.GetValue(((DeserializationOldNameAttribute)attribute).OldName, fieldInfo.FieldType); else storedValue = info.GetValue(t.Name + "+" + ((DeserializationOldNameAttribute)attribute).OldName , fieldInfo.FieldType); //set the old field name value to the new field name. fieldInfo.SetValue(obj, storedValue); } } }
private void ThrowWrappedSerializationException( Type messageType, SerializationException serializationException) { string logMessage = string.Format( "A serialization exception occured while sending or publishing a message: {0}. " + "Ensure that all classes used in the message meet the criteria defined in " + "Brnkly.Platform.Framework.ServiceBus.Core.MessageTypeLoader. " + "See the inner exception for details.", messageType.FullName); throw new InvalidOperationException(logMessage, serializationException); }
public object PopulateFromMap(object instance, INameValueCollection nameValues, List<string> ignoredWarningsOnPropertyNames = null) { var errors = new List<RequestBindingError>(); PropertySerializerEntry propertySerializerEntry = null; if (instance == null) instance = type.CreateInstance(); foreach (var key in nameValues.AllKeys) { string value = nameValues[key]; if (!string.IsNullOrEmpty(value)) { instance = PopulateFromKeyValue(instance, key, value, out propertySerializerEntry, errors, ignoredWarningsOnPropertyNames); } } if (errors.Count > 0) { var serializationException = new SerializationException($"Unable to bind to request '{type.Name}'"); serializationException.Data.Add("errors", errors); throw serializationException; } return instance; }
internal static NonSerializableTaskException UnableToDeserialize(string exceptionString, SerializationException serializationException) { return new NonSerializableTaskException(exceptionString, serializationException); }
public object PopulateFromMap(object instance, IDictionary<string, string> keyValuePairs, List<string> ignoredWarningsOnPropertyNames = null) { var errors = new List<RequestBindingError>(); PropertySerializerEntry propertySerializerEntry = null; if (instance == null) instance = type.CreateInstance(); foreach (var pair in keyValuePairs) { if (!string.IsNullOrEmpty(pair.Value)) { instance = PopulateFromKeyValue(instance, pair.Key, pair.Value, out propertySerializerEntry, errors, ignoredWarningsOnPropertyNames); } } if (errors.Count > 0) { var serializationException = new SerializationException($"Unable to bind to request '{type.Name}'"); serializationException.Data.Add("errors", errors); throw serializationException; } return instance; }
private NonSerializableTaskException(string exceptionString, SerializationException serializationException) : base(exceptionString, serializationException) { }
private void OnException(BrokeredMessage message, SerializationException exception) { throw new NotImplementedException(); //message.DeadLetterAsync() }
public object PopulateFromMap(object instance, IDictionary<string, string> keyValuePairs, List<string> ignoredWarningsOnPropertyNames = null) { string propertyName = null; string propertyTextValue = null; PropertySerializerEntry propertySerializerEntry = null; try { if (instance == null) instance = type.CreateInstance(); foreach (var pair in keyValuePairs.Where(x => !string.IsNullOrEmpty(x.Value))) { propertyName = pair.Key; propertyTextValue = pair.Value; if (!propertySetterMap.TryGetValue(propertyName, out propertySerializerEntry)) { var ignoredProperty = propertyName.ToLowerInvariant(); if (ignoredWarningsOnPropertyNames == null || !ignoredWarningsOnPropertyNames.Contains(ignoredProperty)) { Log.WarnFormat("Property '{0}' does not exist on type '{1}'", ignoredProperty, type.FullName); } continue; } if (propertySerializerEntry.PropertySetFn == null) { Log.WarnFormat("Could not set value of read-only property '{0}' on type '{1}'", propertyName, type.FullName); continue; } if (Type.GetTypeCode(propertySerializerEntry.PropertyType) == TypeCode.Boolean) { //InputExtensions.cs#530 MVC Checkbox helper emits extra hidden input field, generating 2 values, first is the real value propertyTextValue = propertyTextValue.SplitOnFirst(',').First(); } var value = propertySerializerEntry.PropertyParseStringFn(propertyTextValue); if (value == null) { Log.WarnFormat("Could not create instance on '{0}' for property '{1}' with text value '{2}'", instance, propertyName, propertyTextValue); continue; } propertySerializerEntry.PropertySetFn(instance, value); } return instance; } catch (Exception ex) { var serializationException = new SerializationException("KeyValueDataContractDeserializer: Error converting to type: " + ex.Message, ex); if (propertyName != null) { serializationException.Data.Add("propertyName", propertyName); } if (propertyTextValue != null) { serializationException.Data.Add("propertyValueString", propertyTextValue); } if (propertySerializerEntry != null && propertySerializerEntry.PropertyType != null) { serializationException.Data.Add("propertyType", propertySerializerEntry.PropertyType); } throw serializationException; } }
private void ParseXml(XmlTextReader reader) { bool flag = false; try { while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { string localName = reader.LocalName; if (reader.LocalName.Equals("assembly")) { this.ParseAssemblyNode(reader, false); } else { if (reader.LocalName.Equals("data")) { this.ParseDataNode(reader, false); continue; } if (reader.LocalName.Equals("resheader")) { this.ParseResHeaderNode(reader); continue; } if (reader.LocalName.Equals("metadata")) { this.ParseDataNode(reader, true); } } } } flag = true; } catch (SerializationException exception) { Point position = this.GetPosition(reader); string message = System.Windows.Forms.SR.GetString("SerializationException", new object[] { reader["type"], position.Y, position.X, exception.Message }); XmlException innerException = new XmlException(message, exception, position.Y, position.X); SerializationException exception3 = new SerializationException(message, innerException); throw exception3; } catch (TargetInvocationException exception4) { Point point2 = this.GetPosition(reader); string str2 = System.Windows.Forms.SR.GetString("InvocationException", new object[] { reader["type"], point2.Y, point2.X, exception4.InnerException.Message }); XmlException inner = new XmlException(str2, exception4.InnerException, point2.Y, point2.X); TargetInvocationException exception6 = new TargetInvocationException(str2, inner); throw exception6; } catch (XmlException exception7) { throw new ArgumentException(System.Windows.Forms.SR.GetString("InvalidResXFile", new object[] { exception7.Message }), exception7); } catch (Exception exception8) { if (System.Windows.Forms.ClientUtils.IsSecurityOrCriticalException(exception8)) { throw; } Point point3 = this.GetPosition(reader); XmlException exception9 = new XmlException(exception8.Message, exception8, point3.Y, point3.X); throw new ArgumentException(System.Windows.Forms.SR.GetString("InvalidResXFile", new object[] { exception9.Message }), exception9); } finally { if (!flag) { this.resData = null; this.resMetadata = null; } } bool flag2 = false; if (object.Equals(this.resHeaderMimeType, ResXResourceWriter.ResMimeType)) { System.Type type = typeof(ResXResourceReader); System.Type type2 = typeof(ResXResourceWriter); string resHeaderReaderType = this.resHeaderReaderType; string resHeaderWriterType = this.resHeaderWriterType; if ((resHeaderReaderType != null) && (resHeaderReaderType.IndexOf(',') != -1)) { resHeaderReaderType = resHeaderReaderType.Split(new char[] { ',' })[0].Trim(); } if ((resHeaderWriterType != null) && (resHeaderWriterType.IndexOf(',') != -1)) { resHeaderWriterType = resHeaderWriterType.Split(new char[] { ',' })[0].Trim(); } if (((resHeaderReaderType != null) && (resHeaderWriterType != null)) && (resHeaderReaderType.Equals(type.FullName) && resHeaderWriterType.Equals(type2.FullName))) { flag2 = true; } } if (!flag2) { this.resData = null; this.resMetadata = null; throw new ArgumentException(System.Windows.Forms.SR.GetString("InvalidResXFileReaderWriterTypes")); } }