Re: [Mono-list] Fun and games with Sqlite and System.Reflection

[Robert Jordan]

How about checking whether the IgnoreAttribute is applied to
the property?
for (int i = 0; i < properties.Length - 1; i++) {
        // ignore props marked with [Ignore]
	if (properties[i].GetCustomAttributes(typeof(IgnoreAttribute), 
false).Length > 0)
                next;
}

Robert


On 09.04.2014 14:38, Paul Johnson wrote:
Hi,

I have a very simple SQLite database class which I'm using
System.Reflection to serialise and use within my DBManager class.

My class looks like this (it's a test case to try and get things working
before I integrate it)

public class dbclass
{
     [PrimaryKey]
     public string Id { get; set; }

     public string Test { get; set; }

     public DateTime Today { get; set; }

     [Ignore]
     public List<string> ListTest { get; set; }

     public override string ToString()
     {
         return string.Format("[dbclass: Id={0}, Test={1},
ListTest={2}]", Id, Test, ListTest);
     }
}
When I serialise this class, the Ignore attribute used for Sqlite is
ignored as it's not a System.Reflection attribute. Without it, the
List<T> tries to be processed and causes the code to crash as it has
nothing in the database for it (and Lists are supported under SQlite
anyway!)

I've checked on MSDN and there doesn't seem to be an equivalent of the
Ignore attribute which is a bit of a pain.

Within my dbclass, is it possible to set the reflection attribute to
something so I can intercept and ignore the property I need to ignore
(in this case the List)?

My code that does the processing looks like this (no giggling at the back!)

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq.Expressions;
using System.Text;
using SQLite;

public class dbclass
     {
         [PrimaryKey]
         public string Id { get; set; }

         public string Test { get; set; }

         public DateTime Today { get; set; }

         [Ignore]
         public List<string> ListTest { get; set; }

         public override string ToString()
         {
             return string.Format("[dbclass: Id={0}, Test={1},
ListTest={2}]", Id, Test, ListTest);
         }
     }

     class TestClass
     {
         public TestClass()
         {
             var db = new dbclass()
             {
                 Id = Guid.NewGuid().ToString(),
                 Test = "Hello",
                 Today = DateTime.Now
             };
             Console.WriteLine("{0}", GetInsertQuery(db));
         }

         private readonly Dictionary<Type, Func<Object, String>>
queryBuilders = new Dictionary<Type, Func<object, string>>();

         public string GetInsertQuery(Object entity)
         {
             var type = entity.GetType();
             if (!queryBuilders.ContainsKey(type))
             {
                 var param = Expression.Parameter(typeof(Object),
"entity");
                 var typedObject = Expression.Variable(type, "obj");
                 var stringBuilder =
Expression.Variable(typeof(StringBuilder), "sb");

                 var appendString =
typeof(StringBuilder).GetMethod("Append", new[] { typeof(String) });
                 var objectToString = typeof(Object).GetMethod("ToString");

                 var code = new List<Expression>();
                 code.Add(Expression.Assign(typedObject,
Expression.Convert(param, type)));
                 code.Add(Expression.Assign(stringBuilder,
Expression.New(typeof(StringBuilder))));

                 code.Add(Expression.Call(stringBuilder, appendString,
Expression.Constant(string.Format("INSERT INTO {0} (", type.Name))));

                 var properties = type.GetProperties();

                 for (int i = 0; i < properties.Length - 1; i++)
                 {
                     code.Add(Expression.Call(stringBuilder,
appendString, Expression.Constant(properties[i].Name)));
                     code.Add(Expression.Call(stringBuilder,
appendString, Expression.Constant(", ")));
                 }

                 code.Add(Expression.Call(stringBuilder, appendString,
Expression.Constant(properties[properties.Length - 1].Name)));

                 code.Add(Expression.Call(stringBuilder, appendString,
Expression.Constant(") VALUES (")));

                 for (int i = 0; i < properties.Length - 1; i++)
                 {
                     code.Add(Expression.Call(stringBuilder,
appendString, Expression.Constant("'")));
                     code.Add(Expression.Call(stringBuilder,
appendString, Expression.Call(Expression.Property(typedObject,
properties[i]), objectToString)));
                     code.Add(Expression.Call(stringBuilder,
appendString, Expression.Constant("', ")));
                 }

                 code.Add(Expression.Call(stringBuilder, appendString,
Expression.Constant("'")));
                 code.Add(Expression.Call(stringBuilder, appendString,
Expression.Call(Expression.Property(typedObject,
properties[properties.Length - 1]), objectToString)));
                 code.Add(Expression.Call(stringBuilder, appendString,
Expression.Constant("', ")));

                 code.Add(Expression.Call(stringBuilder, appendString,
Expression.Constant(");")));


                 code.Add(Expression.Call(stringBuilder, "ToString", new
Type[] { }));

                 var expression = Expression.Lambda<Func<Object,
String>>(Expression.Block(new[] { typedObject, stringBuilder }, code),
param);
                 queryBuilders[type] = expression.Compile();
             }

             string f = queryBuilders[type](entity);
             return f;
         }

Dies if you add a List<T> into the class being passed in

TIA

Paul


_______________________________________________
Mono-list maillist  -  Mono-list@lists.ximian.com
http://lists.ximian.com/mailman/listinfo/mono-list