|
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
}
}
|