Activator.CreateInstance and Generic method in C# - c#-4.0

Question

interface IExecutor
{
void Execute();
}
class Executor2<T> where T : IExecutor
{
public void Execute()
{
var ex = (T)Activator.CreateInstance(typeof(T));
ex.Execute();
}
}
It was a question at an interview. They told me that sometimes this code falls (causes exceptions) and there are at least 3 reasons that could cause the problems. It's unknown what exceptions were there. But the method Execute was created good, its implementation has no fault.
Does anybody have a suggestion about that?
Edit: There are at least 3 reasons that could cause the problems. What are these reasons?

Answer 1

On the face of it I can see a few issues.
The code doesn't compile, but I can ignore that and make it compile.
The code doesn't do what you think it does.
To explain 2: you specify a type T at the class definition with a constraint on IExecutor, but you then define another type T at the method level without a constraint. This doesn't compile.
If I fix this and remove the <T> definition from the method I can see a number of reasons for it failing without much warning:
ex is null.
Type T doesn't have a public parameterless constructor defined.
Perhaps it cannot load the DLL containing T.
As spotted by Jakub:
T could be an interface (no constructor).
T could be an abstract class, these don't allow instances to be created directly.
The first can be guarded against using a null check if (ex != null) and the second can be guarded against using another generic constraint new():
class Executor2<T> where T : IExecutor, new()
{
}
Obviously you could also amend your code to including exception logging. This might be useful in figuring out what the actual problems are instead of just stabbing in the dark:
public void Execute<T>()
{
try
{
var ex = (T)Activator.CreateInstance(typeof(T));
ex.Execute();
}
catch (Exception ex)
{
Log(ex); // Mystical logging framework.
throw;
}
}
This is the only answer I can cobble together considering I didn't understand the question.
If I were asked this in an interview I'd likely say I couldn't name all 3, but I'd know how to change the code to be more maintainable and tell me what was wrong. Then I'd likely walk for asking pointless interview questions.

Answer 2

T may be an interface or abstract class - and you cannot create instances of them, or T doesn't have a parameterless constructor.
Also, var ex = (T)Activator.CreateInstance(typeof(T)); could be rewritten as var ex = Activator.CreateInstance<T>();

Answer 3

Is it assumed that there is no fault in T's design? By which I mean, if T defines a static constructor which does Bad Stuff, type initialisation for T will fail giving a different exception to that which would occur if it did not have a parameterless constructor.
For that matter, if T defines a parameterless constructor which will fail then it's also broken.
Also, if the type has a private constructor you will get an error. Or if the type inherits from a type which will cause a TypeInitialisationException
[Edit]
Try this:
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
try {
new Executor2<IExecutor>().Execute();
}
catch { Console.WriteLine("Failed IExecutor"); }
try { new Executor2<AbstractExecutorWithImpl>().Execute(); }
catch { Console.WriteLine("Failed AbstractExecutorWithImpl"); }
try { new Executor2<AbstractExecutorWithNoImpl>().Execute(); }
catch { Console.WriteLine("Failed AbstractExecutorWithNoImpl"); }
try { new Executor2<ConcreteExecutor>().Execute(); }
catch { Console.WriteLine("Failed ConcreteExecutor"); }
try { new Executor2<DerivedExecutor>().Execute(); }
catch { Console.WriteLine("Failed DerivedExecutor"); }
try { new Executor2<DerivedExecutorWithBadConstr>().Execute(); }
catch { Console.WriteLine("Failed DerivedExecutorWithBadConstr"); }
try { new Executor2<DerivedExecutorWithPrivateConstr>().Execute(); }
catch { Console.WriteLine("Failed DerivedExecutorWithPrivateConstr"); }
try { new Executor2<DerivedExecutorWithPublicBadConstr>().Execute(); }
catch { Console.WriteLine("Failed DerivedExecutorWithPublicBadConstr"); }
Console.ReadLine();
}
}
interface IExecutor
{
void Execute();
}
abstract class AbstractExecutorWithImpl : IExecutor
{
public void Execute()
{
Console.Write("Executing AbstractExecutorWithImpl ");
}
}
abstract class AbstractExecutorWithNoImpl : IExecutor
{
public abstract void Execute();
}
class ConcreteExecutor : IExecutor
{
public void Execute()
{
Console.WriteLine("Executing ConcreteExecutor");
}
}
class DerivedExecutor : AbstractExecutorWithNoImpl
{
public override void Execute()
{
Console.WriteLine("Executing DerivedExecutor");
}
}
class DerivedExecutorWithBadConstr : IExecutor
{
static DerivedExecutorWithBadConstr() { throw new Exception("Static initialisation Exception"); }
public void Execute()
{
Console.WriteLine("Executing DerivedExecutorWithBadConstr");
}
}
class DerivedExecutorWithPrivateConstr : DerivedExecutor
{
private DerivedExecutorWithPrivateConstr() { }
}
class DerivedExecutorWithPublicBadConstr : DerivedExecutorWithBadConstr
{
public DerivedExecutorWithPublicBadConstr() : base() { }
}
class Executor2<T> where T : IExecutor
{
public void Execute()
{
var ex = (T)Activator.CreateInstance(typeof(T));
ex.Execute();
}
}
}