What is the appropriate exception to throw for an Object being passed in and needing to be cast to the generic parameter?

public IPredefinedInterface
{
    void DoSomething(Object obj);
}

public class MyClass<T> : IPredefinedInterface
{
    public void DoSomething(Object obj)
    {
        if (!(obj is T)) throw new ???

        SomeOtherFunc((T)obj);
    }
}

Not sure what the appropriate exception he开发者_运维百科re is... ArgumentException, InvalidCastException, etc?

---

It's a problem with the argument, so ArgumentException. You haven't actually done the cast, so InvalidCastException is not appropriate.

---

Consider the example of IList, which supports Add operations using type object. When implemented by the generic List<T>, you get an ArgumentException for invalid types.

var list = new List<int>();
var ilist = list as IList;
ilist.Add("A");

Result:

ArgumentException: The value "A" is not of type "System.Int32" and cannot be used in this generic collection.Parameter name: value

In examples like this, I might tend to follow the precedents set by BCL classes unless there are compelling arguments against it.

---

I would consider making a generic interface:

 public interface IPredefinedInterface<T>
 {
       void DoSomething(T obj)
 }

Then implement like so:

 public clas MyClass<T> : IPredefinedInterface<T>
 {
      public void DoSomething(T obj)
      {
           // It's now always T, eliminating the need for an exception
      }
 }

If you can't go with that pattern (because you want to be able to pass any type in), then I would suggest going with a context specific exception for that class:

 public class InvalidMyClassInputException : ApplicationException
 {
      public InvalidMyClassInputException(object obj)
         : base("An invalid call to DoSomething was made with object of type: " + obj.GetType().Name)
      {
      }
 }

---

Whenever a cast causes an exception (or if something cannot be cast), a InvalidCastException is appropriate.

However, re-architecting your code may be a better solution, and allow compile-time checking:

public IPredefinedInterface<T>
{
    void DoSomething(T obj);
}

public class MyClass<T> : IPredefinedInterface<T>
{
    public void DoSomething(T obj)
    {

        SomeOtherFunc((T)obj);
    }
}

Then you don't even need to check because the environment and/ or compiler is doing it for you, which lets your code be much more simple.