Default BuildObject implementation using reflection #24

Activity

1. robdmoore

   added

   up-for-grabs

   on Apr 19, 2015
2. Bringer128 commented on May 1, 2015

   

   Bringer128

   on May 1, 2015

   Contributor

   More actions

   I've implemented this as an extension method. There's a bit of ninja backflipping to get the data out of the builder when running outside of the builder but that's easily fixed when implementing this for realsies.

   public static class TestDataBuilderExtensions
   {
       public static TObject BuildObjectByConstructor<TObject, TBuilder>(this TestDataBuilder<TObject, TBuilder> builder)
           where TObject : class
           where TBuilder : TestDataBuilder<TObject, TBuilder>, new()
       {
           var longestConstructor = typeof (TObject)
               .GetConstructors()
               .OrderByDescending(x => x.GetParameters().Length)
               .FirstOrDefault();
   
           if(longestConstructor == null) throw new ObjectCreationException();
   
           // TODO Validation around Parameters.All(x => typeof(TObject).HasProperty(...))
           var parameterValues = longestConstructor
               .GetParameters()
               .Select(x => new { PropertyName = x.Name.ToUpperCamelCase(), PropertyType = x.ParameterType })
               .Select(x => GetValueStoredInBuilder(builder, x.PropertyType, x.PropertyName));
   
           return (TObject) longestConstructor.Invoke(parameterValues.ToArray());
       }
   
       public static string ToUpperCamelCase(this string param)
       {
           if(string.IsNullOrWhiteSpace(param)) throw new ArgumentNullException("param");
   
           var builder = new StringBuilder(param);
           builder[0] = char.ToUpperInvariant(builder[0]);
   
           return builder.ToString();
       }
   
       public static bool HasProperty(this Type type, string propertyName, Type propertyType)
       {
           var propertyInfo = type.GetProperty(propertyName);
   
           if (propertyInfo == null) return false;
   
           return propertyInfo.PropertyType == propertyType;
       }
   
       private static object GetValueStoredInBuilder<TObject, TBuilder>(TestDataBuilder<TObject, TBuilder> builder, Type propertyType,
           string propertyName) where TObject : class where TBuilder : TestDataBuilder<TObject, TBuilder>, new()
       {
           // Make a Func<TObj, TPropertyType>
           var expressionDelegateType = typeof (Func<,>).MakeGenericType(typeof (TObject), propertyType);
   
           // Make an expression parameter of type TObj
           var tObjParameterType = Expression.Parameter(typeof (TObject));
   
           var valueStoredInBuilder = typeof (TBuilder)
               .GetMethod("Get")
               .MakeGenericMethod(propertyType)
               .Invoke(builder, new object[]
               {
                   Expression.Lambda(
                       expressionDelegateType,
                       Expression.Property(tObjParameterType, propertyName),
                       tObjParameterType)
               });
   
           return valueStoredInBuilder;
       }
   }

   There are obvious shortcomings to this approach:

   1. Constructor argument names must match Property Names exactly, bar the lower-upper camel casing.
   2. There must be a 1-1 relationship to constructor args - properties.

   Perhaps this feature could be opt-in by making it a protected method rather than a default?
3. robdmoore commented on May 1, 2015

   

   robdmoore

   on May 1, 2015

   MemberAuthor

   More actions

   Hi Ryan :)

   Nice one!

   My thinking was if we couldn't find a matching value via Get that we would then use the anonymous value stuff :) and in fact, the Get method does this for us automatically anyway.

   Case sensitivity might actually be an issue because we store the values in a dictionary, we might need to make a chance to make it case insensitive by lowercasing the key when it gets popped in and when it gets checked.
4. Bringer128 commented on May 1, 2015

   

   Bringer128

   on May 1, 2015

   Contributor

   More actions

   To avoid having to implement GetValueStoredInBuilder I think you'll need a private overload of Get that takes a String anyway, so the current version could proxy to the overload and the overload could handle the case sensitivity.

   FYI I'm not using this personally, I just had a similar implementation to populate a DTO via setters and figured I should create a basic version while it was still in my head. :)
5. Bringer128 commented on May 1, 2015

   

   Bringer128

   on May 1, 2015

   Contributor

   More actions

   I ended up using my reflective method to call Get<TValue> as I didn't want to pollute the entire generics stack with untyped stuff just for this one use case. We would need to change the whole chain of AnonymouseValueFixture.Get<TObject, T>, IAnonymousValueSupplier.CanSupplyValue and IAnonymousValueSupplier.GenerateAnonymousValue.

   I'm not convinced this is a good solution, so perhaps this was a decent exercise in proving it is "too much effort" for the amount of value.