Dynamic declaration in attribute property

Question

As part of a microplataforma ORM I’m developing, I’m defining a generic class that implements exclusively tight Coupling (1 record x 1 object).

public class Course : MicroEntity<Course>
{
    public string fullname { get; set; }
    public string shortname { get; set; }
    public string summary { get; set; }
    public string format { get; set; }
    [...]
}

To define the behavior of this class, I have a Attribute which contains all boot characteristics:

[MicroEntity(
    TableName = "mdl_course",
    IdentifierColumnName = "ID",
    IsReadOnly = true,
    UseDistributedCaching = true)]
public class Course : MicroEntity<Course>
{
    public string fullname { get; set; }
    public string shortname { get; set; }
    public string summary { get; set; }
    public string format { get; set; }
    [...]
}

Recently I implemented a Databasedapter mechanism to allow agnostic connection to different databases:

public abstract class BaseAdapter
{
    internal abstract void CheckDatabaseEntities<T>() where T : MicroEntity<T>;
    internal abstract void SetSqlStatements<T>() where T : MicroEntity<T>;
    internal abstract void SetConnectionString<T>() where T : MicroEntity<T>;
    internal abstract void RenderSchemaMicroEntityNames<T>() where T : MicroEntity<T>;
    internal abstract BaseDynamicParameters Parameters<T>(object obj) where T : MicroEntity<T>;
    internal abstract DbConnection Connection(string connectionString);
}

From there, I declare Adapters for different banks. At the moment, I have adapters for Oracle and Mysql.

Question

I wish I could declare the adapter as a property of the Attribute:

[MicroEntity(
    TableName = "mdl_course",
    IdentifierColumnName = "ID",
    IsReadOnly = true,
    Adapter = new InternalAdapters.MySql.Adapter();
    UseDistributedCaching = true)]
public class Course : MicroEntity<Course>
{
    [...]

But the use of new() is not allowed. Which model would best suit this type of behavior?

Answer 1

I’ve seen this problem solved using a Type (I can’t remember now where, but I’m sure I’ve seen it more than once).

public class MicroEntityAttribute : Attribute
{
    public Type Adapter { get; set; }
}

[MicroEntity(Adapter = typeof(InternalAdapters.MySql.Adapter))]
public class SomeClass {}

The expression new Class() is not a constant, but typeof(Class) is - and therefore can be used to initialize an attribute.

The attribute interpreter should then initialize an Adapter instance using Activator, and making an exception if you don’t have a public constructor without parameters.

Answer 2

The problem is that attributes do not accept dynamic object initialization. There are two alternatives:

1. Mark attribute with adapter type

[MicroEntity(
    TableName = "mdl_course",
    IdentifierColumnName = "ID",
    IsReadOnly = true,
    Adapter = typeof(InternalAdapters.MySql.Adapter),
    UseDistributedCaching = true)]

2. Mark attribute with an enumeration

[MicroEntity(
    TableName = "mdl_course",
    IdentifierColumnName = "ID",
    IsReadOnly = true,
    Adapter = Adapter.MySql,
    UseDistributedCaching = true)]

I am in favor of the first, especially since you have virtually no limits to inject new adapters into the application when this is desired.

When reading the attribute, the initialization would be quite simple:

var course = new Course();
var atributoMicroEntity = course.GetType().GetAttribute<MicroEntityAttribute>();
if (atributoMicroEntity != null) 
{
    var adaptador = Activator.CreateInstance(atributoMicroEntity.Adapter);
}