Question

I need to create some custom attributes, to be used for my reflection functions.

Here is the usecase, as I see it:

• the user creates some class and marks it with my special attribute ([ImportantAttribute] for example)
• then the user does something with functions from my library. Those functions find classes with [ImportantAttribute] and do something with them

The main problem is that functions in my library expects, that classes wich was marked with [ImportantAttribute] inherit my interface (IMyInterface for example)

Is there any way to let user know if he mark his class with [ImportantAttribute] and forget to inherit IMyInterface during compilation, not in run time. Some way to specify that this attribute is only for classes that inherit IMyInterface.

Same with attributes for properties and fields.

Answer 1

I’ve used the strategy you mention in a couple of the frameworks I’ve built with good success. One such example is for providing metadata to a plug-in infrastructure:

[AttributeUsage(AttributeTargets.Class, AllowMultiple=false, Inherited=false)]
public class PluginAttribute : Attribute
{
    public string DisplayName { get; set; }
    public string Description { get; set; }
    public string Version { get; set; }
}

public interface IPlug
{
    void Run(IWork work);
}

[Plugin(DisplayName="Sample Plugin", Description="Some Sample Plugin")]
public class SamplePlug : IPlug
{
    public void Run(IWork work) { ... }
}

Doing so allows me to figure out information about plug-ins without having to instantiate them and read metadata properties.

In my experience in doing so, the only way I’ve found to enforce that both requirements are met is to perform runtime checks and make sure it is bold and <blink>blinking</blink> in the documentation. It is far from optimal but it is the best that can be done (that I’ve found). Then again I’m sure there is a better way to go about handling this but so far this has been pretty solid for me.