Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.ComponentModel/AuthoringOM/Fault.cs

@@ -0,0 +1,224 @@
+namespace System.Workflow.ComponentModel
+{
+    using System;
+    using System.Text;
+    using System.Reflection;
+    using System.Collections;
+    using System.CodeDom;
+    using System.ComponentModel;
+    using System.ComponentModel.Design;
+    using System.ComponentModel.Design.Serialization;
+    using System.Drawing;
+    using System.Runtime.Serialization;
+    using System.Globalization;
+    using System.Workflow.ComponentModel;
+    using System.Workflow.ComponentModel.Design;
+    using System.Collections.Generic;
+    using System.Workflow.Runtime;
+    using System.Workflow.ComponentModel.Compiler;
+
+    [SRDescription(SR.FaultActivityDescription)]
+    [ToolboxItem(typeof(ActivityToolboxItem))]
+    [Designer(typeof(ThrowDesigner), typeof(IDesigner))]
+    [ToolboxBitmap(typeof(ThrowActivity), "Resources.Throw.png")]
+    [SRCategory(SR.Standard)]
+    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
+    public sealed class ThrowActivity : Activity, ITypeFilterProvider, IDynamicPropertyTypeProvider
+    {
+        [Browsable(false)]
+        public static readonly DependencyProperty FaultProperty = DependencyProperty.Register("Fault", typeof(Exception), typeof(ThrowActivity));
+        [Browsable(false)]
+        public static readonly DependencyProperty FaultTypeProperty = DependencyProperty.Register("FaultType", typeof(Type), typeof(ThrowActivity));
+
+        #region Constructors
+
+        public ThrowActivity()
+        {
+        }
+
+        public ThrowActivity(string name)
+            : base(name)
+        {
+        }
+
+        #endregion
+
+        protected internal override void Initialize(IServiceProvider provider)
+        {
+            if (this.Parent == null)
+                throw new InvalidOperationException(SR.GetString(SR.Error_MustHaveParent));
+
+            base.Initialize(provider);
+        }
+
+        protected internal override sealed ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
+        {
+            if (this.Fault == null && this.FaultType == null)
+            {
+                throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, SR.Error_PropertyNotSet, FaultProperty.Name));
+            }
+
+            if (this.FaultType != null && !typeof(Exception).IsAssignableFrom(this.FaultType))
+            {
+                throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, SR.Error_ExceptionTypeNotException, this.FaultType, FaultTypeProperty.Name));
+            }
+
+            if (this.Fault != null && this.FaultType != null && !this.FaultType.IsInstanceOfType(this.Fault))
+            {
+                throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, SR.Error_FaultIsNotOfFaultType));
+            }
+
+            if (this.Fault != null)
+                throw this.Fault;
+
+            ConstructorInfo cInfo = this.FaultType.GetConstructor(new Type[] { });
+
+            if (cInfo != null)
+                throw (Exception)cInfo.Invoke(null);
+
+            throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, SR.Error_FaultTypeNoDefaultConstructor, this.FaultType));
+        }
+
+        [TypeConverter(typeof(FaultConverter))]
+        [SRCategory(SR.Handlers)]
+        [SRDescription(SR.FaultDescription)]
+        [MergableProperty(false)]
+        [DefaultValue(null)]
+        public Exception Fault
+        {
+            get
+            {
+                return base.GetValue(FaultProperty) as Exception;
+            }
+            set
+            {
+                base.SetValue(FaultProperty, value);
+            }
+        }
+
+        [Editor(typeof(TypeBrowserEditor), typeof(System.Drawing.Design.UITypeEditor))]
+        [SRCategory(SR.Handlers)]
+        [SRDescription(SR.FaultTypeDescription)]
+        [MergableProperty(false)]
+        [DefaultValue(null)]
+        [TypeConverter(typeof(FaultTypeConverter))]
+        public Type FaultType
+        {
+            get
+            {
+                return base.GetValue(FaultTypeProperty) as Type;
+            }
+            set
+            {
+                base.SetValue(FaultTypeProperty, value);
+            }
+        }
+
+        #region ITypeFilterProvider Members
+        bool ITypeFilterProvider.CanFilterType(Type type, bool throwOnError)
+        {
+            bool isAssignable = TypeProvider.IsAssignable(typeof(Exception), type);
+
+            if (throwOnError && !isAssignable)
+                throw new Exception(SR.GetString(SR.Error_ExceptionTypeNotException, type, "Type"));
+
+            return isAssignable;
+        }
+
+        string ITypeFilterProvider.FilterDescription
+        {
+            get
+            {
+                return SR.GetString(SR.FilterDescription_FaultHandlerActivity);
+            }
+        }
+        #endregion
+
+        #region IDynamicPropertyTypeProvider Members
+        Type IDynamicPropertyTypeProvider.GetPropertyType(IServiceProvider serviceProvider, string propertyName)
+        {
+            if (!String.IsNullOrEmpty(propertyName) && propertyName.Equals("Fault", StringComparison.Ordinal))
+                return FaultType;
+            else
+                return null;
+        }
+
+        AccessTypes IDynamicPropertyTypeProvider.GetAccessType(IServiceProvider serviceProvider, string propertyName)
+        {
+            return AccessTypes.Read;
+        }
+        #endregion
+
+        #region Class FaultConverter
+        private sealed class FaultConverter : TypeConverter
+        {
+            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+            {
+                if (sourceType == typeof(string))
+                    return false;
+
+                return base.CanConvertFrom(context, sourceType);
+            }
+        }
+        #endregion
+
+        #region Class FaultTypeConverter
+        private sealed class FaultTypeConverter : TypeConverter
+        {
+            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+            {
+                if (sourceType == typeof(string))
+                    return true;
+
+                return base.CanConvertFrom(context, sourceType);
+            }
+
+            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+            {
+                object convertedValue = value;
+
+                string stringValue = value as string;
+                ITypeProvider typeProvider = context.GetService(typeof(ITypeProvider)) as ITypeProvider;
+                if (context != null && typeProvider != null && !String.IsNullOrEmpty(stringValue))
+                {
+                    Type type = typeProvider.GetType(stringValue, false);
+                    if (type != null)
+                    {
+                        ITypeFilterProvider typeFilterProvider = context.Instance as ITypeFilterProvider;
+                        if (typeFilterProvider != null)
+                            typeFilterProvider.CanFilterType(type, true);
+
+                        convertedValue = type;
+                    }
+                }
+                else if (stringValue != null && stringValue.Length == 0)
+                {
+                    convertedValue = null;
+                }
+
+                return convertedValue;
+            }
+
+            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+            {
+                if (destinationType == typeof(string))
+                    return true;
+
+                return base.CanConvertTo(context, destinationType);
+            }
+
+            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+            {
+                if (destinationType == typeof(string))
+                {
+                    Type type = value as Type;
+                    if (type != null)
+                        return type.FullName;
+                }
+
+                return base.ConvertTo(context, culture, value, destinationType);
+            }
+        }
+        #endregion
+    }
+}