Example #1
0
        public object Create(Type type)
        {
            if (generationStack.Contains(type))
            {
                return(null);
            }
            if (type.IsAbstract || type.IsInterface || type == typeof(void))
            {
                return(null);
            }
            IGenerator value;

            Generators.TryGetValue(type, out value);
            if (value != null)
            {
                return(value.Generate());
            }
            if (type.IsGenericType)
            {
                return(listGenerator.Generate((Type)type.GenericTypeArguments.GetValue(0)));
            }
            if (!type.IsAbstract || !type.IsPrimitive)
            {
                generationStack.Push(type);
                ConstructorInfo ConstructorWithMaxArgs = GetConstructorWithMaxParams(type);
                if (ConstructorWithMaxArgs != null)
                {
                    var instance = GenerateObjectFromConstructor(ConstructorWithMaxArgs);
                    instance = GenerateFieldsAndProperties(type, instance);
                    generationStack.Pop();
                    return(instance);
                }
                else
                {
                    if (type.GetConstructors().Count() != 0)
                    {
                        var instance = Activator.CreateInstance(type);
                        instance = GenerateFieldsAndProperties(type, instance);
                        generationStack.Pop();
                        return(instance);
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
            return(null);
        }
Example #2
0
        private object GenerateValue(Type type)
        {
            object          generatedObject;
            IValueGenerator baseTypeGenerator;

            if (baseTypesGenerators.TryGetValue(type, out baseTypeGenerator))
            {
                generatedObject = baseTypeGenerator.Generate();
            }
            else if (type.IsGenericType)  // list
            {
                generatedObject = listGenerator.Generate(type.GenericTypeArguments[0]);
            }
            else if (type.IsClass && !type.IsGenericType && !type.IsArray && !type.IsPointer && !type.IsAbstract && !generatedTypes.Contains(type))
            {
                generatedTypes.Add(type);

                generatedObject = Create(type);

                generatedTypes.RemoveAt(generatedTypes.Count - 1);
            }
            else if (type.IsValueType)
            {
                generatedObject = Activator.CreateInstance(type);
            }
            else
            {
                generatedObject = null;
            }

            return(generatedObject);
        }