// Token: 0x060074CF RID: 29903 RVA: 0x00216970 File Offset: 0x00214B70 private void ProcessRequest(object o) { AsyncDataRequest asyncDataRequest = (AsyncDataRequest)o; try { asyncDataRequest.Complete(asyncDataRequest.DoWork()); } catch (Exception ex) { if (CriticalExceptions.IsCriticalApplicationException(ex)) { throw; } asyncDataRequest.Fail(ex); } catch { asyncDataRequest.Fail(new InvalidOperationException(SR.Get("NonCLSException", new object[] { "processing an async data request" }))); } object syncRoot = this._list.SyncRoot; lock (syncRoot) { this._list.Remove(asyncDataRequest); } }
object GetTypedParamValue(string param, Type type, bool throwOnError) { object value = null; if (type == typeof(string)) { return(param); } TypeConverter tc = TypeDescriptor.GetConverter(type); if (tc != null && tc.CanConvertFrom(typeof(string))) { // PreSharp uses message numbers that the C# compiler doesn't know about. // Disable the C# complaints, per the PreSharp documentation. #pragma warning disable 1634, 1691 // PreSharp complains about catching NullReference (and other) exceptions. // It doesn't recognize that IsCritical[Application]Exception() handles these correctly. #pragma warning disable 56500 try { value = tc.ConvertFromString(null, CultureInfo.InvariantCulture, param); // technically the converter can return null as a legitimate // value. In practice, this seems always to be a sign that // the conversion didn't work (often because the converter // reverts to the default behavior - returning null). So // we treat null as an "error", and keep trying for something // better. (See bug 861966) } // catch all exceptions. We simply want to move on to the next // candidate indexer. catch (Exception ex) { if (CriticalExceptions.IsCriticalApplicationException(ex) || throwOnError) { throw; } } catch { if (throwOnError) { throw; } } #pragma warning restore 56500 #pragma warning restore 1634, 1691 } if (value == null && type.IsAssignableFrom(typeof(string))) { value = param; } return(value); }
// Token: 0x06001C5A RID: 7258 RVA: 0x000856C4 File Offset: 0x000838C4 private object CreateObjectInstance(out Exception e) { object result = null; string text = null; e = null; try { object[] array = new object[this._constructorParameters.Count]; this._constructorParameters.CopyTo(array, 0); result = Activator.CreateInstance(this._objectType, BindingFlags.Default, null, array, CultureInfo.InvariantCulture); this.OnPropertyChanged("ObjectInstance"); } catch (ArgumentException ex) { text = "Cannot create Context Affinity object."; e = ex; } catch (COMException ex2) { text = "Marshaling issue detected."; e = ex2; } catch (MissingMethodException ex3) { text = "Wrong parameters for constructor."; e = ex3; } catch (Exception ex4) { if (CriticalExceptions.IsCriticalApplicationException(ex4)) { throw; } text = null; e = ex4; } catch { text = null; e = new InvalidOperationException(SR.Get("ObjectDataProviderNonCLSException", new object[] { this._objectType.Name })); } if (e != null || text != null) { if (TraceData.IsEnabled) { TraceData.Trace(TraceEventType.Error, TraceData.ObjDPCreateFailed, this._objectType.Name, text, e); } if (!this.IsAsynchronous && text == null) { throw e; } } return(result); }
//------------------------------------------------------ // // Private methods // //------------------------------------------------------ // Run a single request. This method gets scheduled on a worker thread // from the process ThreadPool. void ProcessRequest(object o) { AsyncDataRequest request = (AsyncDataRequest)o; // PreSharp uses message numbers that the C# compiler doesn't know about. // Disable the C# complaints, per the PreSharp documentation. #pragma warning disable 1634, 1691 // PreSharp complains about catching NullReference (and other) exceptions. // In this case, these are precisely the ones we want to catch the most, // so that a failure on a worker thread doesn't affect the main thread. #pragma warning disable 56500 // run the request - this may take a while try { request.Complete(request.DoWork()); } // Catch all exceptions. There is no app code on the stack, // so the exception isn't actionable by the app. // Yet we don't want to crash the app. catch (Exception ex) { if (CriticalExceptions.IsCriticalApplicationException(ex)) { throw; } request.Fail(ex); } catch // non CLS compliant exception { request.Fail(new InvalidOperationException(SR.Get(SRID.NonCLSException, "processing an async data request"))); } #pragma warning restore 56500 #pragma warning restore 1634, 1691 // remove the request from the list lock (_list.SyncRoot) { _list.Remove(request); } }
// Token: 0x06000962 RID: 2402 RVA: 0x00020E34 File Offset: 0x0001F034 internal bool ConvertAndMatch(object state) { object obj = this.Value; string text = obj as string; Type type = (state != null) ? state.GetType() : null; if (text != null && type != null && type != typeof(string)) { BindingValueCache bindingValueCache = this.BindingValueCache; Type bindingValueType = bindingValueCache.BindingValueType; object obj2 = bindingValueCache.ValueAsBindingValueType; if (type != bindingValueType) { obj2 = obj; TypeConverter converter = DefaultValueConverter.GetConverter(type); if (converter != null && converter.CanConvertFrom(typeof(string))) { try { obj2 = converter.ConvertFromString(null, TypeConverterHelper.InvariantEnglishUS, text); } catch (Exception ex) { if (CriticalExceptions.IsCriticalApplicationException(ex)) { throw; } } catch { } } bindingValueCache = new BindingValueCache(type, obj2); this.BindingValueCache = bindingValueCache; } obj = obj2; } return(this.Match(state, obj)); }
// Token: 0x060007C0 RID: 1984 RVA: 0x0001884C File Offset: 0x00016A4C private object GetTypedParamValue(string param, Type type, bool throwOnError) { object obj = null; if (type == typeof(string)) { return(param); } TypeConverter converter = TypeDescriptor.GetConverter(type); if (converter != null && converter.CanConvertFrom(typeof(string))) { try { obj = converter.ConvertFromString(null, CultureInfo.InvariantCulture, param); } catch (Exception ex) { if (CriticalExceptions.IsCriticalApplicationException(ex) || throwOnError) { throw; } } catch { if (throwOnError) { throw; } } } if (obj == null && type.IsAssignableFrom(typeof(string))) { obj = param; } return(obj); }
object InvokeMethodOnInstance(out Exception e) { object data = null; string error = null; // string that describes known error e = null; Debug.Assert(_objectType != null); object[] parameters = new object[_methodParameters.Count]; _methodParameters.CopyTo(parameters, 0); // PreSharp uses message numbers that the C# compiler doesn't know about. // Disable the C# complaints, per the PreSharp documentation. #pragma warning disable 1634, 1691 // PreSharp complains about catching NullReference (and other) exceptions. // It doesn't recognize that IsCritical[Application]Exception() handles these correctly. #pragma warning disable 56500 try { data = _objectType.InvokeMember(MethodName, s_invokeMethodFlags, null, _objectInstance, parameters, System.Globalization.CultureInfo.InvariantCulture); } catch (ArgumentException ae) { error = "Parameter array contains a string that is a null reference."; e = ae; } catch (MethodAccessException mae) { error = "The specified member is a class initializer."; e = mae; } catch (MissingMethodException mme) { error = "No method was found with matching parameter signature."; e = mme; } catch (TargetException te) { error = "The specified member cannot be invoked on target."; e = te; } catch (AmbiguousMatchException ame) { error = "More than one method matches the binding criteria."; e = ame; } // Catch all exceptions. When there is no app code on the stack, // the exception isn't actionable by the app. // Yet we don't want to crash the app. catch (Exception ex) { if (CriticalExceptions.IsCriticalApplicationException(ex)) { throw; } error = null; // indicate unknown error e = ex; } catch //FXCop Fix: CatchNonClsCompliantExceptionsInGeneralHandlers { error = null; // indicate unknown error e = new InvalidOperationException(SR.Get(SRID.ObjectDataProviderNonCLSExceptionInvoke, MethodName, _objectType.Name)); } #pragma warning restore 56500 #pragma warning restore 1634, 1691 if (e != null || error != null) { // report known errors through TraceData (instead of throwing exceptions) if (TraceData.IsEnabled) { TraceData.Trace(TraceEventType.Error, TraceData.ObjDPInvokeFailed, MethodName, _objectType.Name, error, e); } // in async mode we pass all exceptions to main thread; // in [....] mode we don't handle unknown exceptions. if (!IsAsynchronous && error == null) { throw e; } } return(data); }
object CreateObjectInstance(out Exception e) { object instance = null; string error = null; // string that describes known error e = null; // PreSharp uses message numbers that the C# compiler doesn't know about. // Disable the C# complaints, per the PreSharp documentation. #pragma warning disable 1634, 1691 // PreSharp complains about catching NullReference (and other) exceptions. // It doesn't recognize that IsCritical[Application]Exception() handles these correctly. #pragma warning disable 56500 Debug.Assert(_objectType != null); try { object[] parameters = new object[_constructorParameters.Count]; _constructorParameters.CopyTo(parameters, 0); instance = Activator.CreateInstance(_objectType, 0, null, parameters, System.Globalization.CultureInfo.InvariantCulture); OnPropertyChanged(s_instance); } catch (ArgumentException ae) { // this may fire when trying to create Context Affinity objects error = "Cannot create Context Affinity object."; e = ae; } catch (System.Runtime.InteropServices.COMException ce) { // this may fire due to marshalling issues error = "Marshaling issue detected."; e = ce; } catch (System.MissingMethodException mme) { // this may be due to setting parameters to a non parameter // only class contructor error = "Wrong parameters for constructor."; e = mme; } // Catch all exceptions. When there is no app code on the stack, // the exception isn't actionable by the app. // Yet we don't want to crash the app. catch (Exception ex) { if (CriticalExceptions.IsCriticalApplicationException(ex)) { throw; } error = null; // indicate unknown error e = ex; } catch // non CLS compliant exception { error = null; // indicate unknown error e = new InvalidOperationException(SR.Get(SRID.ObjectDataProviderNonCLSException, _objectType.Name)); } #pragma warning restore 56500 #pragma warning restore 1634, 1691 if (e != null || error != null) { // report known errors through TraceData (instead of throwing exceptions) if (TraceData.IsEnabled) { TraceData.Trace(TraceEventType.Error, TraceData.ObjDPCreateFailed, _objectType.Name, error, e); } // in async mode we pass all exceptions to main thread; // in [....] mode we don't handle unknown exceptions. if (!IsAsynchronous && error == null) { throw e; } } return(instance); }
/// <summary> /// Validate is called when Data binding is updating /// </summary> public override ValidationResult Validate(object value, CultureInfo cultureInfo) { // This rule is called during the CommittedValue step, so the value is the // owner of the rule collection - either a BindingGroup or an individual // binding expression. BindingGroup bindingGroup; BindingExpression bindingExpr; if ((bindingGroup = value as BindingGroup) != null) { // in a BindingGroup, check the item-level IDataErrorInfo for each // source item in the group IList items = bindingGroup.Items; for (int i = items.Count - 1; i >= 0; --i) { IDataErrorInfo idei = items[i] as IDataErrorInfo; if (idei != null) { string error = idei.Error; if (!String.IsNullOrEmpty(error)) { return(new ValidationResult(false, error)); } } } } else if ((bindingExpr = value as BindingExpression) != null) { // in a binding, check the error info for the binding's source // property IDataErrorInfo idei = bindingExpr.SourceItem as IDataErrorInfo; string name = (idei != null) ? bindingExpr.SourcePropertyName : null; if (!String.IsNullOrEmpty(name)) { // get the data error information, if any, by calling idie[name]. // We do this in a paranoid way, even though indexers with // string-valued arguments are not supposed to throw exceptions. // PreSharp uses message numbers that the C# compiler doesn't know about. // Disable the C# complaints, per the PreSharp documentation. #pragma warning disable 1634, 1691 // PreSharp complains about catching NullReference (and other) exceptions. // It doesn't recognize that IsCritical[Application]Exception() handles these correctly. #pragma warning disable 56500 string error; try { error = idei[name]; } catch (Exception ex) { if (CriticalExceptions.IsCriticalApplicationException(ex)) { throw; } error = null; if (TraceData.IsEnabled) { TraceData.TraceAndNotify(TraceEventType.Error, TraceData.DataErrorInfoFailed( name, idei.GetType().FullName, ex.GetType().FullName, ex.Message), bindingExpr); } } #pragma warning restore 56500 #pragma warning restore 1634, 1691 if (!String.IsNullOrEmpty(error)) { return(new ValidationResult(false, error)); } } } else { throw new InvalidOperationException(SR.Get(SRID.ValidationRule_UnexpectedValue, this, value)); } return(ValidationResult.ValidResult); }
/// <summary>Performs validation checks on a value.</summary> /// <param name="value">The value to check.</param> /// <param name="cultureInfo">The culture to use in this rule.</param> /// <returns>The result of the validation.</returns> // Token: 0x060044E3 RID: 17635 RVA: 0x001385D4 File Offset: 0x001367D4 public override ValidationResult Validate(object value, CultureInfo cultureInfo) { BindingGroup bindingGroup; if ((bindingGroup = (value as BindingGroup)) != null) { IList items = bindingGroup.Items; for (int i = items.Count - 1; i >= 0; i--) { IDataErrorInfo dataErrorInfo = items[i] as IDataErrorInfo; if (dataErrorInfo != null) { string error = dataErrorInfo.Error; if (!string.IsNullOrEmpty(error)) { return(new ValidationResult(false, error)); } } } } else { BindingExpression bindingExpression; if ((bindingExpression = (value as BindingExpression)) == null) { throw new InvalidOperationException(SR.Get("ValidationRule_UnexpectedValue", new object[] { this, value })); } IDataErrorInfo dataErrorInfo2 = bindingExpression.SourceItem as IDataErrorInfo; string text = (dataErrorInfo2 != null) ? bindingExpression.SourcePropertyName : null; if (!string.IsNullOrEmpty(text)) { string text2; try { text2 = dataErrorInfo2[text]; } catch (Exception ex) { if (CriticalExceptions.IsCriticalApplicationException(ex)) { throw; } text2 = null; if (TraceData.IsEnabled) { TraceData.Trace(TraceEventType.Error, TraceData.DataErrorInfoFailed(new object[] { text, dataErrorInfo2.GetType().FullName, ex.GetType().FullName, ex.Message }), bindingExpression); } } if (!string.IsNullOrEmpty(text2)) { return(new ValidationResult(false, text2)); } } } return(ValidationResult.ValidResult); }
// Token: 0x06001C5B RID: 7259 RVA: 0x000857F4 File Offset: 0x000839F4 private object InvokeMethodOnInstance(out Exception e) { object result = null; string text = null; e = null; object[] array = new object[this._methodParameters.Count]; this._methodParameters.CopyTo(array, 0); try { result = this._objectType.InvokeMember(this.MethodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod | BindingFlags.OptionalParamBinding, null, this._objectInstance, array, CultureInfo.InvariantCulture); } catch (ArgumentException ex) { text = "Parameter array contains a string that is a null reference."; e = ex; } catch (MethodAccessException ex2) { text = "The specified member is a class initializer."; e = ex2; } catch (MissingMethodException ex3) { text = "No method was found with matching parameter signature."; e = ex3; } catch (TargetException ex4) { text = "The specified member cannot be invoked on target."; e = ex4; } catch (AmbiguousMatchException ex5) { text = "More than one method matches the binding criteria."; e = ex5; } catch (Exception ex6) { if (CriticalExceptions.IsCriticalApplicationException(ex6)) { throw; } text = null; e = ex6; } catch { text = null; e = new InvalidOperationException(SR.Get("ObjectDataProviderNonCLSExceptionInvoke", new object[] { this.MethodName, this._objectType.Name })); } if (e != null || text != null) { if (TraceData.IsEnabled) { TraceData.Trace(TraceEventType.Error, TraceData.ObjDPInvokeFailed, new object[] { this.MethodName, this._objectType.Name, text, e }); } if (!this.IsAsynchronous && text == null) { throw e; } } return(result); }