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!).