C# System.Collections.Generic.GetType方法代码示例

        public void Should_render_include_with_same_model()
        {
            var model = new { Name = "Joe" };
            RegisterTemplate("person", SyntaxTree.Block(
                SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name"))
            ));
            var template = SyntaxTree.Block(
                SyntaxTree.WriteString("Hello "),
                SyntaxTree.Include("person", SyntaxTreeExpression.Self(model.GetType()))
            );

            var result = ExecuteTemplate(template, model);
            Assert.That(result, Is.EqualTo("Hello Joe"));
        }

        public void Should_map_an_anonymous_object_to_the_settings()
        {
            var converterCache = new DynamicObjectConverterCache(new DynamicImplementationBuilder());
            var cache = new DictionaryConverterCache();

            var source = new
                {
                    Host = "localhost",
                    VirtualHost = "vortex",
                    Username = "joe",
                    Password = "guess",
                    Port = 5672,
                };

            IDictionaryConverter converter = cache.GetConverter(source.GetType());
            IDictionary<string, object> dictionary = converter.GetDictionary(source);

            IObjectConverter objectConverter = converterCache.GetConverter(typeof(RabbitMqSettings));

            var settings = (RabbitMqSettings)objectConverter.GetObject(dictionary);

            Assert.IsNotNull(settings);

            Assert.AreEqual("localhost", settings.Host);
            Assert.AreEqual("vortex", settings.VirtualHost);
            Assert.AreEqual("joe", settings.Username);
            Assert.AreEqual("guess", settings.Password);
            Assert.AreEqual(5672, settings.Port);
            Assert.AreEqual(0, settings.Heartbeat);

            Assert.IsNull(settings.Options);
        }

        public void Should_render_include_with_same_sub_model()
        {
            var model = new { Name = "Joe", Company = new { Name = "Foo" } };
            RegisterTemplate("company", SyntaxTree.Block(
                SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.Company.GetType(), "Name"))
            ));
            RegisterTemplate("person", SyntaxTree.Block(
                SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name"))
            ));
            var template = SyntaxTree.Block(
                SyntaxTree.WriteString("Welcome from "),
                SyntaxTree.Include("company", SyntaxTreeExpression.Property(model.GetType(), "Company")),
                SyntaxTree.WriteString(" the amazing "),
                SyntaxTree.Include("person", SyntaxTreeExpression.Self(model.GetType())),
                SyntaxTree.WriteString(".")
            );

            var result = ExecuteTemplate(template, model);
            Assert.That(result, Is.EqualTo("Welcome from Foo the amazing Joe."));
        }

 public void Should_use_items_from_collection_as_scope()
 {
     var model = new { Items = new[] { new ItemModel { Name = "John" }, new ItemModel { Name = "Kim" } } };
     var template = SyntaxTree.Block(SyntaxTree.Iterate(
         SyntaxTreeExpression.Property(model.GetType(), "Items"),
         SyntaxTree.Block(
             SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(typeof(ItemModel), "Name"))
         )
     ));
     var result = ExecuteTemplate(template, model);
     Assert.That(result, Is.EqualTo("JohnKim"));
 }

        public void Should_throw_if_unable_to_load_template()
        {
            var model = new { Name = "Joe" };
            var template = SyntaxTree.Block(
                SyntaxTree.WriteString("Hello "),
                SyntaxTree.Include("person", SyntaxTreeExpression.Self(model.GetType()))
            );

            Assert.Throws<VeilCompilerException>(() =>
            {
                ExecuteTemplate(template, model);
            });
        }

        public void Should_be_able_to_output_value_types_from_collections()
        {
            var model = new { Items = new[] { "1", "2", "3", "4" } };
            var template = SyntaxTree.Block(SyntaxTree.Iterate(
                SyntaxTreeExpression.Property(model.GetType(), "Items"),
                SyntaxTree.Block(
                    SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string)))
                )
            ));

            var result = ExecuteTemplate(template, model);
            Assert.That(result, Is.EqualTo("1234"));
        }

        public void SholdKnowIfATypeIsAListOfResources()
        {
            var list = new List<IBehaveAsResource>();
            var array = new[] {new SomeResource()};

            var notAResourceList = new List<int>();
            var notAResourceArray = new[] {1, 2};

            Assert.IsTrue(list.GetType().IsAListOfResources());
            Assert.IsTrue(array.GetType().IsAListOfResources());

            Assert.IsFalse(notAResourceList.GetType().IsAListOfResources());
            Assert.IsFalse(notAResourceArray.GetType().IsAListOfResources());
        }

        public void Should_be_able_to_iterate_an_array()
        {
            var model = new { Items = new[] { "1", "2" } };
            var template = SyntaxTree.Block(SyntaxTree.Iterate(
                SyntaxTreeExpression.Property(model.GetType(), "Items"),
                SyntaxTree.Block(
                    SyntaxTree.WriteString("Item")
                ),
                SyntaxTree.Block(
                    SyntaxTree.WriteString("Empty")
                )
            ));

            var result = ExecuteTemplate(template, model);
            Assert.That(result, Is.EqualTo("ItemItem"));
        }

        public void Root_model_of_template_should_be_the_model_executed_against()
        {
            var model = new { Name = "Joe", Company = new { Name = "Foo", Departments = new[] { "IT", "Admin" } } };
            RegisterTemplate("company", SyntaxTree.Block(
                SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.Company.GetType(), "Name")),
                SyntaxTree.WriteString(" - "),
                SyntaxTree.Iterate(SyntaxTreeExpression.Property(model.Company.GetType(), "Departments"), SyntaxTree.Block(
                    SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.Company.GetType(), "Name", ExpressionScope.RootModel))
                ))
            ));
            var template = SyntaxTree.Block(
                SyntaxTree.Include("company", SyntaxTreeExpression.Property(model.GetType(), "Company"))
            );

            var result = ExecuteTemplate(template, model);
            Assert.That(result, Is.EqualTo("Foo - FooFoo"));
        }

        public void Does_encode_unicode()
        {
            string test = "<\"I get this : 􏰁􏰂􏰃􏰄􏰂􏰅􏰆􏰇􏰈􏰀􏰉􏰊􏰇􏰋􏰆􏰌􏰀􏰆􏰊􏰀􏰍􏰄􏰎􏰆􏰏􏰐􏰑􏰑􏰆􏰒􏰆􏰂􏰊􏰀";
            var obj = new { test };
            using (var mem = new System.IO.MemoryStream())
            {
                ServiceStack.Text.JsonSerializer.SerializeToStream(obj, obj.GetType(), mem);

                var encoded = System.Text.Encoding.UTF8.GetString(mem.ToArray());

                var copy1 = JsonObject.Parse(encoded);

                Assert.That(test, Is.EqualTo(copy1["test"]));

                System.Diagnostics.Debug.WriteLine(copy1["test"]);
            }
        }

        public void Should_be_able_to_extend_a_template()
        {
            var model = new { Name = "Bob" };
            RegisterTemplate("master", SyntaxTree.Block(
                SyntaxTree.WriteString("<html><head>"),
                SyntaxTree.Override("head"),
                SyntaxTree.WriteString("</head></html>")
            ));
            var template = SyntaxTree.Extend("master", new Dictionary<string, SyntaxTreeNode> {
                {
                    "head",
                    SyntaxTree.Block(
                        SyntaxTree.WriteString("<title>"),
                        SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name")),
                        SyntaxTree.WriteString("</title>")
                    )
                }
            });
            var result = ExecuteTemplate(template, model);

            Assert.That(result, Is.EqualTo("<html><head><title>Bob</title></head></html>"));
        }

 public void AnonObjectIsNotSimpleType()
 {
     var dummyObject = new { id = 1, Name = "fred" };
     Assert.That(reader.IsSimpleType(dummyObject.GetType()), Is.False);
 }

        public void Should_render_empty_block_no_items_in_collection()
        {
            var model = new { Items = new List<string> { } };
            var template = SyntaxTree.Block(SyntaxTree.Iterate(
                SyntaxTreeExpression.Property(model.GetType(), "Items"),
                SyntaxTree.Block(
                    SyntaxTree.WriteString("Item")
                ),
                SyntaxTree.Block(
                    SyntaxTree.WriteString("Empty")
                )
            ));

            var result = ExecuteTemplate(template, model);
            Assert.That(result, Is.EqualTo("Empty"));
        }

 public IList<dynamic> GetFlowAuths(decimal flowId)
 {
     using (var ctx = new OAContext())
     {
         var x = new
         {
             flow_id = 1m,
             auth_to = 1m,
             auth_to_name = ""
         };
         var t = x.GetType();
         var re = ctx.SqlDynamic(string.Format(@"
     select fa.*,nvl(o.org_name,'') || nvl(d.dept_name,'') || nvl(r.role_name,'') as auth_name from t_flow_auth fa left join t_org o on fa.auth_to = o.org_id
     left join t_dept d on fa.auth_to = d.dept_id
     left join t_role r on fa.auth_to = r.role_id
     where fa.flow_id={0}", flowId));
         return re;
     }
 }