How to throw custom exception when exception type was passed by constructor

I've created class that takes Exception type in constructor

    private readonly Exception _exception;开发者_开发知识库

    public StringToObject(Exception exception)
    {
        _exception = exception;
    }

i wanted to throw exception

throw new _exception("");

but i got error: '._exception' is a 'field' but is used like a 'type'

is any possible ways to throw it?

---

This is not a good practice at all. Doing so will cause you to lose your stack trace related information. Please consider reading this section of Eric Lippert's blog:

Too Much Reuse

When you write

throw new Exception();

you instantiate this new exception. But then, since your private member _exception is already instantiated, you don't need to re-instantiate it, that is instantiating an instance, which doesn't make sense. Instead, use the following:

throw _exception;

This will do it.

---

To rethrow an existing exception like that use

throw _exception;

However, that will modify the call stack in the exception instance, so you will lose the original source of the exception. If you want to avoid that, you can throw a new exception with the instance as an inner exception.

---

I'm actually very confused about why you want to do this? Are you trying to create a custom exception to provide more information? If so, then you want to use this pattern.

First define a custom exception class that derives from Exception:

public class MyCustomException : Exception  // Or you could derive from ApplicationException
{
   public MyCustomException(string msg, Exception innerException)
   : base(msg, innerException)
   {
   }
}

You could also define additional parameters in your custom exception constructor to contain even more information if you wish. Then, in your application code...

public void SomeMethod()
{
   try
   {
        // Some code that might throw an exception
   }
   catch (Exception ex)
   {
        throw new MyCustomException("Additional error information", ex);
   }
}

You'll want to be sure to keep track of the inner exception, because that will have the most useful call stack information about what caused the exception in the first place.

---

throw _exception;

---

This example should work. I´ve included all the classes involved in the example.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    public class MyException : Exception
    {
        public MyException(string message) : base(message)
        {}

        //...
    }

    public class MyClass
    {
        private Exception exception;

        public MyClass(Exception e)
        {
            this.exception = e;
        }

        public void ThrowMyException()
        {
            throw exception;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyException myExceptionInstance = new MyException("A custom message");
            MyClass myClassInstance = new MyClass(myExceptionInstance);


            myClassInstance.ThrowMyException();

        }
    }
}

---

I suspect that what you're really looking for is to throw a new exception of your suggested type, in which case passing in a "Type" parameter (or even using a generic) would be the way forward.

However, I can't imagine a situation where this is a sensible design choice, so I'd have to urge you to reconsider (and perhaps post more of your requirements so that someone can suggest a better alternative!).