Пример #1
0
        private void TestContainer2 <T>(params T[] items)
        {
            var schema = new Scope();

            schema.Element <Container2 <T> >()
            .Elements()
            .Add(x => x.Items);

            var container = new Container2 <T>();

            foreach (var item in items)
            {
                container.Items.Add(item);
            }

            var serial = schema.ToString(container, _format);

            var container2 = schema.Parse <Container2 <T> >(serial, _format);

            Assert.AreEqual(container.Items.Count, container2.Items.Count);
            for (int i = 0; i < container.Items.Count; i++)
            {
                Assert.AreEqual(container.Items[i], container2.Items[i]);
            }
        }
Пример #2
0
            public void UniqueUserPerContainer()
            {
                Container1 = CreateContainer(Container1Handle);
                Container2 = CreateContainer(Container2Handle);

                var pSpec = new ProcessSpec
                {
                    ExecutablePath     = "whoami.exe",
                    DisablePathMapping = true,
                    Privileged         = false
                };

                var io1 = new StringProcessIO();
                var io2 = new StringProcessIO();

                Container1.Run(pSpec, io1).WaitForExit();
                Container2.Run(pSpec, io2).WaitForExit();

                var user1 = io1.Output.ToString();
                var user2 = io2.Output.ToString();

                Assert.NotEmpty(user1);
                Assert.NotEmpty(user2);
                Assert.NotEqual(user1, user2);
            }
Пример #3
0
        static void Main(string[] args)
        {
            IContainer<Shape> list = new Container<Shape>();

            Shape shape = new Circle();

            Shape[] mas = new Shape[2];
            mas[0] = new Circle();

            list = new Container<Circle>();

            IContainer2<Shape> list2 = new Container2<Circle>();

        }
Пример #4
0
 public override string ToString()
 {
     if (string.IsNullOrEmpty(Container.Trim()))
     {
         return(Name);
     }
     else if (string.IsNullOrEmpty(Container2.Trim()))
     {
         return(Container + "." + Name);
     }
     else
     {
         return(Container2 + "." + Container + "." + Name);
     }
 }
Пример #5
0
 protected override void OnStart()
 {
     base.OnStart();
     _resType = ResType.ControllerState;
     if (isOverride)
     {
         override_Container2 = new Container2();
         string   value  = DataManager.instance.GetDataByIDAndName("Tip_1000", "value");
         string[] list   = value.Split('/');
         Sprite   sprite = ResManager.instance.GetObject <Sprite>(list[0]);
         override_Container2.bg   = sprite;
         override_Container2.text = list[1];
         InitView();
     }
 }
    public static void Test()
    {
        var container1 = new Container1 {
            Name = "name", ProductId = 101, Common = new CommonFields {
                Id = "1401", Time = DateTime.Today.Ticks
            }
        };
        var container2 = new Container2 {
            Group = Guid.NewGuid(), Common = new CommonFields {
                Id = "2401", Time = DateTime.Today.Ticks
            }
        };

        Test(container1);
        Test(container2);
    }
Пример #7
0
        public void ForEachBench()
        {
            var   count = 10_000_000;
            var   arr   = new int[count];
            IList arrO  = arr;
            var   vecT  = new Vec <int>(arr);
            var   vec   = new Vec(arr);
            var   cont  = new Container(vec);
            var   cont2 = new Container2(cont);
            var   mem   = (Memory <int>)arr;
            var   list  = new List <int>(arr);

            for (int i = 0; i < count; i++)
            {
                vecT[i] = i;
                //if ((int)vec[i] != vecT[i])
                //{
                //    throw new Exception("(int)vec[i] != vecT[i]");
                //}
            }

            long sum    = 0;
            var  rounds = 10;
            var  mult   = 10;

            for (int r = 0; r < rounds; r++)
            {
                //using (Benchmark.Run("Array", count * mult))
                //{
                //    var z = count - 1;
                //    for (int m = 0; m < mult; m++)
                //    {
                //        for (int j = 1; j < z; j++)
                //        {
                //            sum += arr[j - 1];
                //        }
                //    }
                //}

                //using (Benchmark.Run("ArrayO", count * mult))
                //{
                //    var z = count - 1;
                //    for (int m = 0; m < mult; m++)
                //    {
                //        for (int j = 1; j < z; j++)
                //        {
                //            sum += (int)arrO[j - 1];
                //        }
                //    }
                //}

                //using (Benchmark.Run("ArrayNoBC", count * mult))
                //{
                //    var z = count - 1;
                //    for (int m = 0; m < mult; m++)
                //    {
                //        for (int j = 1; j < arr.Length; j++)
                //        {
                //            sum += arr[j] + 1;
                //        }
                //    }
                //}

                //using (Benchmark.Run("List", count * mult))
                //{
                //    var z = count - 1;
                //    for (int m = 0; m < mult; m++)
                //    {
                //        for (int j = 1; j < z; j++)
                //        {
                //            sum += list[j - 1];
                //        }
                //    }
                //}

                //using (Benchmark.Run("VecT", count * mult))
                //{
                //    for (int m = 0; m < mult; m++)
                //    {
                //        var z = count - 1;
                //        for (int j = 1; j < z; j++)
                //        {
                //            sum += vecT.Get(j - 1);
                //        }
                //    }
                //}

                //using (Benchmark.Run("Span", count * mult))
                //{
                //    for (int m = 0; m < mult; m++)
                //    {
                //        var z = count - 1;
                //        var sp = vecT.Span;
                //        for (int j = 1; j < z; j++)
                //        {
                //            sum += sp[j - 1];
                //        }
                //    }
                //}

                sum = VecGetT_Loop(count, mult, sum, vec);

                //using (Benchmark.Run("Vec", count * mult))
                //{
                //    for (int m = 0; m < mult; m++)
                //    {
                //        for (int j = 0; j < count; j++)
                //        {
                //            sum += (int)vec.DangerousGet(j);
                //        }
                //    }
                //}

                //using (Benchmark.Run("Memory<T>.Span", count * mult))
                //{
                //    for (int m = 0; m < mult; m++)
                //    {
                //        for (int j = 0; j < count; j++)
                //        {
                //            sum += (int)mem.Span[j];
                //        }
                //    }
                //}
            }

            Benchmark.Dump();
            Console.WriteLine(sum);
        }
Пример #8
0
 public Nested(Container2 parent)
 {
     _parent = parent;
 }
 public Nested(Container2 parent)
 {
     _parent = parent;
 }