static public void Main () 
   {
      I i = new MyClass();

      i.MyEvent += new MyDelegate(f);
      i.FireAway();
   }

    public bool PosTest2()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest2: The key to be remove is a custom class");

        try
        {
            IDictionary iDictionary = new Dictionary<object,object>();
            MyClass mc = new MyClass();
            int value = TestLibrary.Generator.GetInt32(-55);
            iDictionary.Add(mc, value);
            iDictionary.Remove(mc);
            if (iDictionary.Contains(mc))
            {
                TestLibrary.TestFramework.LogError("003", "The result is not the value as expected ");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
            retVal = false;
        }

        return retVal;
    }

		public void OrderByWithAttributeShouldStillWork()
		{
			using (var store = NewDocumentStore())
			{
				const int count = 1000;

				using (var session = store.OpenSession())
				{
					for (var i = 0; i < count; i++)
					{
						var model = new MyClass
						{
							ThisWontWork = i,
							ThisWillWork = i
						};
						session.Store(model);
					}
					session.SaveChanges();
				}

				using (var session = store.OpenSession())
				{
					var orderedWithoutAttribute = session.Query<MyClass>().OrderBy(x => x.ThisWillWork).Take(count).ToList();
					var orderedWithAttribute = session.Query<MyClass>().OrderByDescending(x => x.ThisWontWork).Take(count).ToList();

					Assert.Equal(count, orderedWithoutAttribute.Count);
					Assert.Equal(count, orderedWithAttribute.Count);

					for (var i = 1; i <= count; i++)
					{
						Assert.Equal(orderedWithoutAttribute[i - 1].ThisWontWork, orderedWithAttribute[count - i].ThisWontWork);
					}
				}
			}
		}

    public bool NegTest1()
    {
        bool retVal = true;

        int count;
        bool actualValue;
        bool expectedValue;

        count = 20;
        expectedValue = count >= c_CRITERIA;

        TestLibrary.TestFramework.BeginScenario("NegTest1: call the method Predicate.BeginInvoke asynchronously");
        try
        {
            MyClass myClass = new MyClass(count);
            Predicate<int> selector = myClass.IsGreatEnough;
            IAsyncResult asyncResult = selector.BeginInvoke(c_CRITERIA, null, null);
            actualValue = selector.EndInvoke(asyncResult);
            retVal = false;
            TestLibrary.TestFramework.LogError("003", "NotSupportedException expected");
        }
        catch (NotSupportedException)
        {
            //expected
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("002", "Unexpected exception:" + e);
            retVal = false;
        }
        return retVal;
    }

    public bool PosTest2()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest2: The generic type is type of string");

        try
        {
            string[] strArray = { "Hello", "wor", "l", "d" };
            List<string> listObject = new List<string>(strArray);
            MyClass myClass = new MyClass();
            Action<string> action = new Action<string>(myClass.joinstr);
            listObject.ForEach(action);
            if (myClass.result != "Helloworld")
            {
                TestLibrary.TestFramework.LogError("003", "The result is not the value as expected,sum is: " + myClass.sum);
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
            retVal = false;
        }

        return retVal;
    }

 //Main_3_4_1
 public static void Main()
 {
     MyStruct ms = new MyStruct();
     MyClass mc = new MyClass();
     Console.WriteLine("IL Keywords.");
     Console.Read();
 }

 static void Method1(int number, string text, MyClass myClass)
 {
     number = 10;
       text = "new string";
       myClass = new MyClass(true);
     //same
 }

    public bool PosTest2()
    {
        bool retVal = true;

        int count;
        bool actualValue;
        bool expectedValue;

        count = 99;
        expectedValue = count >= c_CRITERIA;

        TestLibrary.TestFramework.BeginScenario("PosTest2: call the method Predicate.EndInvoke synchronously");
        try
        {
            MyClass myClass = new MyClass(count);
            Predicate<int> selector = myClass.IsGreatEnough;
            actualValue = selector(c_CRITERIA);
            if (actualValue != expectedValue)
            {
                TestLibrary.TestFramework.LogError("003", "ExpectedValue(" + expectedValue + ") != ActualValue(" + actualValue + ")");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("004", "Unexpected exception:" + e);
            retVal = false;
        }
        return retVal;
    }

 public static int MainMethod(string[] args)
 {
     MyClass mc = new MyClass();
     dynamic d = mc.Prop;
     d(3); //We invoke the dynamic delegate
     return Test.s_status ? 0 : 1;
 }

	static void Main()
	{
		var inst1 = new MyClass();
		inst1.x = 10;
		ChangeMyClass(inst1);
		System.Console.WriteLine(inst1.x);

		var inst2 = new MyStruct();
		inst2.x = 10;
		ChangeMyStruct(ref inst2);
		System.Console.WriteLine(inst2.x);

		var inst3 = inst1;
		inst1.x = 5;
		System.Console.WriteLine(inst3.x);

		var inst4 = inst2;
		inst2.x = 5;
		System.Console.WriteLine(inst4.x);

		var inst5 = new MyClass();
		inst5.x = 5;
		System.Console.WriteLine(System.String.Format("inst3 and inst1 are {0}equal!", (inst3 == inst1) ? "" : "not "));
		System.Console.WriteLine(System.String.Format("inst5 and inst1 are {0}equal!", (inst5 == inst1) ? "" : "not "));

		var s1 = "Hello Trainer!";
		System.String s2 = s1;
		s1 = "Hello Trainees!";
		System.Console.WriteLine(s1);
		System.Console.WriteLine(s2);
		System.Console.WriteLine(System.String.Format("s1 and s2 are {0}equal!", (s1==s2) ? "" : "not "));

		var s3 = System.Console.ReadLine();
		System.Console.WriteLine(System.String.Format("s1 and s3 are {0}equal!", (s1==s3) ? "" : "not "));
	}

        static void Main(string[] args)
        {
            MyClass<string> cl = new MyClass<string>();

            cl.Add("Dan");
            cl.Add("Bob");
            cl.Add("Max");
            cl.Add("Nina");
            cl.Add("Marina");
            cl.Add("Nadya");
            cl.Add("Vanya");
            //cl.Add("Vova");
            //cl.Add("Vasya");

            foreach (string temp in cl)
                Console.WriteLine(temp);

            Console.WriteLine(cl.Count);
            Console.WriteLine();

            Console.WriteLine(cl[4]);
            Console.WriteLine();

            cl.Remove("Bob");
            foreach (string temp in cl)
                Console.WriteLine(temp);
            Console.WriteLine(cl.Count);
            Console.ReadLine();
        }

        public void test2()
        {
            int a = 2;
            int b = 2;

            int c, d, result;

            MyClass myClass1 = new MyClass();
            MyClass myClass2 = new MyClass();

            while ((a > 1) && (b > 1))
            {
                c = 3;
                d = 1;

                while (d < b)
                {
                    result = AddAll(myClass1, a, b, c, d, myClass2);

                    AssertEquals(8, result);

                    b = 0;
                }
            }
        }

        public void GetValue()
        {
            var mc = new MyClass
            {
                MyProperty = 100,
                Depth2 = new Depth2
                {
                    MyProperty = 1000,
                    Depth3 = new Depth3
                    {
                        MyProperty = 10000
                    }
                }
            };

            {
                Expression<Func<MyClass, int>> selector = x => x.MyProperty;
                var accessor = ReflectionAccessor.Create(selector.Body as MemberExpression);
                accessor.GetValue(mc).Is(100);
            }

            {
                Expression<Func<MyClass, int>> selector = x => x.Depth2.MyProperty;
                var accessor = ReflectionAccessor.Create(selector.Body as MemberExpression);
                accessor.GetValue(mc).Is(1000);
            }

            {
                Expression<Func<MyClass, int>> selector = x => x.Depth2.Depth3.MyProperty;
                var accessor = ReflectionAccessor.Create(selector.Body as MemberExpression);
                accessor.GetValue(mc).Is(10000);
            }
        }

 public static bool InitObj()
 {
     MyClass c = new MyClass();
     return c.x == c.y &&
            c.y == c.z &&
            c.z == 0;
 }

		static void Main(string[] args)
		{
			MyClass mc = new MyClass(); // Create an instance of the class.
			Type t = mc.GetType(); // Get the Type object from the instance.

			// IsDefined
			bool isDefined = // Check the Type for the attribute.
			t.IsDefined(typeof(ReviewCommentAttribute), false);
			if( isDefined )
			{
				Console.WriteLine("ReviewComment is applied to type {0}", t.Name);
			}
			
			// GetCustomAttributes
			object[] AttArr = t.GetCustomAttributes( false );
			foreach ( Attribute a in AttArr )
			{
				ReviewCommentAttribute attr = a as ReviewCommentAttribute;
				if ( null != attr )
				{
					Console.WriteLine( "Description : {0}", attr.Description );
					Console.WriteLine( "Version Number : {0}", attr.VersionNumber );
					Console.WriteLine( "Reviewer ID : {0}", attr.ReviewerID );
				}
			}
		}

      /// <summary>
      /// Итак у нас есть событие событие содержит ключевое слово event ТипДелегатаОбрабатывающегоСобытие НазваниеСобытия
      /// ДЕлегат это объект содержащий в себе ссылку на одну единственную функцию. Важный момент, что делегат и функция должны иметь
      /// одинаковую сигнатуру. 
      /// Мы создаем объект делегата, в конструктор передаем делегату функцию, которая соответсвует сигнатуре делегата. Затем мы берем событие
      /// и подписываем на него делегат.
      /// Событие отрабатывает -> зовутся все делегаты которые подписаны на событие -> зовутся все методы-обработчики.
      /// Не рекомендуется поджписывать событие на несколько обработчиков(делегатов) т.к в этом случае точный порядок вызовов обработчиков 
      /// не известен
      /// </summary>
      /// <param name="args"></param>
      static void Main(string[] args) {
         var objMyClass = new MyClass();

         for(int i = 0; i < 1; ++i) {
            objMyClass.CallEvent();
         }
      }

        static void Main(string[] args)
        {
            var s=new ConcretePorotype("id");
               var fIdd= ((Test1.ProtoType) s).Idd();//访问父类被隐藏的Idd方法
            var cIdd=s.Idd();//默认访问新类的Idd方法;
            var sClone = s.Clone();
            Console.WriteLine(fIdd);
            Console.WriteLine(cIdd);
            Console.WriteLine(sClone);
            Console.WriteLine("********************************");
            var a=new WorkExperice()
            {
                Name = "testName",
                StarTime = DateTime.Now,
                EndTime = DateTime.Now.AddDays(7)
            };

            var b = a.Clone();
            Console.WriteLine(b);

            var c=new MyClass();
            var d = c.Clone();
            Console.WriteLine(d);
            Console.ReadKey();
        }

 public static void Main()
 {
     var myInstance = new MyClass();
     var fieldInfo = typeof(MyClass).GetField("answer", BindingFlags.NonPublic | BindingFlags.Instance);
     var answer = fieldInfo.GetValue(myInstance);
     Console.WriteLine(answer);
 }

        static void Main(string[] args)
        {
            int i = 1;
              string s = "string";
              MyClass m = new MyClass(false);
              Method1(i, s, m);
              Console.WriteLine("i: {0}\ts: {1,-18}m: {2}", i, s, m.Changed);

              #region same for Method2
              i = 1;
              s = "string";
              m = new MyClass(false);
              Method2(i, s, m);
              Console.WriteLine("i: {0}\ts: {1,-18}m: {2}", i, s, m.Changed);
              #endregion

              #region same for Method1Ref
              i = 1;
              s = "string";
              m = new MyClass(false);
              Method1Ref(ref i, ref s, ref m);
              Console.WriteLine("i: {0}\ts: {1,-18}m: {2}", i, s, m.Changed);
              #endregion

              #region same for Method2Ref
              i = 1;
              s = "string";
              m = new MyClass(false);
              Method2Ref(ref i, ref s, ref m);
              Console.WriteLine("i: {0}\ts: {1,-18}m: {2}", i, s, m.Changed);
              #endregion

              Console.ReadLine();
        }

 static void Method2(int number, string text, MyClass myClass)
 {
     number += 10;
       text += " changed";
       myClass.Changed = true;
     //true
 }