Question

Is there a way to enforce that a type parameter passed to an attribute implement specific interface?

public interface IExpectedInterface
{
    void InterfaceMethod();
}

public class MyCustomAttribute : Attribute
{
    public MyCustomAttribute(Type classType)
    {
        this.ConfirmAssignedClassType();

        _classType = classType;
    }

    public void SomeMethod<T>() where T : IExpectedInterface, new()
    {
        //var expectedType = Activator.CreateInstance(this._classType) as IExpectedInterface;
        var expectedType = Activator.CreateInstance(typeof(T)) as IExpectedInterface;

        if (expectedType == null)
        {
            // Wrong type

            throw new ArgumentException(string.Format("Wrong type: {0} could not be created or converted to IActionAuthorization", _classType.ToString()));
        }

        // Do something with expectedType

        expectedType.InterfaceMethod();
    }

    private void ConfirmAssignedClassType()
    {
        if (!typeof(IExpectedInterface).IsAssignableFrom(_classType))
        {
            // Wrong type
            // Can we enforce it via language construct

            throw new ArgumentException(string.Format("Wrong type: {0} must implement IExpectedInterface", _classType.ToString()));
        }

        if (this._classType.GetConstructor(Type.EmptyTypes) == null)
        {
            // Wrong type
            // Can we enforce it via language construct

            throw new ArgumentException(string.Format("Wrong type: {0} must have parameter less constructor", _classType.ToString()));
        }
    }

    private Type _classType;
}

public class TestClass
{
    [MyCustom(typeof(TestClassImplementsExpectedInterface))]
    public void TestMethod1()
    {
    }

    [MyCustom(typeof(TestClassDoesntImplementExpectedInterface))]
    public void TestMethod2()
    {
    }
}

public class TestClassImplementsExpectedInterface : IExpectedInterface
{
    public void InterfaceMethod()
    {
        return;
    }
}

public class TestClassDoesntImplementExpectedInterface
{
}

Answer 1

Couldn’t this be done with generics? (Edited — cannot create a generic subclass of Attribute)

   public class MyAttribute: Attribute 
    {
        private Type _ClassType;
        public MyAttribute(Type classType)
        {
            _ClassType = classType;
        }
        public void SomeMethod<T>() where T: IMyInterface
        {
            var expectedType = Activator.CreateInstance(typeof(T)) as IMyInterface;
        // Do something with expectedType
        }
    }

And of course the other answer’s translation to use “new” makes a lot of sense!