c# - nBuilder 测试数据生成器和反射

Question

我正在使用 nBuilder 为我的应用程序生成一些测试数据。 首先，我对其进行了测试，它运行良好。 一个简单的例子:

Customer customer = Builder<Customer>
                   .CreateNew()
                   .Build();

创建一个对象并自动填充所有属性。 例如，如果客户包含属性:name，它将填充为name1 等等……

所有这一切都很好，但我现在很难动态地完成整个事情。

我现在正在做的是反射，我正在遍历我的类中的所有实体，并且应该为它们中的每一个生成一些测试数据，甚至应该填充查找和子列表，但这不是问题..我的问题是，我如何将以上 代码与any 类型一起使用？

ANYTYPE object = Builder<ANYTYPE> ...

我尝试过的:

object entity = null; //The object/Entity
Assembly assembly = Assembly.GetAssembly(typeof(EMI_ERPContext)); //Getting Assembly
Type type = assembly.GetType(entityName); //I know the Type
//entity = Activator.CreateInstance(type); Do I must create an Instance here?
object entity = Builder<dynamic> //The above code.. Tried to put dynamic as Type, but doesnt work
               .CreateNew()
               .Build();

Answer 1

我用一个控制台应用程序(在此处完成)进行了测试，伪造了 nBuilder 的类/接口(interface)/方法。

所以这可行，但没有在真实环境中尝试过。

您可以重用的方法是“TryToReflectBuilder”。它可能不那么冗长，但我使用“逐步”代码，因为它可能更明确。 ReflectionConsole.Test 用作“要反射(reflect)的实体”。

namespace ReflectionConsole {
    class Program {
        static void Main(string[] args)
        {

            object test = TryToReflectBuilder("ReflectionConsole.Test");
            Console.ReadKey();
        }

        public static object TryToReflectBuilder(string type)
        {
            //getting the assembly : not same as your way, but... that wasn't a problem for you
            var assembly = Assembly.GetAssembly(typeof(Test));

            //getting the entityType by name.
            var entityType = assembly.GetType(type);

            //The interesting (I hope) part is starting (yeah)
            //get the Builder<T> type
            var builderClassType = typeof(Builder<>);

            //create generic argument for Builder<T> will take the type of our entity (always an array)
            Type[] args = {entityType};

            //pass generic arguments to Builder<T>. Which becomes Builder<entityType>
            var genericBuilderType = builderClassType.MakeGenericType(args);

            //create a new instance of Builder<entityType>
            var builder = Activator.CreateInstance(genericBuilderType);

            //retrieve the "CreateNew" method, which belongs to Builder<T> class
            var createNewMethodInfo = builder.GetType().GetMethod("CreateNew");

            //invoke "CreateNew" from our builder instance which gives us an ObjectBuilder<T>, so now an ObjectBuilder<entityType> (well as an ISingleObjectBuilder<entityType>, but... who minds ;))
            var objectBuilder = createNewMethodInfo.Invoke(builder, null);

            //retrieve the "Build" method, which belongs to ObjectBuilder<T> class
            var buildMethodInfo = objectBuilder.GetType().GetMethod("Build");

            //finally, invoke "Build" from our ObjectBuilder<entityType> instance, which will give us... our entity !
            var result = buildMethodInfo.Invoke(objectBuilder, null);

            //it would be sad to return nothing after all these efforts, no ??
            return result;
        }
    }

    public  class Builder<T>
    {
        public static ISingleObjectBuilder<T> CreateNew()
        {
            Console.WriteLine(string.Format("{0} creating new",typeof(T)));
            return new ObjectBuilder<T>();
        } 
    }

    public interface ISingleObjectBuilder<T> : IBuildable<T>
    {
    }
    public interface IObjectBuilder<T> : ISingleObjectBuilder<T>
    {

    }
    public interface IBuildable<T>
    {
        T Build();
    }

    public class ObjectBuilder<T> : ISingleObjectBuilder<T>
    {
        public T Build()
        {
            Console.WriteLine(string.Format("{0} building myself", typeof(T)));
            return Activator.CreateInstance<T>();
        }
    }

    public class Test
    {
    }
}