private bool CanHandleException(FaultHandlerActivity exceptionHandler, Type et)
{
Type faultType = exceptionHandler.FaultType;
if (!(et == faultType))
{
return(et.IsSubclassOf(faultType));
}
return(true);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
FaultHandlersActivity activity = obj as FaultHandlersActivity;
if (activity == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(FaultHandlersActivity).FullName }), "obj");
}
Hashtable hashtable = new Hashtable();
ArrayList list = new ArrayList();
bool flag = false;
foreach (Activity activity2 in activity.EnabledActivities)
{
if (!(activity2 is FaultHandlerActivity))
{
if (!flag)
{
errors.Add(new ValidationError(SR.GetString("Error_FaultHandlersActivityDeclNotAllFaultHandlerActivityDecl"), 0x51e));
flag = true;
}
}
else
{
FaultHandlerActivity activity3 = (FaultHandlerActivity)activity2;
Type faultType = activity3.FaultType;
if (faultType != null)
{
if (hashtable[faultType] == null)
{
hashtable[faultType] = 1;
list.Add(faultType);
}
else if (((int)hashtable[faultType]) == 1)
{
errors.Add(new ValidationError(string.Format(CultureInfo.CurrentCulture, SR.GetString("Error_ScopeDuplicateFaultHandlerActivityFor"), new object[] { Helpers.GetEnclosingActivity(activity).GetType().Name, faultType.FullName }), 0x520));
hashtable[faultType] = 2;
}
foreach (Type type2 in list)
{
if ((type2 != faultType) && type2.IsAssignableFrom(faultType))
{
errors.Add(new ValidationError(SR.GetString("Error_FaultHandlerActivityWrongOrder", new object[] { faultType.Name, type2.Name }), 0x521));
}
}
}
}
}
if (activity.AlternateFlowActivities.Count > 0)
{
errors.Add(new ValidationError(SR.GetString("Error_ModelingConstructsCanNotContainModelingConstructs"), 0x61f));
}
return(errors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
FaultHandlerActivity activity = obj as FaultHandlerActivity;
if (activity == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(FaultHandlerActivity).FullName }), "obj");
}
if (!(activity.Parent is FaultHandlersActivity))
{
errors.Add(new ValidationError(SR.GetString("Error_FaultHandlerActivityParentNotFaultHandlersActivity"), 0x519));
}
if (!(manager.GetService(typeof(ITypeProvider)) is ITypeProvider))
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
ValidationError item = null;
if (activity.FaultType == null)
{
item = new ValidationError(SR.GetString("Error_TypePropertyInvalid", new object[] { "FaultType" }), 0x116)
{
PropertyName = "FaultType"
};
errors.Add(item);
}
else if (!TypeProvider.IsAssignable(typeof(Exception), activity.FaultType))
{
item = new ValidationError(SR.GetString("Error_TypeTypeMismatch", new object[] { "FaultType", typeof(Exception).FullName }), 0x51a)
{
PropertyName = "FaultType"
};
errors.Add(item);
}
if (activity.EnabledActivities.Count == 0)
{
errors.Add(new ValidationError(SR.GetString("Warning_EmptyBehaviourActivity", new object[] { typeof(FaultHandlerActivity).FullName, activity.QualifiedName }), 0x1a3, true));
}
if (activity.AlternateFlowActivities.Count > 0)
{
errors.Add(new ValidationError(SR.GetString("Error_ModelingConstructsCanNotContainModelingConstructs"), 0x61f));
}
return(errors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
FaultHandlersActivity exceptionHandlers = obj as FaultHandlersActivity;
if (exceptionHandlers == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(FaultHandlersActivity).FullName), "obj");
}
Hashtable exceptionTypes = new Hashtable();
ArrayList previousExceptionTypes = new ArrayList();
bool bFoundNotFaultHandlerActivity = false;
foreach (Activity activity in exceptionHandlers.EnabledActivities)
{
// All child activities must be FaultHandlerActivity
if (!(activity is FaultHandlerActivity))
{
if (!bFoundNotFaultHandlerActivity)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_FaultHandlersActivityDeclNotAllFaultHandlerActivityDecl), ErrorNumbers.Error_FaultHandlersActivityDeclNotAllFaultHandlerActivityDecl));
bFoundNotFaultHandlerActivity = true;
}
}
else
{
FaultHandlerActivity exceptionHandler = (FaultHandlerActivity)activity;
Type catchType = exceptionHandler.FaultType;
if (catchType != null)
{
if (exceptionTypes[catchType] == null)
{
exceptionTypes[catchType] = 1;
previousExceptionTypes.Add(catchType);
}
else if ((int)exceptionTypes[catchType] == 1)
{
/*if (catchType == typeof(System.Exception))
* validationErrors.Add(new ValidationError(SR.GetString(SR.Error_ScopeDuplicateFaultHandlerActivityForAll, exceptionHandlers.EnclosingDataContextActivity.GetType().Name), ErrorNumbers.Error_ScopeDuplicateFaultHandlerActivityForAll));
* else*/
validationErrors.Add(new ValidationError(string.Format(CultureInfo.CurrentCulture, SR.GetString(SR.Error_ScopeDuplicateFaultHandlerActivityFor), new object[] { Helpers.GetEnclosingActivity(exceptionHandlers).GetType().Name, catchType.FullName }), ErrorNumbers.Error_ScopeDuplicateFaultHandlerActivityFor));
exceptionTypes[catchType] = 2;
}
foreach (Type previousType in previousExceptionTypes)
{
if (previousType != catchType && previousType.IsAssignableFrom(catchType))
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_FaultHandlerActivityWrongOrder, catchType.Name, previousType.Name), ErrorNumbers.Error_FaultHandlerActivityWrongOrder));
}
}
}
}
}
// fault handlers can not contain fault handlers, compensation handler and cancellation handler
if (((ISupportAlternateFlow)exceptionHandlers).AlternateFlowActivities.Count > 0)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_ModelingConstructsCanNotContainModelingConstructs), ErrorNumbers.Error_ModelingConstructsCanNotContainModelingConstructs));
}
return(validationErrors);
}
private bool CanHandleException(FaultHandlerActivity exceptionHandler, Type et)
{
Type canHandleType = exceptionHandler.FaultType;
return(et == canHandleType || et.IsSubclassOf(canHandleType));
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
FaultHandlerActivity exceptionHandler = obj as FaultHandlerActivity;
if (exceptionHandler == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(FaultHandlerActivity).FullName), "obj");
}
// check parent must be exception handler
if (!(exceptionHandler.Parent is FaultHandlersActivity))
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_FaultHandlerActivityParentNotFaultHandlersActivity), ErrorNumbers.Error_FaultHandlerActivityParentNotFaultHandlersActivity));
}
// validate exception property
ITypeProvider typeProvider = manager.GetService(typeof(ITypeProvider)) as ITypeProvider;
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
// Validate the required Type property
ValidationError error = null;
if (exceptionHandler.FaultType == null)
{
error = new ValidationError(SR.GetString(SR.Error_TypePropertyInvalid, "FaultType"), ErrorNumbers.Error_PropertyNotSet);
error.PropertyName = "FaultType";
validationErrors.Add(error);
}
else if (!TypeProvider.IsAssignable(typeof(Exception), exceptionHandler.FaultType))
{
error = new ValidationError(SR.GetString(SR.Error_TypeTypeMismatch, new object[] { "FaultType", typeof(Exception).FullName }), ErrorNumbers.Error_TypeTypeMismatch);
error.PropertyName = "FaultType";
validationErrors.Add(error);
}
// Generate a warning for unrechable code, if the catch type is all and this is not the last exception handler.
/*if (exceptionHandler.FaultType == typeof(System.Exception) && exceptionHandler.Parent is FaultHandlersActivity && ((FaultHandlersActivity)exceptionHandler.Parent).Activities.IndexOf(exceptionHandler) != ((FaultHandlersActivity)exceptionHandler.Parent).Activities.Count - 1)
* {
* error = new ValidationError(SR.GetString(SR.Error_FaultHandlerActivityAllMustBeLast), ErrorNumbers.Error_FaultHandlerActivityAllMustBeLast, true);
* error.PropertyName = "FaultType";
* validationErrors.Add(error);
* }*/
if (exceptionHandler.EnabledActivities.Count == 0)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Warning_EmptyBehaviourActivity, typeof(FaultHandlerActivity).FullName, exceptionHandler.QualifiedName), ErrorNumbers.Warning_EmptyBehaviourActivity, true));
}
// fault handler can not contain fault handlers, compensation handler and cancellation handler
if (((ISupportAlternateFlow)exceptionHandler).AlternateFlowActivities.Count > 0)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_ModelingConstructsCanNotContainModelingConstructs), ErrorNumbers.Error_ModelingConstructsCanNotContainModelingConstructs));
}
return(validationErrors);
}