class1.cs

java基础方面的一些实例代码

using System;

namespace mcaoConsoleAppException
{
	/// <summary>
	/// Class1 的摘要说明。
	/// </summary>
	class Class1
	{
		//抛出异常
		public void MyThrowExceptionTest()
		{
			Console.WriteLine("Please input a string, and if you input mcao, I will throw an exception, though it is not an exception.");
			string strTemp = Console.ReadLine();
			if (strTemp.Equals("mcao") == true)
				throw (new ArgumentNullException());
			Console.WriteLine(strTemp);
		}

		//处理异常
		public void MyThrowExceptionDealtTest()
		{
			try 
			{
				MyThrowExceptionTest();
			}			
			catch (ArgumentNullException ae)
			{
				Console.WriteLine(ae.ToString()+"  ::" +ae.Message);
			}
			catch (Exception ee) 
			{
				Console.WriteLine(ee.ToString()+"  ::" +ee.Message);
			}
			finally 
			{
				Console.WriteLine("Though you throw a System.ArgumentNullException, I am still mcao!");
			}
		}

		//两个整数相除，输入时除数可能为0，用户输入1和0分别表示处理/不处理异常
		public void CatchDivideZeroException()
		{
			int x, y, z,b;
			string StrTemp;
			Console.WriteLine("Now we complete x divided by y, y may be 0");
			Console.WriteLine("Please input b, b is 1 means with exception sealt, and 0 means without exception dealt!");
			StrTemp = Console.ReadLine();
			b = int.Parse(StrTemp);Console.WriteLine("Please input x,y,respectively, one number in a line:");
			
	
			if (b == 0) 
			{
				StrTemp = Console.ReadLine();
				x = int.Parse(StrTemp);
				StrTemp = Console.ReadLine();
				y = int.Parse(StrTemp);
				z = x/y;
			}
			else 
			{
				try 
				{
					StrTemp = Console.ReadLine();
					x = int.Parse(StrTemp);
					StrTemp = Console.ReadLine();
					y = int.Parse(StrTemp);
					z = x / y;
				}
				catch (DivideByZeroException de)  //除数为0的异常
				{
					Console.WriteLine(de.ToString());
				}
				catch (FormatException fe)
				{
					Console.WriteLine(fe.ToString()); //输入整数格式不对的异常
				}
			}
		}

		//测试异常嵌套以及Exception的属性
		public void MyThrowExceptionLayer1()
		{
			MyThrowExceptionLayer2();
		}
		public void MyThrowExceptionLayer2()
		{
			MyThrowExceptionLayer3();
		}
		public void MyThrowExceptionLayer3()
		{
			try 
			{
				MyThrowExceptionTest();
			}
			catch (ArgumentNullException ae)
			{
				Console.WriteLine(ae.ToString()+"  ::" +ae.Message);
				throw new  Exception();
			}
		}
		public void MyThrowExceptionLayerTest()
		{
			try
			{
				MyThrowExceptionLayer1();
			}
			catch (Exception ge)
			{
				Console.WriteLine("异常类型：" + ge.ToString());
				Console.WriteLine("异常message：" + ge.Message);
				Console.WriteLine("异常StackTrace：" + ge.StackTrace);
				Console.WriteLine("异常InnerException：" + ge.InnerException);
				Console.WriteLine("异常TargetSite：" + ge.TargetSite);
				Console.WriteLine("异常Source：" + ge.Source);
				Console.WriteLine("异常HelpLink：" + ge.HelpLink);
			}
		}


		//为了测试将指针作为函数形参，所以定义该函数
		static int value = 20;
		unsafe static void F(out int* pi1, ref int* pi2) 
		{
			int i = 10;
			pi1 = &i;
			fixed (int* pj = &value) 
			{
				// ...
				pi2 = pj;
			}
		}

		public void PointRefTest()
		{
			int i = 10;
			unsafe 
			{
				int* px1;
				int* px2 = &i;
				F(out px1, ref px2);
				Console.WriteLine("*px1 = {0}, *px2 = {1}",
					*px1, *px2);   // undefined behavior
			}

		}

		//方法可以返回某一类型的值，而该类型可以是指针。例如：
		//给定一个指向连续的int值序列的指针、该序列的元素个数，和另外一个int值 (value)，
		//下面的方法将在该整数序列中查找与该 value 匹配的值，若找到匹配项，则返回该匹配
		//项的地址；否则，它将返回 null：同时可以测试fixed语句的使用方法
		unsafe static int* Find(int* pi, int size, int value) 
		{
			for (int i = 0; i < size; ++i) 
			{
				if (*pi == value) 
					return pi;
				++pi;
			}
			return null;
		}

		//测试指针算法
		public void MyStackallocTest()
		{
			unsafe 
			{
				int* values = stackalloc int[20];
				int* p = &values[1];
				int* q = &values[15];
				Console.WriteLine("p - q = {0}", p - q);
				Console.WriteLine("q - p = {0}", q - p);
			}

		}

		//指针成员访问
		//先定义结构，然后访问
		struct Point
		{
			public int x;
			public int y;
			public override string ToString() 
			{
				return "(" + x + "," + y + ")";
			}
		}

		//visit
		public void PointNumberVisited()
		{
			Point point;
			unsafe 
			{
				Point* p = &point;
				p->x = 10;
				p->y = 20;
				Console.WriteLine("First visited format " + p->ToString());

				(*p).x = 10;
				(*p).y = 20;
				Console.WriteLine("Second visited format" + (*p).ToString());

			}
		}

		//指针元素访问
		public void PointComponentVisited()
		{
			int i;
			unsafe 
			{
				char* p = stackalloc char[256];
				for (i = 0; i < 256; i++) p[i] = (char)i;
				//由于 P[E] 操作与 *(P + E) 完全等效，此示例可以等效地写为：
				for (i = 0; i < 256; i++) *(p + i) = (char)i;
				//指针元素访问运算符不能检验是否发生访问越界错误，
				//而且当访问超出边界的元素时行为是未定义的。这与 C 和 C++ 相同。
			}
		}

		//测试指针结果，和C++比较
		public void MyTestPointResult()
		{
			int i;
			unsafe 
			{
				int* p = &i;
				*p = 123;
			}
			Console.WriteLine(i);

		}

		//测试fixed语句，以string类型为例
		static string name = "xx";
		unsafe static void MyFixedTestSalve(char* p) 
		{
			for (int i = 0; p[i] != '\0'; ++i)
				Console.WriteLine(p[i]);
		}

		public void MyFixedTestClient()
		{
			unsafe 
			{
				fixed (char* p = name) MyFixedTestSalve(p);
				fixed (char* p = "xx") MyFixedTestSalve(p);
			}
		}

		public void MyFixedIntTestClient()
		{
			int[,,] a = new int[2,3,4];
			unsafe 
			{
				fixed (int* p = a) 
				{
					for (int i = 0; i < a.Length; ++i)   // treat as linear
						p[i] = i;
				}
			}
			for (int i = 0; i < 2; ++i)
				for (int j = 0; j < 3; ++j) 
				{
					for (int k = 0; k < 4; ++k)
						Console.Write("[{0},{1},{2}] = {3,2} ", i, j, k, a[i,j,k]);
					Console.WriteLine();
				}
		}

		//使用一条 fixed 语句固定一个数组，以便可以将该数组的地址传递给//
		//一个采用指针作为参数的方法。
		unsafe static void Fill(int* p, int count, int value) 
		{
			for (; count != 0; count--) *p++ = value;
		}

		public void MyFixedArrayTestClient( )
		{
			int[] a = new int[100];
			unsafe 
			{
				fixed (int* p = a) Fill(p, 100, -1);
			}
		}

		//测试指针类型隐式/显式转换
		public void MyPointExchangeTest()
		{
			double d = 123.456e23;
			int j;
			unsafe
			{
				char c = 'A';
				char* pc = &c;
				void* pv = pc;
				int* pi = (int*)pv;
				int i = *pi;      // undefined
				*pi = 123456;      // undefined

				byte* pb = (byte*)&d;
				for (j = 0; j < sizeof(double); ++j)
					Console.Write("{0:X2} ", *pb++);
				Console.WriteLine();
			}
		}

		//堆栈分配例子
		public string MyHeapStackAllocTest(int value)
		{
			int n = value >= 0? value: -value;
			unsafe 
			{
				char* buffer = stackalloc char[16];
				char* p = buffer + 16;
				do 
				{
					*--p = (char)(n % 10 + '0');
					n /= 10;
				} while (n != 0);
				if (value < 0) *--p = '-';
				return new string(p, 0, (int)(buffer + 16 - p));
			}
		}
		
				
		/// <summary>
		/// 应用程序的主入口点。
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			//
			// TODO: 在此处添加代码以启动应用程序
			//
			Class1 obj = new Class1();
			//obj.MyThrowExceptionDealtTest();
			obj.MyThrowExceptionLayerTest();
			
			//obj.CatchDivideZeroException();

			/* obj.PointRefTest();
			obj.MyStackallocTest();
			obj.PointNumberVisited();
			obj.MyTestPointResult();
			//fixed 语句的用法
			int[] a = new int[10] {1,4,10, 20, 40, 5, 20, 65, 45, 20};
			unsafe 
			{
				fixed (int* p = a) 
				{
					Find(p, 10, 20);
					Console.WriteLine(*p);
				}
				
			}
			obj.MyFixedTestClient();
			obj.MyFixedIntTestClient();
			obj.MyFixedArrayTestClient();
			obj.MyPointExchangeTest();
			Console.WriteLine(obj.MyHeapStackAllocTest(12345));
			Console.WriteLine(obj.MyHeapStackAllocTest(-999)); */	

		}
	}
}