Question

I working on a test program which to help me figure out how work with the Microsoft.Practices.EnterpriseLibrary.ExceptionHandling framework works. The program defines several custom exception types and associates custom exception handlers with each type. At run time, the program prompts the user for the type of exception to throw, throws the exception, and uses the ExceptionHandling framework to call an appropriate exception handler for the exception type:

using System;
using System.Collections.Specialized;
using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;
using Microsoft.Practices.EnterpriseLibrary.ExceptionHandling;
using Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Configuration;

namespace ConsoleApplication1
{
    public class AException  : Exception  { public AException(string message)  : base(message) { } }
    public class BException  : Exception  { public BException(string message)  : base(message) { } }
    public class BBException : BException { public BBException(string message) : base(message) { } }

    public class WrapperException : Exception
    {
        public WrapperException(Exception innerException)
            : base("Wrapped exception: [" + innerException.Message + "]", innerException) { }
    }

    public class MyExceptionHandler<T> : IExceptionHandler
    {
        protected NameValueCollection Ignore { get; set; }
        public MyExceptionHandler(NameValueCollection ignore)
        {
            Ignore = ignore;
        }

        #region IExceptionHandler Members

        public virtual Exception HandleException(Exception exception, Guid handlingInstanceId)
        {
            if (exception is T)
            {
                Console.WriteLine("Exception Handled:");
                Console.WriteLine("  Expected Type : [{0}]", typeof(T).ToString());
                Console.WriteLine("  Actual Type   : [{0}]", exception.GetType().ToString());
                Console.WriteLine("  Message       : [{0}]", exception.Message);
                Console.WriteLine();
            }
            else
            {
                Console.WriteLine("Unexpected Exception Type: [{0}]", exception.GetType().ToString());
            }
            return exception;
        }

        #endregion
    }

    [ConfigurationElementType(typeof(CustomHandlerData))]
    public class AExceptionHandler : MyExceptionHandler<AException>
    {
        public AExceptionHandler(NameValueCollection ignore) : base(ignore) { }
    }

    [ConfigurationElementType(typeof(CustomHandlerData))]
    public class BExceptionHandler : MyExceptionHandler<BException>
    {
        public BExceptionHandler(NameValueCollection ignore) : base(ignore) { }
    }

    [ConfigurationElementType(typeof(CustomHandlerData))]
    public class ExceptionHandler : MyExceptionHandler<Exception>
    {
        public ExceptionHandler(NameValueCollection ignore) : base(ignore) { }

        public override Exception HandleException(Exception exception, Guid handlingInstanceId)
        {
            var wrapper = new WrapperException(exception);
            return base.HandleException(wrapper, handlingInstanceId);
        }
    }


    class Program
    {
        static void ThrowSomething()
        {
            Console.Write("Enter the exception type: ");
            var x = Console.ReadLine();
            if (x.Equals("a"))
            {
                throw new AException(x);
            }
            else if (x.Equals("b"))
            {
                throw new BException(x);
            }
            else if (x.Equals("bb"))
            {
                throw new BBException(x);
            }
            else
            {
                throw new Exception(x);
            }
        }

        static void Main(string[] args)
        {
            ExceptionManager xm = EnterpriseLibraryContainer.Current.GetInstance<ExceptionManager>();
            while (true)
            {
                //xm.Process(ThrowSomething, "Policy");
                try
                {
                    ThrowSomething();
                }
                catch(Exception ex)
                {
                    Exception exToThrow = null;
                    if (ExceptionPolicy.HandleException(ex, "policy", out exToThrow))
                    {
                        if (exToThrow == null)
                        {
                            throw;
                        }
                        else
                        {
                            throw exToThrow;
                        }
                    }
                }
                Console.WriteLine();
            }
        }
    }
}

In the first iteration of this program, I used the ExceptionManager.Process() method to invoke my ThrowSomething() method. Using this method, everything worked great. I then modified the Main to use ExceptionPolicy.HandleException() instead. When I did this, I started getting this exception:

Unhandled Exception:
Microsoft.Practices.ServiceLocation.ActivationException: Activation
error occured while trying to get instance of type
ExceptionPolicyImpl, key “policy” —>
Microsoft.Practices.Unity.ResolutionFailedException: Resolution of the
dependency failed, type =
“Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.ExceptionPolicyImpl”,
name
= “policy”. Exception occurred while: while resolving. Exception is: InvalidOperationException – The type ExceptionPolicyImpl has multiple
constructors of length 2. Unable to disambiguate.

My App.config file contains the following:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="exceptionHandling" type="Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Configuration.ExceptionHandlingSettings, Microsoft.Practices.EnterpriseLibrary.ExceptionHandling, Version=5.0.414.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" requirePermission="true" />
    </configSections>
    <exceptionHandling>
        <exceptionPolicies>
            <add name="Policy">
                <exceptionTypes>
                    <add name="AException" type="ConsoleApplication1.AException, ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
                        postHandlingAction="None">
                        <exceptionHandlers>
                            <add type="ConsoleApplication1.AExceptionHandler, ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
                                name="AExceptionHandler" />
                        </exceptionHandlers>
                    </add>
                    <add name="BException" type="ConsoleApplication1.BException, ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
                        postHandlingAction="None">
                        <exceptionHandlers>
                            <add type="ConsoleApplication1.BExceptionHandler, ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
                                name="BExceptionHandler" />
                        </exceptionHandlers>
                    </add>
                    <add name="All Other Exceptions" type="System.Exception, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
                        postHandlingAction="NotifyRethrow">
                        <exceptionHandlers>
                            <add type="ConsoleApplication1.ExceptionHandler, ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
                                name="ExceptionHandler" />
                        </exceptionHandlers>
                    </add>
                </exceptionTypes>
            </add>
        </exceptionPolicies>
    </exceptionHandling>
</configuration>

Can anyone tell me why I am getting this exception and how to resolve the problem?

Answer 1

Well, I feel stupid. The problem was that spelled “policy” with a lowercase “p” instead of an uppercase “P”. Changing the line

if (ExceptionPolicy.HandleException(ex, "policy", out exToThrow))

to

if (ExceptionPolicy.HandleException(ex, "Policy", out exToThrow))

fixed the problem.