C# MyObject类代码示例

 public void CreatingAnEventFromASimpleMethodWithoutArgumentsShouldReturnMethodEventForThatMethod()
 {
     var obj = new MyObject();
     var @event = MethodEventFactory.CreateMethodEventFromExpression(Guid.NewGuid(), () => obj.SimpleMethod());
     Assert.That(@event, Is.Not.Null);
     Assert.That(@event.Name,Is.EqualTo("SimpleMethod"));
 }

        public void TestKeepAliveMax()
        {
            WeakReference r;
            ObjectKeepAlive keep = new ObjectKeepAlive(25, 50, TimeSpan.FromSeconds(1));

            if(true)
            {
                object target = new MyObject();
                r = new WeakReference(target);
                keep.Add(target);
                target = null;
            }

            _destroyed = false;
            Assert.IsTrue(r.IsAlive);

            for (int i = 0; i < 49; i++)
                keep.Add(i);

            Assert.IsTrue(r.IsAlive);

            GC.GetTotalMemory(true);
            GC.WaitForPendingFinalizers();
            Assert.IsTrue(r.IsAlive);
            Assert.IsFalse(_destroyed);

            keep.Add(new object());
            keep.Add(new object());

            GC.GetTotalMemory(true);
            GC.WaitForPendingFinalizers();
            Assert.IsFalse(r.IsAlive);
            Assert.IsTrue(_destroyed);
        }

        static void CustomBasedCache()
        {
            MyObject obj1 = new MyObject();
            obj1.var1 = 1;
            obj1.var2 = 1;
            MyObject obj3 = new MyObject();
            obj3.var1 = 2;
            obj3.var2 = 1;
            MyObject obj2 = new MyObject();
            obj2.var1 = 5;
            obj2.var2 = 5;
            LFUCache<MyKey, MyObject> customCache = new LFUCache<MyKey, MyObject>();
            MyKey key = customCache.Add(obj1);
            MyKey key2 = customCache.Add(obj2);
            MyKey key3 = customCache.Add(obj3);

            //........

            //obj1.var1 + obj1.var2
            //OUTPUT: 2
            Console.WriteLine("" + (customCache[key].var1 + customCache[key].var2)); //The frequency count will go up 2, because we access it twice

            MyObject obj = customCache[key3];
            //obj3.var1 + obj3.var2
            //OUTPUT: 3
            Console.WriteLine("" + (obj.var1 + obj.var2)); //The frequency count will go up 1, because we only access it once

            obj = customCache.LeastFrequentlyUsedObject; //The least frequently used object will be obj2 because we haven't requested it yet.
            //obj2.var1 + obj2.var2
            //OUTPUT: 10
            Console.WriteLine("" + (obj.var1 + obj.var2)); //This will be obj2.var1 + obj2.var2
        }

        public void TestDestoryed()
        {
            Utils.WeakReference<MyObject> r;
            if (true)
            {
                MyObject obj = new MyObject();

                r = new Utils.WeakReference<MyObject>(obj);
                Assert.IsTrue(r.IsAlive);
                Assert.IsNotNull(r.Target);
                MyObject test;
                Assert.IsTrue(r.TryGetTarget(out test));
                Assert.IsTrue(ReferenceEquals(obj, test));
                test = null;
                _destroyed = false;

                GC.KeepAlive(obj);
                obj = null;
            }

            GC.GetTotalMemory(true);
            GC.WaitForPendingFinalizers();

            Assert.IsTrue(_destroyed);

            MyObject tmp;
            Assert.IsFalse(r.IsAlive);
            Assert.IsNull(r.Target);
            Assert.IsFalse(r.TryGetTarget(out tmp));
        }

        public new void Init(object objParam)
        {
            // Get parameter info
            _strPath = Path.Combine(@"TestFiles\", FilePathUtil.GetTestDataPath(), @"XsltApi\");

            xsltArg1 = new XsltArgumentList();

            MyObject obj1 = new MyObject(1, _output);
            MyObject obj2 = new MyObject(2, _output);
            MyObject obj3 = new MyObject(3, _output);
            MyObject obj4 = new MyObject(4, _output);
            MyObject obj5 = new MyObject(5, _output);

            xsltArg1.AddExtensionObject("urn:my-obj1", obj1);
            xsltArg1.AddExtensionObject("urn:my-obj2", obj2);
            xsltArg1.AddExtensionObject("urn:my-obj3", obj3);
            xsltArg1.AddExtensionObject("urn:my-obj4", obj4);
            xsltArg1.AddExtensionObject("urn:my-obj5", obj5);

            xsltArg1.AddParam("myArg1", szEmpty, "Test1");
            xsltArg1.AddParam("myArg2", szEmpty, "Test2");
            xsltArg1.AddParam("myArg3", szEmpty, "Test3");
            xsltArg1.AddParam("myArg4", szEmpty, "Test4");
            xsltArg1.AddParam("myArg5", szEmpty, "Test5");

            return;
        }

 public void CreatingAnEventFromASimpleMethodWithOneArgumentAndNotUsingConstantsShouldReturnMethodEventWithArgumentsForThatMethod(string expectedArgument)
 {
     var obj = new MyObject();
     var @event = MethodEventFactory.CreateMethodEventFromExpression(Guid.NewGuid(), () => obj.SimpleMethodWithOneArgument(expectedArgument));
     Assert.That(@event, Is.Not.Null);
     dynamic arguments = @event.Arguments;
     Assert.That(@event.Name, Is.EqualTo("SimpleMethodWithOneArgument"));
     Assert.That(arguments.argument, Is.EqualTo(expectedArgument));
 }

 public static void Main(string[] args)
 {
     MyObject[] array = new MyObject[2];
       array[0] = new MyObject (5, 8);
       array[1] = new MyObject (12, 3);
       using (FileStream fs = new FileStream("test.xml", FileMode.Create)) {
            XmlSerializer serializer = new XmlSerializer(array.GetType());
            serializer.Serialize(Console.Out, array);
       }
 }

        public MyObject NewObject(int Width, int Height)
        {
            MyObject obj = new MyObject();
            obj.Width = Width;
            obj.Height = Height;

            setСoordinates(obj);

            return obj;
        }

 public void B002TestMethod1()
 {
     var s = new XSerializer(typeof(MyObject));
     var obj = new MyObject();
     obj.List.AddRange(new[] { 10, 20, 30 });
     var doc = s.GetSerializedDocument(obj);
     Trace.WriteLine(doc);
     var obj1 = (MyObject)s.Deserialize(doc, null);
     Assert.AreEqual(obj1.List.Count, obj.List.Count);
 }

 public void Method()
 {
     using (MyObject my = new MyObject())
     {
         my.DoSomething();
         string msg = "hello";
         msg += " My name";
         msg += " is Alex";
         Console.WriteLine(msg);
     }
 }

		public void ObjectSerializationTakesConvertersIntoAccount()
		{
			var o = new MyObject() { MyEnum = MyEnum.Foo, Nested = new NestedObject() };
			var serializedObject = _serializationClient.Serializer.Serialize(o).Utf8String();
			serializedObject.JsonEquals(@"
				{
					""myEnum"" : ""Foo"",
					""nested"" : ""something""
				}").Should().BeTrue();

		}

        public void CreatingAnEventFromASimpleMethodWithTwoArgumentsShouldReturnMethodEventWithArgumentsForThatMethod()
        {
            var obj = new MyObject();
            var expectedFirstArgument = "Something";
            var expectedSecondArgument = 42;
            var @event = MethodEventFactory.CreateMethodEventFromExpression(Guid.NewGuid(), () => obj.SimpleMethodWithTwoArguments(expectedFirstArgument, expectedSecondArgument));
            Assert.That(@event, Is.Not.Null);
            Assert.That(@event.Name, Is.EqualTo("SimpleMethodWithTwoArguments"));
            dynamic arguments = @event.Arguments;

            Assert.That(arguments.firstArgument, Is.EqualTo(expectedFirstArgument));
            Assert.That(arguments.secondArgument, Is.EqualTo(expectedSecondArgument));
        }

        public void CloneByJson_creates_new_object_with_same_values()
        {
            var nest = new MyNestedObject() { MyDateTimeProp = DateTime.Now, MyDoubleProp = 5.3 };

            var obj = new MyObject() { MyIntProp = 5, MyStringProp = "Shnogerdob", MyNestedObjectProp = nest };
            var objClone = obj.CloneByJson();

            Assert.False(obj == objClone, "References should be different");
            Assert.AreEqual(obj.MyIntProp, objClone.MyIntProp);
            Assert.AreEqual(obj.MyStringProp, objClone.MyStringProp);
            Assert.AreEqual(obj.MyNestedObjectProp.MyDateTimeProp, objClone.MyNestedObjectProp.MyDateTimeProp);
            Assert.AreEqual(obj.MyNestedObjectProp.MyDoubleProp, obj.MyNestedObjectProp.MyDoubleProp);
        }

 public static void Main()
 {
     MyObject obj1 = new MyObject(),obj2 = new MyObject(),obj3=obj1;
     obj1.x =
     obj2.x = 10;
     ModifyByRef(ref obj1);
     ModifyByVal(obj2);
     if(obj1!=null) System.Console.WriteLine(obj1.x);
     else System.Console.WriteLine("obj1 is null");
     if(obj2!=null) System.Console.WriteLine(obj2.x);
     else System.Console.WriteLine("obj2 is null");
     if(obj3!=null) System.Console.WriteLine(obj3.x);
     else System.Console.WriteLine("obj3 is null");
 }

        public void Test_Cache_Clear_All()
        {
            var cache = Container.Resolve<IEntityCache>();

            var msr = new ManualResetEvent(false);

            Task.Run(async () =>
            {

                var item1 = new MyObject { ItemName = "Item1" };
                var item2 = new MyObject { ItemName = "Item2" };

                var item1a = new MyOtherObject { ItemName = "Item1" };
                var item2a = new MyOtherObject { ItemName = "Item2" };


                await cache.SetEntity(item1.ItemName, item1);
                await cache.SetEntity(item2.ItemName, item2);
                await cache.SetEntity(item1a.ItemName, item1a);
                await cache.SetEntity(item2a.ItemName, item2a);

                var result1 = await cache.GetEntity<MyObject>(item1.ItemName);
                var result2 = await cache.GetEntity<MyObject>(item2.ItemName);
                var result3 = await cache.GetEntity<MyOtherObject>(item1a.ItemName);
                var result4 = await cache.GetEntity<MyOtherObject>(item2a.ItemName);

                Assert.IsNotNull(result1);
                Assert.IsNotNull(result2);
                Assert.IsNotNull(result3);
                Assert.IsNotNull(result4);

                await cache.Clear();

                var result1_e = await cache.GetEntity<MyObject>(item1.ItemName);
                var result2_e = await cache.GetEntity<MyObject>(item2.ItemName);
                var result3_e = await cache.GetEntity<MyOtherObject>(item1a.ItemName);
                var result4_e = await cache.GetEntity<MyOtherObject>(item2a.ItemName);

                Assert.IsNull(result1_e);
                Assert.IsNull(result2_e);
                Assert.IsNull(result3_e);
                Assert.IsNull(result4_e);


                msr.Set();
            });

            var msrResult = msr.WaitOne(20000);
            Assert.IsTrue(msrResult, "MSR not set, means assertion failed in task");
        }