But wait… Didn’t we made a .dbml which generated a couple of classes for the tables in our database? The information we need should be in one of the files that is generated by the .dbml. When you search through the .cs file for your classes and fields, you will see that the properties that are linked to your databse contain a ColumnAttribute. See this code snippet:

[Column(Storage="_id", AutoSync=AutoSync.OnInsert, DbType="Int NOT NULL IDENTITY", IsPrimaryKey=true, IsDbGenerated=true)]
public int id
{ …

[Column(Name="name", Storage="_name", DbType="VarChar(150) NOT NULL", CanBeNull=false)]
public string name
{ …

Here you see that de database field type is specified in the DbType attribute field. So that is wat we want to know in our code. We just have to find an easy way for getting this information. For this I created a Reflection Utility class. Here is the code:

public static class ReflectionUtility
{
    public static string GetPropertyName<T>(Expression<Func<T>>  expression)
    {
        return ((MemberExpression)expression.Body).Member.Name;
    }
    public static ColumnAttribute GetColumnAttribute<T>(Expression<Func<T>> expression)
    {
        string propertyName = ((MemberExpression)expression.Body).Member.Name;
        Type type = ((MemberExpression)expression.Body).Member.ReflectedType;
        PropertyInfo memberInfo = type.GetProperty(propertyName, BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
        object[] attributes = memberInfo.GetCustomAttributes(typeof(ColumnAttribute), false);
        foreach (var attribute in attributes)
        {
            var columnAttribute = attribute as ColumnAttribute;
            if (columnAttribute != null) return columnAttribute;
        }
        return null;
    }
    public static string GetDbType<T>(Expression<Func<T>> expression)
    {
        ColumnAttribute attribute = GetColumnAttribute(expression);
        return (attribute != null) ? attribute.DbType : null;
    }
}

As you can see getting the information can easilly be done with some simple reflection. I even made sure you could query both public and non public properties (internal). After you added the ReflectionUtility class to your solution you can get the DbType of a property or just the name of a property with one simple line of code. Her is a sample of how you can use it:

string fieldName = ReflectionUtility.GetPropertyName(() => (new user()).id);
string dbType = ReflectionUtility.GetDbType(() => (new user()).name);

As you can see you only need one simple line of code for getting the database type information from a property. I am not even using ‘magic strings’ for doing the reflection. I just pass the property itself to the method. The bennefit of this is that after a refactoring (changing the name of a property) you don’t even have to try to find all the property name string and replace them by the new name.

There is one drawback for getting the field type information this way. It is possible to enter something in your .dbml that is different from the actual field type in the database. For instance you could set the size smaller than the actual field size.

Conclusion:

This was a fun exersize. If you think that the DbType information in your .dbml is good, then using this utility class is a very easy way to get the type information. There are a couple of things that could be done for improving this code. For instance you could parse the field type string into an object or you could make a validator method that wil check if the current value is not longer that the field length.

Related posts

• July 4, 2010 -- Extension methods: Not always a good thing. (0)
• January 26, 2010 -- Converting a generic list to one of its interfaces or base class (0)