** WARNING: Lengthy Post w/ Source Code**
Hopefully someone might find this useful. I wrote it primarily because I am lazy and I dont like trying to figure out which overloaded CompareValue method to use when creating a simple predicate.
I ended up with two classes that will be rolled into a template for a plugin that I am building, but the raw code is here.
The 2 classes are CompareValuePredicateBuilder and PredicateBuilderInfo. CompareValuePredicateBuilder returns instance an IPredicate using PredicateBuilderInfo. The CompareValuePredicateBuilder uses reflection to determine which overload of the PredicateFactory.CompareValue method to invoke based on the contents of PredicateBuilderInfo.
The primary reason I wrote the code as such is so that I could reduce the lines of code that need to be generated and to provide a very loose coupling when creating a predicate.
Here is a sample that shows how to use the 2 classes to fetch a collection with a RelationPredicateBucket that has predicate expressions build from my classes.
public void TestWith2Predicates()
{
try
{
LookupTableHelperClass helper = new LookupTableHelperClass();
IRelationPredicateBucket bucket = new RelationPredicateBucket();
PredicateBuilderInfo info = new PredicateBuilderInfo(
CompareValuePredicateBuilder.Aspnet_UsersInRolesEntityKey,
"UserId",
new System.Guid("8e121e39-1dbb-41e1-bbd0-e8a4c25c7f03"));
bucket.PredicateExpression.Add(CompareValuePredicateBuilder.GetPredicate(info));
info.FieldName = "RoleId";
info.FieldValue = new System.Guid("dde0195d-ef53-4a0a-8bdd-5134b6c757be");
bucket.PredicateExpression.AddWithOr(CompareValuePredicateBuilder.GetPredicate(info));
EntityCollection collection = helper.Aspnet_UsersInRolesLookup_WithRelation(
bucket);
foreach (Aspnet_UsersInRolesEntity entity in collection)
{
Console.WriteLine(entity.RoleId + ":" + entity.UserId );
}
}
catch (Exception ex)
{
Fail(ex);
}
}
The important method is the GetPredicate method, which uses the EntityName, FieldName, and FieldValue to get the predicate.
Here is the code if you just want to copy and paste it. I will be rolling it into a plugin very soon.
** Code for the classes**
/// <summary>
/// This class uses reflection an a PredicateBuilderInfo class to create
/// a compare value predicate. The predicate that is returned can
/// be used in a predicate expression
/// </summary>
public sealed class CompareValuePredicateBuilder
{
public const string Aspnet_UsersInRolesEntityKey = "Aspnet_UsersInRoles";
private CompareValuePredicateBuilder()
{
}
public static IPredicate GetPredicate(string entityName,
string entityFieldName, object fieldValue)
{
PredicateBuilderInfo builder = new PredicateBuilderInfo(entityName,
entityFieldName, fieldValue);
return GetPredicate(builder);
}
public static IPredicate GetPredicate(PredicateBuilderInfo builder)
{
object predicate = null;
Type factoryType = null;
string factoryName = "{0}.FactoryClasses.PredicateFactory";
Type[] methodArgs = null;
MethodInfo compareValueMethod = null;
object[] runtimeArgs = null;
AssemblyName[] referencedAssemblies = null;
factoryName = string.Format(factoryName, PredicateBuilderInfo.RootNamespace);
// check the current assembly for the predicate factory
Assembly currentAssembly = Assembly.GetExecutingAssembly();
factoryType = currentAssembly.GetType(factoryName, false,true);
// if the factoryType is still null after the first GetType then
// check the dependent assemblies
if (factoryType == null)
{
if (referencedAssemblies == null)
{
referencedAssemblies = currentAssembly.GetReferencedAssemblies();
}
// iterate through the referenced assemblies
foreach (AssemblyName name in referencedAssemblies)
{
Assembly tempAssembly = Assembly.Load(name);
currentAssembly = tempAssembly;
factoryType = tempAssembly.GetType(factoryName, false, true);
if (factoryType != null)
break;
}
}
if (factoryType != null)
{
string methodName = "CompareValue";
string entityName = builder.EntityName;
Type fieldType = builder.FieldValue.GetType();
// create an arry of types to use when searching for the method
methodArgs = MethodArguments(currentAssembly, builder);
// find the method with the proper overload
compareValueMethod = factoryType.GetMethod(methodName, methodArgs);
// create the values to use in the method invocation
runtimeArgs = RuntimeArguments(methodArgs[0],builder);
// invoke the method
predicate = compareValueMethod.Invoke(factoryType, runtimeArgs);
}
return predicate as IPredicate;
}
/// <summary>
/// Returns an array of types that will be used by the runtime when it is searching
/// for the proper CompareValue method to use
/// </summary>
/// <param name="dbGenericAssembly">The assembly containing the method</param>
/// <param name="builder">The object containing the data required to build the predicate</param>
/// <returns>An array of types</returns>
private static Type[] MethodArguments(Assembly dbGenericAssembly, PredicateBuilderInfo builder)
{
Type enumType = null;
string[] args = new string[]{PredicateBuilderInfo.RootNamespace, builder.EntityName};
string enumName = "{0}.{1}FieldIndex";
enumName = String.Format(enumName, args);
enumType = dbGenericAssembly.GetType(enumName,true,true);
return new Type[]{enumType,
typeof(ComparisonOperator), builder.FieldValue.GetType()};
}
/// <summary>
/// Returns an array of objects that will be used in the method invocation
/// </summary>
/// <param name="enumType">The entity field index</param>
/// <param name="builder">The object containing the data to use to build the arguments</param>
/// <returns>An array of objects</returns>
private static object[] RuntimeArguments(Type enumType, PredicateBuilderInfo builder)
{
object fieldIndex = Enum.Parse(enumType, builder.FieldName, true);
return new object[]{fieldIndex,
ComparisonOperator.Equal, builder.FieldValue};
}
}
/// <summary>
/// This class contains all information used by the generic predicate builder framework.
/// </summary>
public class PredicateBuilderInfo
{
public const string RootNamespace = "EDS.Plugins";
/// <summary>
/// Default ctor
/// </summary>
public PredicateBuilderInfo()
{
}
/// <summary>
/// Use this constructor to initialize this class with all of its
/// values populated
/// </summary>
/// <param name="rootNamespace">Root namespace of the database generic project</param>
/// <param name="entityName">Name of the entity to use in the predicate </param>
/// <param name="fieldName">Name of the field to query on</param>
/// <param name="fieldValue">Value to be used in the query</param>
public PredicateBuilderInfo(string entityName, string fieldName,
object fieldValue)
{
this.m_entityName = entityName;
this.m_fieldName = fieldName;
this.m_fieldValue = fieldValue;
}
private string m_entityName;
private string m_fieldName;
private object m_fieldValue;
/// <summary>
/// Gets / sets the value to use for the field in the predicate
/// </summary>
public object FieldValue
{
get
{
return m_fieldValue;
}
set
{
m_fieldValue = value;
}
}
/// <summary>
/// Gets / sets the name of the field to query on
/// </summary>
public string FieldName
{
get
{
return m_fieldName;
}
set
{
m_fieldName = value;
}
}
/// <summary>
/// Gets / sets the entity name to be used in the predicate expression
/// </summary>
public string EntityName
{
get
{
return m_entityName;
}
set
{
m_entityName = value;
}
}
}
