public static object LoadCollection(string serverConnectionString, string dbName, string collectionName)
        {
            object      result      = null;
            MongoClient client      = new MongoClient(serverConnectionString);
            MongoServer mongoserver = client.GetServer();
            var         DyType      = new { Name = "", Id = 0 };
            //result = mongoserver.GetDatabase(dbName).GetCollection(collectionName).AsQueryable().ToList();
            var filter     = FilterDefinition <BsonDocument> .Empty;
            var collection = client.GetDatabase(dbName).GetCollection <BsonDocument>(collectionName);
            var Names      = collection.Find(_ => true).ToList().Select(x => x.Names).FirstOrDefault().ToList();
            var ty         = MyTypeBuilder.CompileResultType(Names);

            result = client.GetDatabase(dbName).GetCollection <object>(collectionName).Find(_ => true).ToList();
            var json = new JavaScriptSerializer().Serialize(result);

            File.WriteAllText("D:/jso.json", json);


            try
            {
            }
            catch
            {
            }
            return(result);
        }
Exemple #2
0
    static void Main(string[] args)
    {
        // Init List of method that I want to create
        var methods = new List <Method>();

        methods.Add(new Method()
        {
            Name   = "Add",
            Params = new List <MethodParam>()
            {
                new MethodParam()
                {
                    Name = "a",
                    Type = typeof(int)
                },
                new MethodParam()
                {
                    Name = "b",
                    Type = typeof(int)
                }
            },
            ReturnType = typeof(int)
        });
        // Compile my type
        var myType = MyTypeBuilder.CompileResultType(methods);
        // Create instance of my type
        var myObject = Activator.CreateInstance(myType) as IFooContract;
        // Call Function
        var result = myObject.Add(5, 2);

        // Log
        Console.WriteLine(result);
        Console.Read();
    }
        public async Task <IResult> Confirm(AddMoneyDto addMoneyDto)      //dto üzerinden onaylama
        {
            string adres  = "https://api.genelpara.com/embed/doviz.json"; //json formatında döviz kurunun çekileceği link
            var    myType = MyTypeBuilder.CompileResultType(new List <Field>()
            {
                new Field {
                    FieldName = addMoneyDto.CurrencyType, FieldType = typeof(Money)
                }
            });                                                     //json formatından nesneye dönüştürmek için nesne tipi üretiliyor
            var data = await WebApiHelper.GetMethod(adres, myType); //apiden veriler çekiliyor

            Money money  = data.GetType().GetProperty(addMoneyDto.CurrencyType).GetValue(data) as Money;
            var   result = _addMoneyDal.Get(a => a.Id == addMoneyDto.AddMoneyId);//id üzerinden bilgiler çekiliyor

            if (result.Status)
            {
                return(new ErrorResult());
            }
            result.Status = true;                            //durum onaylandı yapılıyor
            _addMoneyDal.Update(result);
            var dovizKuru = money == null ? "1":money.Satis; //null ise döviz kuru 1 kabul ediliyor

            dovizKuru = dovizKuru.Replace('.', ',');
            decimal doviz = decimal.Parse(dovizKuru);

            doviz = doviz != (decimal)1.0 ? doviz : doviz;
            _walletService.AddMoney(new Wallet {
                Amount = addMoneyDto.Amount * doviz, UserId = result.UserId
            });
            return(new SuccessResult("onaylandı"));
        }
        public void CreateRuntimeClassInstanceTest()
        {
            var dic = new Dictionary <string, Type> {
                { "Id", typeof(int) }
            };
            var ins = MyTypeBuilder.CreateNewObject(dic);

            Assert.True(ins.GetType().GetTypeInfo().GetProperty("Id") != null);
        }
Exemple #5
0
        public void ExceptionScanTest()
        {
            // generate a dynamic assembly.
            /* Purpose: dynamic assemblies do not support runtime type discovery and may break unit test framework exception*/
            var tester = MyTypeBuilder.CreateNewObject();
            // inject a type from the fuzzing assembly to check for some degenerative case
            /* Purpose: type in root namespace have a namespace property set as null that may be the source of NRE.*/
            var temp = new NoNameSpaceType();

            Check.That(ExceptionHelper.BuildException("Test")).IsInstanceOf <XunitException>();
            Check.That(2).IsEqualTo(2);
            Check.ThatCode(() => Check.That(2).IsEqualTo(0)).IsAFailingCheck();
        }
Exemple #6
0
        public void MakeDynamicType_PassInParameterInfo_AttachesAttributesToWrapperParameter()
        {
            // assemble
            var k         = new MyTestKernel();
            var attrTypes = new List <Type> {
                typeof(DulcetTonesAttribute)
            };
            Type funcType  = typeof(Func <int, Actor>);
            var  paramInfo = typeof(DummyClass).GetConstructors().First().GetParameters().First(); // has "Thespian" attr on it

            // act
            Type dynamicType    = MyTypeBuilder.MakeDynamicType(funcType, attrTypes, paramInfo);
            var  ctorParamAttrs = dynamicType.GetConstructors().First().GetParameters().First().GetCustomAttribute <ThespianAttribute>();

            // assert
            Assert.IsNotNull(ctorParamAttrs);
        }
        private object CreateDataObject(IDictionary <string, Object> propData, out Type type)
        {
            #region Another trying
            //var fields = propData
            //   .Select(p => p.Key)
            //   .ToList();

            //var properties = propData
            //.Select(p => new DynamicProperty(p.Key, typeof(object)))
            //.ToList();

            //var resultType = DynamicClassFactory.CreateType(properties, false);

            //var definition = Activator.CreateInstance(resultType);
            #endregion

            var fieldList = new List <dynamic>();

            foreach (var item in propData)
            {
                fieldList.Add(new { FieldName = item.Key, FieldType = item.Value != null ? item.Value.GetType() : typeof(object) });
            }

            var newObject = MyTypeBuilder.CreateNewObject(fieldList, out Type newType);

            foreach (var item in propData)
            {
                var value = propData[item.Key];

                if (value?.GetType().Name == "ExpandoObject")
                {
                    var newJson        = JsonConvert.SerializeObject(value);
                    var newJsonExpando = JsonConvert.DeserializeObject <ExpandoObject>(newJson) as IDictionary <string, Object>;

                    var newChildObj = CreateDataObject(newJsonExpando, out Type subType);
                    newObject.GetType().GetProperty(item.Key).SetValue(newObject, newChildObj);
                }
                else
                {
                    newObject.GetType().GetProperty(item.Key).SetValue(newObject, value);
                }
            }
            type = newType;
            return(newObject);
        }
        private static void ByReflection(int total)
        {
            var fields = new Dictionary <string, Type>();

            fields.Add("Id", typeof(int));
            fields.Add("Nome", typeof(string));
            var clientType = MyTypeBuilder.GetType("Client", fields);

            var listaCliente = new List <object>(total);

            for (int i = 0; i < total; i++)
            {
                var client = MyTypeBuilder.CreateNewObject(clientType);
                MyTypeBuilder.SetProperty(client, "Id", i);
                MyTypeBuilder.SetProperty(client, "Nome", $"Nome {i}");
                listaCliente.Add(client);
            }

            ShowMemoryUsage("reflection");
        }
Exemple #9
0
        public void MakeDynamicType_PassInAttrTypes_AttachesToClass()
        {
            // assemble
            var k         = new MyTestKernel();
            var attrTypes = new List <Type> {
                typeof(DulcetTonesAttribute)
            };
            Type funcType       = typeof(Func <int, Actor>);
            var  dummyParamInfo = typeof(DummyClass).GetConstructors().First().GetParameters().First();

            // act
            Type dynamicType = MyTypeBuilder.MakeDynamicType(funcType, attrTypes, dummyParamInfo);

            k.Bind(dynamicType).ToSelf();
            var wrapperInstance = k.Get(dynamicType);
            var funcInstance    = FuncValueGetter.GetFuncValue(wrapperInstance, dynamicType);

            MethodInfo mi     = funcType.GetMethod(nameof(Func <int> .Invoke));
            object     result = mi.Invoke(funcInstance, new object[] { 2 });

            // assert
            Assert.IsInstanceOf(typeof(Actor), result);
        }
Exemple #10
0
        public static void Main(string[] args)
        {
            // read the metadata from the table
            // foreach row in the metadata table
            // Create a class  using dynamic class.


            List <IDynamicClassFields> dynamicClassFields = new List <IDynamicClassFields>()
            {
                new DynamicClassFields()
                {
                    FieldName = "Id", FieldType = typeof(Int32)
                },
                new DynamicClassFields()
                {
                    FieldName = "Name", FieldType = typeof(string)
                }
            };


            var DemoClass = MyTypeBuilder.CreateNewObject(dynamicClassFields, "Demo");

            object value = "sharuk";

            MyTypeBuilder.SetValue(DemoClass, "Name", value);

            CodeFirstDynamicModelEF codeFirstDynamicModelEF = new CodeFirstDynamicModelEF();
            var configuration = new Configuration();
            var migrator      = new DbMigrator(configuration);

            migrator.Update();
            codeFirstDynamicModelEF.MyEntities.Add(new MyEntity());
            codeFirstDynamicModelEF.Set(DemoClass.GetType()).Add(DemoClass);


            codeFirstDynamicModelEF.SaveChanges();
        }
Exemple #11
0
        private CodeTypeDeclaration GenerateClass()
        {
            if (!context.ContainsKey(schema))
            {
                context.Add(schema, new GenerationResult()
                {
                    TypeName       = targetClass.Name,
                    Type           = MyTypeBuilder.CreateType(targetClass.Name),
                    ClassGenerator = this
                });
            }

            if (schema.Enum?.Count > 0)
            {
                return(GenerateClassFromEnumSchema());
            }

            if (schema.Type?.Value is SimpleType && (schema.Type.Value as SimpleType).Value != SimpleType.Object)
            {
                var schemaType = schema.Type.Value as SimpleType;
                if (schemaType.Value == SimpleType.Integer)
                {
                    return(GenerateClassFromIntegerSchema());
                }

                if (schemaType.Value == SimpleType.Number)
                {
                    return(GenerateClassFromNumberSchema());
                }

                if (schemaType.Value == SimpleType.String)
                {
                    return(GenerateClassFromStringSchema());
                }

                if (schemaType.Value == SimpleType.Array)
                {
                    return(GenerateClassFromArraySchema());
                }
            }
            var definitions = schema.Definitions;

            if (definitions != null)
            {
                foreach (string definitionName in schema.Definitions.Keys)
                {
                    var definition = definitions[definitionName];
                    if (!context.ContainsKey(definition))
                    {
                        var nestedClassGenerator = new ClassGeneratorFromJsonSchema(definition, context);
                        context[definition] = new GenerationResult()
                        {
                            Type           = MyTypeBuilder.CreateType(nestedClassGenerator.targetClass.Name),
                            TypeName       = nestedClassGenerator.targetClass.Name,
                            ClassGenerator = nestedClassGenerator
                        };
                        nestedClassGenerator.GenerateClass();
                    }
                    //context.Add(definition, new GenerationResult() { TypeName = nestedClassGenerator.targetClass.Name });
                }
            }

            var properties           = schema.Properties;
            var additionalProperties = schema.AdditionalProperties;

            //Oneof/AnyOf/AllOf are only supported when there are no properties or additionalProperties and when the schema type is not a primitive type or array type
            if (properties == null && additionalProperties == null)
            {
                if (schema.OneOf != null && schema.OneOf.Count > 0)
                {
                    return(GenerateClassFromOneOfAnyOfSchema(true));
                }

                if (schema.AnyOf != null && schema.AnyOf.Count > 0)
                {
                    return(GenerateClassFromOneOfAnyOfSchema(false));
                }

                if (schema.AllOf != null && schema.AllOf.Count > 0)
                {
                    var mergedSchema         = JSONSchema.MergeSchemas(schema.AllOf);
                    var mergedClassGenerator = new ClassGeneratorFromJsonSchema(mergedSchema, this.targetClass.Name);
                    targetClass     = mergedClassGenerator.GenerateClass();
                    context[schema] = mergedClassGenerator.context[mergedSchema];
                    foreach (var jsonSchema in mergedClassGenerator.context.Keys)
                    {
                        if (jsonSchema != mergedSchema)
                        {
                            context[jsonSchema] = mergedClassGenerator.context[jsonSchema];
                        }
                    }
                    return(targetClass);
                }
            }

            if (properties != null)
            {
                foreach (string propertyName in properties.Keys)
                {
                    var cleanPropertyName = Clean(propertyName);
                    if (propertyNames.Contains(cleanPropertyName))
                    {
                        //to avoid property names that would collide
                        continue;
                    }
                    propertyNames.Add(cleanPropertyName);
                    var property = properties[propertyName];

                    if (context.ContainsKey(property))
                    {
                        targetClass.AddProperty(cleanPropertyName, context[property].TypeName);
                    }
                    else if (property.Type?.GetUnderlyingType() == typeof(SimpleType) &&
                             (property.Type.Value as SimpleType).Value != SimpleType.Object &&
                             (property.Type.Value as SimpleType).Value != SimpleType.Array &&
                             (property.Enum == null || property.Enum.Count < 1)
                             )
                    {
                        targetClass.AddProperty(cleanPropertyName, ComputeType((SimpleType)property.Type.GetValue()));
                    }
                    else
                    {
                        var nestedClassGenerator = new ClassGeneratorFromJsonSchema(property, context, cleanPropertyName);
                        context[property] = new GenerationResult()
                        {
                            Type           = MyTypeBuilder.CreateType(nestedClassGenerator.targetClass.Name),
                            TypeName       = nestedClassGenerator.targetClass.Name,
                            ClassGenerator = nestedClassGenerator
                        };
                        nestedClassGenerator.GenerateClass();
                        targetClass.AddProperty(cleanPropertyName, context[property].Type);
                    }
                }
            }


            if (additionalProperties != null)
            {
                if (additionalProperties.Value is bool)
                {
                    if ((bool)additionalProperties.Value == true)
                    {
                        targetClass.BaseTypes.Add(new CodeTypeReference(typeof(Dictionary <string, object>)));
                    }
                }
                else
                {
                    var additionalPropertiesSchema = additionalProperties.Value as JSONSchema;
                    if (!context.ContainsKey(additionalPropertiesSchema))
                    {
                        var nestedClassGenerator = new ClassGeneratorFromJsonSchema(additionalPropertiesSchema, context, context[schema].TypeName + "AdditionalProperties");
                        context[additionalPropertiesSchema] = new GenerationResult()
                        {
                            Type           = MyTypeBuilder.CreateType(nestedClassGenerator.targetClass.Name),
                            TypeName       = nestedClassGenerator.targetClass.Name,
                            ClassGenerator = nestedClassGenerator
                        };
                        nestedClassGenerator.GenerateClass();
                    }
                    targetClass.BaseTypes.Add(new CodeTypeReference("Dictionary", new CodeTypeReference(typeof(string)), new CodeTypeReference(context[additionalPropertiesSchema].Type)));
                    context[schema].Imports.Add("System.Collections.Generic");
                }
            }



            return(targetClass);
        }
Exemple #12
0
        private CodeTypeDeclaration GenerateClassFromOneOfAnyOfSchema(bool handleOneOf)
        {
            ISet <string> subSchemasSet = new HashSet <string>();
            int           index         = 0;
            var           schemaArray   = handleOneOf ? schema.OneOf : schema.AnyOf;

            foreach (JSONSchema subSchema in schemaArray)
            {
                if (context.ContainsKey(subSchema))
                {
                    subSchemasSet.Add(context[subSchema].TypeName);
                }
                else if (subSchema.Type?.GetUnderlyingType() == typeof(SimpleType) &&
                         (subSchema.Type.Value as SimpleType).Value != SimpleType.Object &&
                         (subSchema.Type.Value as SimpleType).Value != SimpleType.Array
                         )
                {
                    subSchemasSet.Add(ComputeType((SimpleType)subSchema.Type.GetValue()).Name);
                }
                else
                {
                    var nestedClassGenerator = new ClassGeneratorFromJsonSchema(subSchema, context, string.Concat(targetClass.Name, handleOneOf?"OneOf":"AnyOf", index));
                    context[subSchema] = new GenerationResult()
                    {
                        Type           = MyTypeBuilder.CreateType(nestedClassGenerator.targetClass.Name),
                        TypeName       = nestedClassGenerator.targetClass.Name,
                        ClassGenerator = nestedClassGenerator
                    };
                    nestedClassGenerator.GenerateClass();
                    subSchemasSet.Add(nestedClassGenerator.targetClass.Name);
                }
                index++;
            }


            targetClass = new CodeTypeDeclaration(targetClass.Name)
            {
                IsClass        = true,
                TypeAttributes = TypeAttributes.Public
            };

            var field = new CodeMemberField()
            {
                Attributes = MemberAttributes.Private | MemberAttributes.Final,
                Name       = "Value",
                Type       = new CodeTypeReference(typeof(object))
            };

            targetClass.Members.Add(field);

            CodeConstructor constructor = new CodeConstructor
            {
                Attributes = MemberAttributes.Private
            };

            constructor.Comments.Add(new CodeCommentStatement("Hiding visiblity of default constructor"));
            targetClass.Members.Add(constructor);

            CodeStatement[] codeStatements = new CodeStatement[subSchemasSet.Count + 1];
            index = 0;
            foreach (string subSchemaName in subSchemasSet)
            {
                codeStatements[index] = If(NewSnippet("value is " + subSchemaName), new CodeAssignStatement(new CodeVariableReferenceExpression("Value"), new CodeVariableReferenceExpression("value")));
                index++;
            }
            codeStatements[index] = Throw(typeof(ArgumentException), "Value's type is not correct");

            CodeConstructor publicConstructor = NewPublicConstructor(
                Array(NewParameter(typeof(object), "value")),
                codeStatements
                );

            targetClass.Members.Add(publicConstructor);

            foreach (string subSchemaName in subSchemasSet)
            {
                var implicitOperator = new CodeSnippetTypeMember(string.Format("\t\tpublic static implicit operator {0}({1} d) => ({0})d.Value;", subSchemaName, targetClass.Name));
                targetClass.Members.Add(implicitOperator);

                var explicitOperator = new CodeSnippetTypeMember(string.Format("\t\tpublic static explicit operator {0}({1} v) => new {0}(v);", targetClass.Name, subSchemaName));
                targetClass.Members.Add(explicitOperator);
            }

            return(targetClass);
        }