using System;
namespace HelloWorldApplication
{
    /* 类名为 HelloWorld */
    class HelloWorld
    {
        /* main 函数 */
        static void Main(string[] args)
        {
            /* 我的第一个 C# 程序 */
            Console.WriteLine("Hello World!");
            Console.ReadKey();
        }
    }
}

using System;  // using 关键字用于在程序中包含 System 命名空间。
namespace HelloWorldApplication  // 一个 namespace 里包含了一系列的类。便于管理，还可以防止类重名，在这里也可以不写。
{
   class HelloWorld  // C# 是完全面向对象的语言，执行代码必须放在一个类中
   {
      static void Main(string[] args)  // Main 方法，是所有 C# 程序的入口点。Main 方法说明当执行时类将做什么动作。
      {
         /* 我的第一个 C# 程序*/
         Console.WriteLine("Hello World");
         Console.ReadKey();  // 针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。在 VS2022 中，也可以 Ctrl + F5 启动调试防止控制台自动关闭。
      }
   }
}

using System;
namespace RectangleApplication
{
    class Rectangle
    {
        // 成员变量
        double length;
        double width;
        public void Acceptdetails()
        {
            length = 4.5;    
            width = 3.5;
        }
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("Length: {0}", length);
            Console.WriteLine("Width: {0}", width);
            Console.WriteLine("Area: {0}", GetArea());
        }
    }
    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.Acceptdetails();
            r.Display();
            Console.ReadLine();
        }
    }
}

using System;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            PrintValueTypeRange();
        }
        static void PrintValueTypeRange()
        {
            Console.WriteLine("int      类型的最大值是：{0}", int.MaxValue);  //  32 位有符号整数类型
            Console.WriteLine("uint     类型的最大值是：{0}", uint.MaxValue);  // 32 位无符号整数类型
            Console.WriteLine("byte     类型的最大值是：{0}", byte.MaxValue);  // 8 位无符号整数
            Console.WriteLine("sbyte    类型的最大值是：{0}", sbyte.MaxValue);  // 8 位有符号整数类型
            Console.WriteLine("short    类型的最大值是：{0}", short.MaxValue);  // 16 位有符号整数类型
            Console.WriteLine("ushort   类型的最大值是：{0}", ushort.MaxValue);  // 16 位无符号整数类型
            Console.WriteLine("long     类型的最大值是：{0}", long.MaxValue);  // 64 位有符号整数类型
            Console.WriteLine("ulong    类型的最大值是：{0}", ulong.MaxValue);  // 64 位无符号整数类型
            Console.WriteLine("float    类型的最大值是：{0}", float.MaxValue);  // 32 位单精度浮点型
            Console.WriteLine("double   类型的最大值是：{0}", double.MaxValue);  // 64 位双精度浮点型
            Console.WriteLine("decimal  类型的最大值是：{0}", decimal.MaxValue);  // 128 位精确的十进制值，28-29 有效位数
            Console.WriteLine("int      类型的最小值是：{0}", int.MinValue);
            Console.WriteLine("uint     类型的最小值是：{0}", uint.MinValue);
            Console.WriteLine("byte     类型的最小值是：{0}", byte.MinValue);
            Console.WriteLine("sbyte    类型的最小值是：{0}", sbyte.MinValue);
            Console.WriteLine("short    类型的最小值是：{0}", short.MinValue);
            Console.WriteLine("ushort   类型的最小值是：{0}", ushort.MinValue);
            Console.WriteLine("long     类型的最小值是：{0}", long.MinValue);
            Console.WriteLine("ulong    类型的最小值是：{0}", ulong.MinValue);
            Console.WriteLine("float    类型的最小值是：{0}", float.MinValue);
            Console.WriteLine("double   类型的最小值是：{0}", double.MinValue);
            Console.WriteLine("decimal  类型的最小值是：{0}", decimal.MinValue);
            Console.ReadKey();
        }
    }
}

using System;
 
namespace DataTypeApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Size of bool: {0}", sizeof(bool));
            Console.WriteLine("Size of byte: {0}", sizeof(byte));
            Console.WriteLine("Size of sbyte: {0}", sizeof(sbyte));
            Console.WriteLine("Size of int: {0}", sizeof(int));
            Console.WriteLine("Size of float: {0}", sizeof(float));
            Console.WriteLine("Size of double: {0}", sizeof(double));
            Console.WriteLine("Size of decimal: {0}", sizeof(decimal));
            Console.ReadLine();
        }
    }
}

using System;
 
namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            // 原始值类型
            int original = 10;
 
            // 装箱过程，将 int 类型装箱为 object 类型
            object boxed = original;
 
            // 拆箱过程，将 object 类型拆箱为 int 类型
            int unboxed = (int)boxed;
 
            Console.WriteLine($"原始值：{original}");
            Console.WriteLine($"拆箱后的值：{unboxed}");
        }
    }
}

dynamic d = 20;

string str = "runoob.com";

string str = @"C:\Windows";

string str = "C:\\Windows";

using System;
 
namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = @"<script type=""text/javascript"">
    <!--
    -->
</script>";
            Console.WriteLine(str);
            Console.ReadLine();
        }
    }
}

type* identifier;

byte b = 10;
int i = b; // 隐式转换，不需要显式转换

using System;
 
namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            double a = 3.141592653589;
            float b = 3.141592653589f;
 
            Console.WriteLine(a + "");
            Console.WriteLine((float)a + "");
            Console.WriteLine(b);
            Console.ReadLine();
        }
    }
}

using System;
 
namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            string a = "3.1415926535";
            float b = Convert.ToSingle(a);
            Single c = Convert.ToSingle(a);
            double d = Convert.ToDouble(a);
 
            Console.WriteLine(a);
            Console.WriteLine(b);
            Console.WriteLine(c);
            Console.WriteLine(d);
            Console.ReadLine();
        }
    }
}

using System;
 
namespace TypeConversionApplication
{
    class StringConversion
    {
        static void Main(string[] args)
        {
            int i = 75;
            float f = 53.005f;
            double d = 2345.7652;
            bool b = true;
            Console.WriteLine(i.ToString());
            Console.WriteLine(f.ToString());
            Console.WriteLine(d.ToString());
            Console.WriteLine(b.ToString());
            Console.ReadKey();
        }
    }
}

string str = "123.45";
double d = double.Parse(str);

using System;
 
namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "123.45";
            double d;
            bool success = double.TryParse(str, out d);
 
            if (success)
            {
                Console.WriteLine("转换成功: " + d);
            }
            else
            {
                Console.WriteLine("转换失败");
            }
 
            int i;
            success = int.TryParse(str, out i);
 
            if (success)
            {
                Console.WriteLine("转换成功: " + i);
            }
            else
            {
                Console.WriteLine("转换失败");
            }
 
            Console.ReadKey();
        }
    }
}

using System;
 
public class Fahrenheit
{
    public double Degrees { get; set; }
 
    public Fahrenheit(double degrees)
    {
        Degrees = degrees;
    }
 
    // 隐式转换从华氏温度转为摄氏温度
    public static implicit operator Celsius(Fahrenheit f)
    {
        return new Celsius((f.Degrees - 32) / 1.8);
    }
 
    // 显式转换从摄氏温度转为华氏温度
    public static explicit operator Fahrenheit(Celsius c)
    {
        return new Fahrenheit(32 + c.Degrees * 1.8);
    }
}
 
public class Celsius
{
    public double Degrees { get; set; }
 
    public Celsius(double degrees)
    {
        Degrees = degrees;
    }
}
 
public class Program
{
    public static void Main()
    {
        Celsius c = new Celsius(37);
        Fahrenheit f = new Fahrenheit(98.6);
        Celsius c2 = f;  // 使用隐式转换
        Fahrenheit f2 = (Fahrenheit)c;  // 使用显式转换
 
        Console.WriteLine(c.Degrees + "°C");
        Console.WriteLine(f.Degrees + "°F");
        Console.WriteLine(c2.Degrees + "°C");
        Console.WriteLine(f2.Degrees + "°F");
 
        Console.ReadKey();
    }
}

using System;
 
namespace VariableDefinition
{
    class Program
    {
        static void Main(string[] args)
        {
            short a;
            int b;
            double c;
 
            /* 实际初始化 */
            a = 10;
            b = 20;
            c = a + b;
            Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
            Console.ReadLine();
        }
    }
}

using System;
 
namespace VariableDefinition
{
    class Program
    {
        static void Main(string[] args)
        {
            int num;
            num = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine(num);
            Console.ReadLine();
        }
    }
}

int g = 20;

10 = 20;

class MyClass
{
    int memberVar = 30; // 成员变量，在整个类中可见
}

class MyClass
{
    static int staticVar = 40; // 静态变量，在整个类中可见
}

for (int i = 0; i < 5; i++)
{
    // i 在循环体内可见
}
// i 在这里不可见

using System;
 
namespace VariableDefinition
{
    class Program
    {
        static void Main(string[] args)
        {
            var num = 0xFeeL;
            Console.WriteLine(num);
            Console.ReadLine();
        }
    }
}

namespace EscapeChar
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello\tWorld\n\n");
            Console.ReadLine();
        }
    }
}

string a = "hello, world";  // hello, world
string b = @"hello, world";  // hello, world
string c = "hello \t world";  // hello     world
string d = @"hello \t world";  // hello \t world
string e = "Joe said \"Hello\" to me";  // Joe said "Hello" to me
string f = @"Joe said ""Hello"" to me";  // Joe said "Hello" to me
string g = "\\\\server\\share\\file.txt";  // \\server\share\file.txt
string h = @"\\server\share\file.txt";  // \\server\share\file.txt
string i = "one\r\ntwo\r\nthree";
string j = @"one
two
three";

using System;
 
namespace VariableDefinition
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic a = 3.14;
            Console.WriteLine(a is float);
            Console.ReadLine();
        }
    }
}

using System;
 
namespace AsOperatorExample
{
    class Program
    {
        static void Main(string[] args)
        {
            object obj = "This is a string";
 
            // Using 'as' operator to cast obj to string
            string str = obj as string;
 
            if (str != null)
            {
                Console.WriteLine("The object was successfully cast to a string.");
                Console.WriteLine(str);
            }
            else
            {
                Console.WriteLine("The object could not be cast to a string.");
            }
 
            // Attempting to cast obj to an incompatible type
            obj = 123;
            str = obj as string;
 
            if (str == null)
            {
                Console.WriteLine("The object could not be cast to a string because it is not a compatible type.");
            }
        }
    }
}

using System;
 
class Program
{
    static void Main(string[] args)
    {
        Type type = typeof(string);
        Console.WriteLine(type.FullName);
        Console.ReadKey();
    }
}

int[] fibarray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 };

// 创建一个字符串列表
List<string> myStrings = new List<string>();
 
// 向列表添加一些字符串元素
myStrings.Add("Google");
myStrings.Add("Runoob");
myStrings.Add("Taobao");

class ForEachTest
{
    static void Main(string[] args)
    {
        int[] fibarray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 };
        foreach (int element in fibarray)
        {
            System.Console.WriteLine(element);
        }
        System.Console.WriteLine();
 
        // 类似 foreach 循环
        for (int i = 0; i < fibarray.Length; i++)
        {
            System.Console.WriteLine(fibarray[i]);
        }
        System.Console.WriteLine();
 
        // 设置集合中元素的计算器
        int count = 0;
        foreach (int element in fibarray)
        {
            count += 1;
            System.Console.WriteLine("Element #{0}: {1}", count, element);
        }
        System.Console.WriteLine("Number of elements in the array: {0}", count);
    }
}

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

using System;
namespace CalculatorApplication
{
    class NumberManipulator
    {
        public void swap(int x, int y)
        {
            int temp;
 
            temp = x; /* 保存 x 的值 */
            x = y;    /* 把 y 赋值给 x */
            y = temp; /* 把 temp 赋值给 y */
        }
 
        static void Main(string[] args)
        {
            NumberManipulator n = new NumberManipulator();
            /* 局部变量定义 */
            int a = 100;
            int b = 200;
 
            Console.WriteLine("在交换之前，a 的值： {0}", a);
            Console.WriteLine("在交换之前，b 的值： {0}", b);
 
            /* 调用函数来交换值 */
            n.swap(a, b);
 
            Console.WriteLine("在交换之后，a 的值： {0}", a);
            Console.WriteLine("在交换之后，b 的值： {0}", b);
 
            Console.ReadLine();
        }
    }
}

using System;
namespace CalculatorApplication
{
    class NumberManipulator
    {
        public void swap(ref int x, ref int y)
        {
            int temp;
 
            temp = x; /* 保存 x 的值 */
            x = y;    /* 把 y 赋值给 x */
            y = temp; /* 把 temp 赋值给 y */
        }
 
        static void Main(string[] args)
        {
            NumberManipulator n = new NumberManipulator();
            /* 局部变量定义 */
            int a = 100;
            int b = 200;
 
            Console.WriteLine("在交换之前，a 的值： {0}", a);
            Console.WriteLine("在交换之前，b 的值： {0}", b);
 
            /* 调用函数来交换值 */
            n.swap(ref a, ref b);
 
            Console.WriteLine("在交换之后，a 的值： {0}", a);
            Console.WriteLine("在交换之后，b 的值： {0}", b);
 
            Console.ReadLine();
 
        }
    }
}

using System;
 
namespace CalculatorApplication
{
    class NumberManipulator
    {
        public void getValue(out int x)
        {
            int temp = 5;
            x = temp;
        }
 
        static void Main(string[] args)
        {
            NumberManipulator n = new NumberManipulator();
            /* 局部变量定义 */
            int a = 100;
 
            Console.WriteLine("在方法调用之前，a 的值： {0}", a);
 
            /* 调用函数来获取值 */
            n.getValue(out a);
 
            Console.WriteLine("在方法调用之后，a 的值： {0}", a);
            Console.ReadLine();
 
        }
    }
}

using System;
namespace CalculatorApplication
{
    class NullablesAtShow
    {
        static void Main(string[] args)
        {
            int? num1 = null;
            int? num2 = 45;
            double? num3 = new double?();
            double? num4 = 3.14157;
 
            bool? boolval = new bool?();
 
            // 显示值
 
            Console.WriteLine("显示可空类型的值： {0}, {1}, {2}, {3}",
                               num1, num2, num3, num4);
            Console.WriteLine("一个可空的布尔值： {0}", boolval);
            Console.ReadLine();
 
        }
    }
}

using System;
namespace CalculatorApplication
{
    class NullablesAtShow
    {
 
        static void Main(string[] args)
        {
 
            double? num1 = null;
            double? num2 = 3.14157;
            double num3;
            num3 = num1 ?? 5.34;      // num1 如果为空值则返回 5.34
            Console.WriteLine("num3 的值： {0}", num3);
            num3 = num2 ?? 5.34;
            Console.WriteLine("num3 的值： {0}", num3);
            Console.ReadLine();
 
        }
    }
}

using System;
namespace ArrayApplication
{
    class MyArray
    {
        static void Main(string[] args)
        {
            int[] n = new int[10]; /* n 是一个带有 10 个整数的数组 */
            int i, j;
 
 
            /* 初始化数组 n 中的元素 */
            for (i = 0; i < 10; i++)
            {
                n[i] = i + 100;
            }
 
            /* 输出每个数组元素的值 */
            for (j = 0; j < 10; j++)
            {
                Console.WriteLine("Element[{0}] = {1}", j, n[j]);
            }
            Console.ReadKey();
        }
    }
}

using System;
 
namespace TwoDimensionalArrayExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 定义一个3行4列的二维数组
            int[,] array = new int[3, 4];
 
            // 使用嵌套循环来初始化数组元素
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    array[i, j] = i * j; // 举例：初始化为行索引乘以列索引
                }
            }
            
            /* 也可直接初始化：
                int[,] array = 
                {
                    { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 }
                };
            */
 
            // 打印数组元素
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    Console.Write(array[i, j] + "\t");
                }
                Console.WriteLine();
            }
        }
    }
}

int [,] a = new int [3,4] {
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

int [][] scores;

int[][] scores = new int[5][];
for (int i = 0; i < scores.Length; i++) 
{
   scores[i] = new int[4];
}

int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};

using System;
 
namespace ArrayApplication
{
   class MyArray
   {
      double getAverage(int[] arr, int size)
      {
         int i;
         double avg;
         int sum = 0;
 
         for (i = 0; i < size; ++i)
         {
            sum += arr[i];
         }
 
         avg = (double)sum / size;
         return avg;
      }
      static void Main(string[] args)
      {
         MyArray app = new MyArray();
         /* 一个带有 5 个元素的 int 数组 */
         int [] balance = new int[]{1000, 2, 3, 17, 50};
         double avg;
 
         /* 传递数组的指针作为参数 */
         avg = app.getAverage(balance, 5 ) ;
 
         /* 输出返回值 */
         Console.WriteLine( "平均值是： {0} ", avg );
         Console.ReadKey();
      }
   }
}

using System;
 
namespace StringApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            // 字符串，字符串连接
            string fname, lname;
            fname = "Rowan";
            lname = "Atkinson";
 
            string fullname = fname + lname;
            Console.WriteLine("Full Name: {0}", fullname);
 
            // 通过使用 string 构造函数
            char[] letters = { 'H', 'e', 'l', 'l', 'o' };
            string greetings = new string(letters);
            Console.WriteLine("Greetings: {0}", greetings);
 
            // 方法返回字符串
            string[] sarray = { "Hello", "From", "Tutorials", "Point" };
            string message = String.Join(" ", sarray);
            Console.WriteLine("Message: {0}", message);
 
            // 用于转化值的格式化方法
            DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
            string chat = String.Format("Message sent at {0:t} on {0:D}",
            waiting);
            Console.WriteLine("Message: {0}", chat);
            Console.ReadKey();
        }
    }
}

using System;
 
namespace StringApplication
{
    class StringProg
    {
        static void Main(string[] args)
        {
            string str1 = "This is test";
            string str2 = "This is test";
 
            if (String.Compare(str1, str2) == 0)
            {
                Console.WriteLine(str1 + " and " + str2 + " are equal.");
            }
            else
            {
                Console.WriteLine(str1 + " and " + str2 + " are not equal.");
            }
 
            Console.ReadKey();
        }
    }
}

using System;
 
namespace StringApplication
{
    class StringProg
    {
        static void Main(string[] args)
        {
            string str = "This is test";
            if (str.Contains("test"))
            {
                Console.WriteLine("The sequence 'test' was found.");
            }
            Console.ReadKey();
        }
    }
}

using System;
namespace StringApplication
{
    class StringProg
    {
        static void Main(string[] args)
        {
            string str = "01234567890123456789";
            Console.WriteLine(str);
            string substr = str.Substring(10);
            Console.WriteLine(substr);
            Console.ReadKey();
        }
    }
}

using System;
 
namespace StringApplication
{
   class StringProg
   {
      static void Main(string[] args)
      {
         string[] starray = new string[]{"Down the way nights are dark",
         "And the sun shines daily on the mountain top",
         "I took a trip on a sailing ship",
         "And when I reached Jamaica",
         "I made a stop"};
 
         string str = String.Join("\n", starray);
         Console.WriteLine(str);
         Console.ReadKey() ;
      }
   }
}

DateTime dt = new DateTime(2017, 4, 1, 13, 16, 32, 108);
string.Format("{0:y yy yyy yyyy}",dt); // 17 17 2017 2017
string.Format("{0:M MM MMM MMMM}", dt);// 4  04 四月 四月
string.Format("{0:d dd ddd dddd}", dt);// 1  01 周六 星期六
string.Format("{0:t tt}", dt);// 下 下午
string.Format("{0:H HH}", dt);// 13 13
string.Format("{0:h hh}", dt);// 1  01
string.Format("{0:m mm}", dt);// 16 16
string.Format("{0:s ss}", dt);// 32 32
string.Format("{0:F FF FFF FFFF FFFFF FFFFFF FFFFFFF}", dt);// 1 1  108 108  108   108    108
string.Format("{0:f ff fff ffff fffff ffffff fffffff}", dt);// 1 10 108 1080 10800 108000 1080000
string.Format("{0:z zz zzz}", dt);// +8 +08 +08:00
 
string.Format("{0:yyyy/MM/dd HH:mm:ss.fff}",dt);　　// 2017/04/01 13:16:32.108
string.Format("{0:yyyy/MM/dd dddd}", dt);　　　　　　// 2017/04/01 星期六
string.Format("{0:yyyy/MM/dd dddd tt hh:mm}", dt); // 2017/04/01 星期六 下午 01:16
string.Format("{0:yyyyMMdd}", dt);　　　　　　　　　// 20170401
string.Format("{0:yyyy-MM-dd HH:mm:ss.fff}", dt);　// 2017-04-01 13:16:32.108

DateTime dt = new DateTime(2017,4,1,13,16,32,108);
dt.ToString("y yy yyy yyyy");  // 17 17 2017 2017
dt.ToString("M MM MMM MMMM");  // 4  04 四月 四月
dt.ToString("d dd ddd dddd");  // 1  01 周六 星期六
dt.ToString("t tt");  // 下 下午
dt.ToString("H HH");  // 13 13
dt.ToString("h hh");  // 1  01
dt.ToString("m mm");  // 16 16
dt.ToString("s ss");  // 32 32
dt.ToString("F FF FFF FFFF FFFFF FFFFFF FFFFFFF");  // 1 1  108 108  108   108    108
dt.ToString("f ff fff ffff fffff ffffff fffffff");  // 1 10 108 1080 10800 108000 1080000
dt.ToString("z zz zzz");  // +8 +08 +08:00
 
dt.ToString("yyyy/MM/dd HH:mm:ss.fff");　// 2017/04/01 13:16:32.108
dt.ToString("yyyy/MM/dd dddd");  // 2017/04/01 星期六
dt.ToString("yyyy/MM/dd dddd tt hh:mm");  // 2017/04/01 星期六 下午 01:16
dt.ToString("yyyyMMdd");  // 20170401
dt.ToString("yyyy-MM-dd HH:mm:ss.fff");　 // 2017-04-01 13:16:32.108

using System;
using System.Text;
 
struct Books
{
    public string title;
    public string author;
    public string subject;
    public int book_id;
};
 
public class testStructure
{
    public static void Main(string[] args)
    {
		/* 声明 Book1，类型为 Books */
        Books Book1;
        /* 声明 Book2，类型为 Books */
        Books Book2;
 
        /* book 1 详述 */
        Book1.title = "C Programming";
        Book1.author = "Nuha Ali";
        Book1.subject = "C Programming Tutorial";
        Book1.book_id = 6495407;
 
        /* book 2 详述 */
        Book2.title = "Telecom Billing";
        Book2.author = "Zara Ali";
        Book2.subject = "Telecom Billing Tutorial";
        Book2.book_id = 6495700;
 
        /* 打印 Book1 信息 */
        Console.WriteLine("Book 1 title : {0}", Book1.title);
        Console.WriteLine("Book 1 author : {0}", Book1.author);
        Console.WriteLine("Book 1 subject : {0}", Book1.subject);
        Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);
 
        /* 打印 Book2 信息 */
        Console.WriteLine("Book 2 title : {0}", Book2.title);
        Console.WriteLine("Book 2 author : {0}", Book2.author);
        Console.WriteLine("Book 2 subject : {0}", Book2.subject);
        Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);
 
        Console.ReadKey();
 
    }
}

using System;
 
// 结构声明
struct MyStruct
{
    public int X;
    public int Y;
 
    // 结构不能有无参数的构造函数
    // public MyStruct()
    // {
    // }
 
    // 有参数的构造函数
    // CS0171	必须先完全分配字段 'MyStruct.Y' ，然后才能将控件返回给调用方。请考虑更新到语言版本 '11.0' 以自动默认字段
    public MyStruct(int x, int y)
    {
        X = x;
        Y = y;
    }
 
    // 结构不能继承
    // struct MyDerivedStruct : MyBaseStruct
    // {
    // }
}
 
// 类声明
class MyClass
{
    public int X;
    public int Y;
 
    // 类可以有无参数的构造函数
    public MyClass()
    {
    }
 
    // 有参数的构造函数
    public MyClass(int x, int y)
    {
        X = x;
        Y = y;
    }
 
    // 类支持继承
    // class MyDerivedClass : MyBaseClass
    // {
    // }
 
    public MyClass ShallowCopy()
    {
        return (MyClass)this.MemberwiseClone();
    }
}
 
class Program
{
    static void Main()
    {
        // 结构是值类型，分配在栈上
        MyStruct structInstance1 = new MyStruct(1, 2);
        MyStruct structInstance2 = structInstance1; // 复制整个结构
 
        // 类是引用类型，分配在堆上
        MyClass classInstance1 = new MyClass(3, 4);
        MyClass classInstance2 = classInstance1; // 复制引用，指向同一个对象
        MyClass classInstance3 = classInstance1.ShallowCopy(); // 浅拷贝，指向不同对象
 
        // 修改结构实例不影响其他实例
        structInstance1.X = 5;
        Console.WriteLine($"Struct: {structInstance1.X}, {structInstance2.X}");
 
        // 修改类实例会影响其他实例
        classInstance1.X = 6;
        Console.WriteLine($"Class: {classInstance1.X}, {classInstance2.X}, {classInstance3.X}");
    }
}

using System;
 
public class EnumTest
{
    enum Day { Sun = 1, Mon = 3, Tue, Wed, Thu, Fri = 9, Sat };
 
    static void Main()
    {
        Console.WriteLine("Sun = {0}, Mon = {1}, Tue = {2}, Wed = {3}, Thu = {4}, Fri = {5}, Sat = {6}", (int)Day.Sun, (int)Day.Mon, (int)Day.Tue, (int)Day.Wed, (int)Day.Thu, (int)Day.Fri, (int)Day.Sat);
    }
}

<access specifier> class  class_name 
{
    // member variables
    <access specifier> <data type> variable1;
    <access specifier> <data type> variable2;
    ...
    <access specifier> <data type> variableN;
    // member methods
    <access specifier> <return type> method1(parameter_list) 
    {
        // method body 
    }
    <access specifier> <return type> method2(parameter_list) 
    {
        // method body 
    }
    ...
    <access specifier> <return type> methodN(parameter_list) 
    {
        // method body 
    }
}

using System;
namespace BoxApplication
{
    class Box
    {
        private double length;   // 长度
        private double breadth;  // 宽度
        private double height;   // 高度
        public void setLength(double len)
        {
            length = len;
        }
 
        public void setBreadth(double bre)
        {
            breadth = bre;
        }
 
        public void setHeight(double hei)
        {
            height = hei;
        }
        public double getVolume()
        {
            return length * breadth * height;
        }
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();        // 声明 Box2，类型为 Box
            double volume;               // 体积
 
 
            // Box1 详述
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);
 
            // Box2 详述
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);
 
            // Box1 的体积
            volume = Box1.getVolume();
            Console.WriteLine("Box1 的体积： {0}", volume);
 
            // Box2 的体积
            volume = Box2.getVolume();
            Console.WriteLine("Box2 的体积： {0}", volume);
 
            Console.ReadKey();
        }
    }
}

using System;
namespace StaticVarApplication
{
    class StaticVar
    {
        public static int num;
        public void count()
        {
            num++;
        }
        public static int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s = new StaticVar();
            s.count();
            s.count();
            s.count();
            Console.WriteLine("变量 num： {0}", StaticVar.getNum());
            Console.ReadKey();
        }
    }
}

<访问修饰符> class <基类>
{
 ...
}
class <派生类> : <基类>
{
 ...
}

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // 成员变量
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         length = l;
         width = w;
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("长度： {0}", length);
         Console.WriteLine("宽度： {0}", width);
         Console.WriteLine("面积： {0}", GetArea());
      }
   }//end class Rectangle  
   class Tabletop : Rectangle
   {
      private double cost;
      public Tabletop(double l, double w) : base(l, w)
      { }
      public double GetCost()
      {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("成本： {0}", GetCost());
      }
   }
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

using System;
 
// 定义一个基接口
interface IBaseInterface
{
    void Method1();
}
 
// 定义一个派生接口，继承自基接口
interface IDerivedInterface : IBaseInterface
{
    void Method2();
}
 
// 实现派生接口的类
class MyClass : IDerivedInterface
{
    public void Method1()
    {
        Console.WriteLine("Method1 implementation");
    }
 
    public void Method2()
    {
        Console.WriteLine("Method2 implementation");
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        // 创建 MyClass 类的实例
        MyClass obj = new MyClass();
 
        // 调用继承自基接口的方法
        obj.Method1();
 
        // 调用派生接口新增的方法
        obj.Method2();
    }
}

using System;
 
// 定义一个基接口
interface IBaseInterface
{
    void Method1();
}
 
// 定义一个派生接口，继承自基接口（接口一样可以继承）
interface IDerivedInterface : IBaseInterface
{
    void Method2();
}
 
// 实现派生接口的类（必须实现，不然编译失败）
class MyClass : IDerivedInterface
{
    public void Method1()
    {
        Console.WriteLine("Method1 implementation");
    }
 
    public void Method2()
    {
        Console.WriteLine("Method2 implementation");
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        // 创建 MyClass 类的实例
        MyClass obj = new MyClass();
 
        // 调用继承自基接口的方法
        obj.Method1();
 
        // 调用派生接口新增的方法
        obj.Method2();
    }
}

using System;
namespace InheritanceApplication
{
    class Shape
    {
        public void setWidth(int w)
        {
            width = w;
        }
        public void setHeight(int h)
        {
            height = h;
        }
        protected int width;
        protected int height;
    }
 
    // 基类 PaintCost
    public interface PaintCost
    {
        int getPaintCost(int area);
 
    }
 
    // 基类 FlatCost
    public interface FlatCost
    {
        int getFlatCost(int area);
 
    }
    // 派生类
    class Rectangle : Shape, PaintCost, FlatCost
    {
        public int getArea()
        {
            return (width * height);
        }
        public int getPaintCost(int area)
        {
            return area * 70;
        }
        public int getFlatCost(int area)
        {
            return area * 20;
        }
    }
    class RectangleTester
    {
        static void Main(string[] args)
        {
            Rectangle Rect = new Rectangle();
            int area;
            Rect.setWidth(5);
            Rect.setHeight(7);
            area = Rect.getArea();
            // 打印对象的面积
            Console.WriteLine("总面积： {0}", Rect.getArea());
            Console.WriteLine("油漆总成本： ${0}", Rect.getPaintCost(area));
            Console.WriteLine("工本费： ${0}", Rect.getFlatCost(area));
            Console.ReadKey();
        }
    }
}

using System;
namespace PolymorphismApplication
{
    public class TestData  
    {  
        public int Add(int a, int b, int c)  
        {  
            return a + b + c;  
        }  
        public int Add(int a, int b)  
        {  
            return a + b;  
        }  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            TestData dataClass = new TestData();
            int add1 = dataClass.Add(1, 2);  
            int add2 = dataClass.Add(1, 2, 3);
 
            Console.WriteLine("add1 :" + add1);
            Console.WriteLine("add2 :" + add2);  
        }  
    }  
}

using System;
namespace PolymorphismApplication
{
    abstract class Shape
    {
        abstract public int area();  // 标记为 abstract 的函数只可声明，不可定义实现
    }
 
    class Rectangle : Shape
    {
        private int length;
        private int width;
        public Rectangle(int a = 0, int b = 0)
        {
            length = a;
            width = b;
        }
        public override int area()  // 若要实现继承所定义的函数，使用 override 标记
        {
            Console.WriteLine("Rectangle 类的面积：");
            return (width * length);
        }
    }
 
    class RectangleTester
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle(10, 7);
            double a = r.area();
            Console.WriteLine("面积： {0}", a);
            Console.ReadKey();
        }
    }
}

using System;
using System.Collections.Generic;
 
public abstract class Shape
{
    public int X { get; private set; }
    public int Y { get; private set; }
    public int Height { get; set; }
    public int Width { get; set; }
 
    // 虚方法
    public virtual void Draw()
    {
        Console.WriteLine("执行基类的画图任务");
    }
}
 
class Circle : Shape
{
    public override void Draw()  // 同样使用 override
    {
        Console.WriteLine("画一个圆形");
        base.Draw();
    }
}
class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("画一个长方形");
        base.Draw();
    }
}
class Triangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("画一个三角形");
        base.Draw();
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        // 创建一个 List<Shape> 对象，并向该对象添加 Circle、Triangle 和 Rectangle
        var shapes = new List<Shape>
        {
            new Rectangle(),
            new Triangle(),
            new Circle()
        };
 
        // 使用 foreach 循环对该列表的派生类进行循环访问，并对其中的每个 Shape 对象调用 Draw 方法 
        foreach (var shape in shapes)
        {
            shape.Draw();
        }
 
        Console.WriteLine("按下任意键退出。");
        Console.ReadKey();
    }
 
}

using System;
namespace PolymorphismApplication
{
   class Shape 
   {
      protected int width, height;
      public Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      public virtual int area()
      {
         Console.WriteLine("父类的面积：");
         return 0;
      }
   }
   class Rectangle: Shape
   {
      public Rectangle( int a=0, int b=0): base(a, b)
      {
 
      }
      public override int area ()
      {
         Console.WriteLine("Rectangle 类的面积：");
         return (width * height); 
      }
   }
   class Triangle: Shape
   {
      public Triangle(int a = 0, int b = 0): base(a, b)
      {
      
      }
      public override int area()
      {
         Console.WriteLine("Triangle 类的面积：");
         return (width * height / 2); 
      }
   }
   class Caller
   {
      public void CallArea(Shape sh)
      {
         int a;
         a = sh.area();
         Console.WriteLine("面积： {0}", a);
      }
   }  
   class Tester
   {
      
      static void Main(string[] args)
      {
         Caller c = new Caller();
         Rectangle r = new Rectangle(10, 7);
         Triangle t = new Triangle(10, 5);
         c.CallArea(r);
         c.CallArea(t);
         Console.ReadKey();
      }
   }
}

using System;
 
namespace OperatorOvlApplication
{
   class Box
   {
      private double length;      // 长度
      private double breadth;     // 宽度
      private double height;      // 高度
 
      public double getVolume()
      {
         return length * breadth * height;
      }
      public void setLength( double len )
      {
         length = len;
      }
 
      public void setBreadth( double bre )
      {
         breadth = bre;
      }
 
      public void setHeight( double hei )
      {
         height = hei;
      }
      // 重载 + 运算符来把两个 Box 对象相加
      public static Box operator+ (Box b, Box c)
      {
         Box box = new Box();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         return box;
      }
 
   }
 
   class Tester
   {
      static void Main(string[] args)
      {
         Box Box1 = new Box();         // 声明 Box1，类型为 Box
         Box Box2 = new Box();         // 声明 Box2，类型为 Box
         Box Box3 = new Box();         // 声明 Box3，类型为 Box
         double volume = 0.0;          // 体积
 
         // Box1 详述
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);
 
         // Box2 详述
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);
 
         // Box1 的体积
         volume = Box1.getVolume();
         Console.WriteLine("Box1 的体积： {0}", volume);
 
         // Box2 的体积
         volume = Box2.getVolume();
         Console.WriteLine("Box2 的体积： {0}", volume);
 
         // 把两个对象相加
         Box3 = Box1 + Box2;
 
         // Box3 的体积
         volume = Box3.getVolume();
         Console.WriteLine("Box3 的体积： {0}", volume);
         Console.ReadKey();
      }
   }
}

using System;
 
interface IMyInterface
{
        // 接口成员
    void MethodToImplement();
}
 
class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }
 
    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

using System;
 
interface IParentInterface
{
    void ParentInterfaceMethod();
}
 
interface IMyInterface : IParentInterface
{
    void MethodToImplement();
}
 
class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
        iImp.ParentInterfaceMethod();
    }
 
    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
 
    public void ParentInterfaceMethod()
    {
        Console.WriteLine("ParentInterfaceMethod() called.");
    }
}

using System;
 
namespace first_space
{
    class namespace_cl
    {
        public void func()
        {
            Console.WriteLine("Inside first_space");
        }
    }
}
namespace second_space
{
    class namespace_cl
    {
        public void func()
        {
            Console.WriteLine("Inside second_space");
        }
    }
}
class TestClass
{
    static void Main(string[] args)
    {
        first_space.namespace_cl fc = new first_space.namespace_cl();
        second_space.namespace_cl sc = new second_space.namespace_cl();
        fc.func();
        sc.func();
        Console.ReadKey();
    }
}

Console.WriteLine ("Hello there");

System.Console.WriteLine("Hello there");

using System;
using first_space;
using second_space;
 
namespace first_space
{
    class abc
    {
        public void func()
        {
            Console.WriteLine("Inside first_space");
        }
    }
}
namespace second_space
{
    class efg
    {
        public void func()
        {
            Console.WriteLine("Inside second_space");
        }
    }
}
class TestClass
{
    static void Main(string[] args)
    {
        abc fc = new abc();
        efg sc = new efg();
        fc.func();
        sc.func();
        Console.ReadKey();
    }
}

using System;
using SomeNameSpace;
using SomeNameSpace.Nested;
 
namespace SomeNameSpace
{
    public class MyClass 
    {
        static void Main() 
        {
            Console.WriteLine("In SomeNameSpace");
            Nested.NestedNameSpaceClass.SayHello();
        }
    }
 
    // 内嵌命名空间
    namespace Nested   
    {
        public class NestedNameSpaceClass 
        {
            public static void SayHello() 
            {
                Console.WriteLine("In Nested");
            }
        }
    }
}

#define DEBUG
 
#undef RELEASE

#define PI 
using System;
namespace PreprocessorDAppl
{
    class Program
    {
        static void Main(string[] args)
        {
#if (PI)
            Console.WriteLine("PI is defined");
#else
            Console.WriteLine("PI is not defined");
#endif
            Console.ReadKey();
        }
    }
}

#define DEBUG
#define VC_V10
using System;
public class TestClass
{
   public static void Main()
   {
 
      #if (DEBUG && !VC_V10)
         Console.WriteLine("DEBUG is defined");
      #elif (!DEBUG && VC_V10)
         Console.WriteLine("VC_V10 is defined");
      #elif (DEBUG && VC_V10)
         Console.WriteLine("DEBUG and VC_V10 are defined");
      #else
         Console.WriteLine("DEBUG and VC_V10 are not defined");
      #endif
      Console.ReadKey();
   }
}

using System;
using System.Text.RegularExpressions;
 
public class Example
{
    public static void Main()
    {
        string input = "1851 1999 1950 1905 2003";
        string pattern = @"(?<=19)\d{2}\b";
 
        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine(match.Value);
    }
}

using System;
namespace ErrorHandlingApplication
{
    class DivNumbers
    {
        int result;
        DivNumbers()
        {
            result = 0;
        }
        public void division(int num1, int num2)
        {
            try
            {
                result = num1 / num2;
            }
            catch (DivideByZeroException e)
            {
                Console.WriteLine("Exception caught: {0}", e);
            }
            finally
            {
                Console.WriteLine("Result: {0}", result);
            }
 
        }
        static void Main(string[] args)
        {
            DivNumbers d = new DivNumbers();
            d.division(25, 0);
            d.division(25, 5);
            Console.ReadKey();
        }
    }
}

using System;
namespace UserDefinedException
{
    class TestTemperature
    {
        static void Main(string[] args)
        {
            Temperature temp = new Temperature();
            try
            {
                temp.showTemp();
            }
            catch (TempIsZeroException e)
            {
                Console.WriteLine("TempIsZeroException: {0}", e.Message);
            }
            Console.ReadKey();
        }
    }
}
public class TempIsZeroException : ApplicationException
{
    public TempIsZeroException(string message) : base(message)
    {
    }
}
public class Temperature
{
    int temperature = 0;
    public void showTemp()
    {
        if (temperature == 0)
        {
            throw (new TempIsZeroException("Zero Temperature found"));
        }
        else
        {
            Console.WriteLine("Temperature: {0}", temperature);
        }
    }
}

Catch(Exception e)
{
   ...
   Throw e
}

// 一个自定义特性 BugFix 被赋给类及其成员
using System;
 
[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]
 
public class DeBugInfo : System.Attribute
{
    private int bugNo;
    private string developer;
    private string lastReview;
    public string message;
 
    public DeBugInfo(int bg, string dev, string d)
    {
        this.bugNo = bg;
        this.developer = dev;
        this.lastReview = d;
    }
 
    public int BugNo
    {
        get
        {
            return bugNo;
        }
    }
    public string Developer
    {
        get
        {
            return developer;
        }
    }
    public string LastReview
    {
        get
        {
            return lastReview;
        }
    }
    public string Message
    {
        get
        {
            return message;
        }
        set
        {
            message = value;
        }
    }
}
 
[DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type mismatch")]
[DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused variable")]
class Rectangle
{
    // 成员变量
    protected double length;
    protected double width;
    public Rectangle(double l, double w)
    {
        length = l;
        width = w;
    }
    [DeBugInfo(55, "Zara Ali", "19/10/2012",
    Message = "Return type mismatch")]
    public double GetArea()
    {
        return length * width;
    }
    [DeBugInfo(56, "Zara Ali", "19/10/2012")]
    public void Display()
    {
        Console.WriteLine("Length: {0}", length);
        Console.WriteLine("Width: {0}", width);
        Console.WriteLine("Area: {0}", GetArea());
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        Rectangle r = new Rectangle(5, 8);
        r.Display();
    }
}

using System;
 
[AttributeUsage(AttributeTargets.All)]
public class HelpAttribute : System.Attribute
{
    public readonly string Url;
 
    public string Topic  // Topic 是一个命名（named）参数
    {
        get
        {
            return topic;
        }
        set
        {
 
            topic = value;
        }
    }
 
    public HelpAttribute(string url)  // url 是一个定位（positional）参数
    {
        this.Url = url;
    }
 
    public override string ToString()
    {
        return base.ToString() + ": "+ this.Url;
    }
 
    private string topic;
}
[HelpAttribute("Information on the class MyClass")]
class MyClass
{
}
 
namespace AttributeAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Reflection.MemberInfo info = typeof(MyClass);
            object[] attributes = info.GetCustomAttributes(true);
            for (int i = 0; i < attributes.Length; i++)
            {
                System.Console.WriteLine(attributes[i]);
            }
            Console.ReadKey();
 
        }
    }
}

using System;
namespace runoob
{
    class Student
    {
 
        private string code = "N.A";
        private string name = "not known";
        private int age = 0;
 
        // 声明类型为 string 的 Code 属性
        public string Code
        {
            get
            {
                return code;
            }
            set
            {
                code = value;
            }
        }
 
        // 声明类型为 string 的 Name 属性
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
 
        // 声明类型为 int 的 Age 属性
        public int Age
        {
            get
            {
                return age;
            }
            set
            {
                age = value;
            }
        }
        public override string ToString()
        {
            return "Code = " + Code + ", Name = " + Name + ", Age = " + Age;
        }
    }
    class ExampleDemo
    {
        public static void Main()
        {
            // 创建一个新的 Student 对象
            Student s = new Student();
 
            // 设置 student 的 code、name 和 age
            s.Code = "001";
            s.Name = "Zara";
            s.Age = 9;
            Console.WriteLine("Student Info: {0}", s);
            // 增加年龄
            s.Age += 1;
            Console.WriteLine("Student Info: {0}", s);
            Console.ReadKey();
        }
    }
}

using System;
namespace runoob
{
    public abstract class Person
    {
        public abstract string Name
        {
            get;
            set;
        }
        public abstract int Age
        {
            get;
            set;
        }
    }
    class Student : Person
    {
 
        private string code = "N.A";
        private string name = "N.A";
        private int age = 0;
 
        // 声明类型为 string 的 Code 属性
        public string Code
        {
            get
            {
                return code;
            }
            set
            {
                code = value;
            }
        }
 
        // 声明类型为 string 的 Name 属性
        public override string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
 
        // 声明类型为 int 的 Age 属性
        public override int Age
        {
            get
            {
                return age;
            }
            set
            {
                age = value;
            }
        }
        public override string ToString()
        {
            return "Code = " + Code + ", Name = " + Name + ", Age = " + Age;
        }
    }
    class ExampleDemo
    {
        public static void Main()
        {
            // 创建一个新的 Student 对象
            Student s = new Student();
 
            // 设置 student 的 code、name 和 age
            s.Code = "001";
            s.Name = "Zara";
            s.Age = 9;
            Console.WriteLine("Student Info:- {0}", s);
            // 增加年龄
            s.Age += 1;
            Console.WriteLine("Student Info:- {0}", s);
            Console.ReadKey();
        }
    }
}

using System;
namespace IndexerApplication
{
    class IndexedNames
    {
        private string[] namelist = new string[size];
        static public int size = 10;
        public IndexedNames()
        {
            for (int i = 0; i < size; i++)
                namelist[i] = "N. A.";
        }
        public string this[int index]
        {
            get
            {
                string tmp;
 
                if (index >= 0 && index <= size - 1)
                {
                    tmp = namelist[index];
                }
                else
                {
                    tmp = "";
                }
 
                return (tmp);
            }
            set
            {
                if (index >= 0 && index <= size - 1)
                {
                    namelist[index] = value;
                }
            }
        }
 
        static void Main(string[] args)
        {
            IndexedNames names = new IndexedNames();
            names[0] = "Zara";
            names[1] = "Riz";
            names[2] = "Nuha";
            names[3] = "Asif";
            names[4] = "Davinder";
            names[5] = "Sunil";
            names[6] = "Rubic";
            for (int i = 0; i < IndexedNames.size; i++)
            {
                Console.WriteLine(names[i]);
            }
            Console.ReadKey();
        }
    }
}

using System;
namespace IndexerApplication
{
    class IndexedNames
    {
        private string[] namelist = new string[size];
        static public int size = 10;
        public IndexedNames()
        {
            for (int i = 0; i < size; i++)
            {
                namelist[i] = "N. A.";
            }
        }
        public string this[int index]
        {
            get
            {
                string tmp;
 
                if (index >= 0 && index <= size - 1)
                {
                    tmp = namelist[index];
                }
                else
                {
                    tmp = "";
                }
 
                return (tmp);
            }
            set
            {
                if (index >= 0 && index <= size - 1)
                {
                    namelist[index] = value;
                }
            }
        }
        public int this[string name]
        {
            get
            {
                int index = 0;
                while (index < size)
                {
                    if (namelist[index] == name)
                    {
                        return index;
                    }
                    index++;
                }
                return index;
            }
 
        }
 
        static void Main(string[] args)
        {
            IndexedNames names = new IndexedNames();
            names[0] = "Zara";
            names[1] = "Riz";
            names[2] = "Nuha";
            names[3] = "Asif";
            names[4] = "Davinder";
            names[5] = "Sunil";
            names[6] = "Rubic";
            // 使用带有 int 参数的第一个索引器
            for (int i = 0; i < IndexedNames.size; i++)
            {
                Console.WriteLine(names[i]);
            }
            // 使用带有 string 参数的第二个索引器
            Console.WriteLine(names["Nuha"]);
            Console.ReadKey();
        }
    }
}

using System;
 
delegate int NumberChanger(int n);
namespace DelegateAppl
{
   class TestDelegate
   {
      static int num = 10;
      public static int AddNum(int p)
      {
         num += p;
         return num;
      }
 
      public static int MultNum(int q)
      {
         num *= q;
         return num;
      }
      public static int getNum()
      {
         return num;
      }
 
      static void Main(string[] args)
      {
         // 创建委托实例
         NumberChanger nc1 = new NumberChanger(AddNum);
         NumberChanger nc2 = new NumberChanger(MultNum);
         // 使用委托对象调用方法
         nc1(25);  // 10 + 15 = 25
         Console.WriteLine("Value of Num: {0}", getNum());
         nc2(5);  // 25 * 5 = 175
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

using System;
 
delegate int NumberChanger(int n);
namespace DelegateAppl
{
    class TestDelegate
    {
        static int num = 10;
        public static int AddNum(int p)
        {
            num += p;
            return num;
        }
 
        public static int MultNum(int q)
        {
            num *= q;
            return num;
        }
        public static int getNum()
        {
            return num;
        }
 
        static void Main(string[] args)
        {
            // 创建委托实例
            NumberChanger nc;
            NumberChanger nc1 = new NumberChanger(AddNum);
            NumberChanger nc2 = new NumberChanger(MultNum);
            nc = nc1;
            nc += nc2;
            // 调用多播
            nc(5);  // (10 + 5) * 5 = 75
            Console.WriteLine("Value of Num: {0}", getNum());
            Console.ReadKey();
        }
    }
}

using System;
using System.IO;
 
namespace DelegateAppl
{
   class PrintString
   {
      static FileStream fs;
      static StreamWriter sw;
      // 委托声明
      public delegate void printString(string s);
 
      // 该方法打印到控制台
      public static void WriteToScreen(string str)
      {
         Console.WriteLine("The String is: {0}", str);
      }
      // 该方法打印到文件
      public static void WriteToFile(string s)
      {
         fs = new FileStream("c:\\message.txt", FileMode.Append, FileAccess.Write);
         sw = new StreamWriter(fs);
         sw.WriteLine(s);
         sw.Flush();
         sw.Close();
         fs.Close();
      }
      // 该方法把委托作为参数，并使用它调用方法
      public static void sendString(printString ps)
      {
         ps("Hello World");
      }
      static void Main(string[] args)
      {
         printString ps1 = new printString(WriteToScreen);
         printString ps2 = new printString(WriteToFile);
         sendString(ps1);
         sendString(ps2);
         Console.ReadKey();
      }
   }
}

public delegate void BoilerLogHandler(string status);

// 基于上面的委托定义事件
public event BoilerLogHandler BoilerEventLog;

using System;
namespace SimpleEvent
{
    using System;
    /***********发布器类***********/
    public class EventTest
    {
        private int value;
 
        public delegate void NumManipulationHandler();
 
        public event NumManipulationHandler ChangeNum;
 
        protected virtual void OnNumChanged()  // 为了允许子类（如果有的话）重写这个方法
        {
            if (ChangeNum != null)
            {
                ChangeNum(); /* 事件被触发，派发事件 ChangeNum */
            }
            else
            {
                Console.WriteLine("event not fire");
                Console.ReadKey(); /* 回车继续 */
            }
        }
 
 
        public EventTest()  // 构造函数
        {
            int n = 5;
            SetValue(n);
        }
 
 
        public void SetValue(int n)
        {
            if (value != n)  // 如果数据更新：
            {
                value = n;
                OnNumChanged();
            }
        }
    }
 
 
    /***********订阅器类***********/
 
    public class subscribEvent
    {
        public void printf()
        {
            Console.WriteLine("event fire");
            Console.ReadKey(); /* 回车继续 */
        }
    }
 
    /***********触发***********/
    public class MainClass
    {
        public static void Main()
        {
            EventTest e = new EventTest(); /* 实例化对象，构造函数将执行一次 OnNumChanged()，第一次没有触发事件 */
            subscribEvent v = new subscribEvent(); /* 实例化对象 */
            e.ChangeNum += new EventTest.NumManipulationHandler(v.printf); /* 注册：接收到消息时，执行函数：printf() */
            e.SetValue(7);
            e.SetValue(11);
            e.SetValue(11);
            e.SetValue(9);
        }
    }
}

using System;
using static System.Console;
using System.Collections.Generic;
namespace HelloWorldApplication
{
    class HelloWorld
    {
        static void Main(string[] args)
        {
            var a = new List<int>();
            a.Add(2);
            a.Add(6);
            a.Add(2);
            a.Add(10);
            Console.WriteLine($"第一个数为{a[0]}");
            a.Remove(2);//删去第一个匹配此条件的项
            a.Sort();
            foreach (var a2 in a)
            {
                WriteLine(a2);
            }
            bool a3 = a.Contains(2);
            WriteLine(a3);
            Console.ReadKey();
        }
    }
}

using System;
using System.Collections;
 
namespace CollectionApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList al = new ArrayList();
 
            Console.WriteLine("Adding some objects:");
            al.Add(45);
            al.Add("A");
            al.Add(33);
            al.Add(56);
            al.Add(true);
            al.Add(23);
            al.Add(9);
 
            Console.WriteLine("Capacity: {0} ", al.Capacity);
            Console.WriteLine("Count: {0}", al.Count);
 
            Console.Write("Content: ");
            foreach (var i in al)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

using System;
using System.Collections;
 
namespace CollectionsApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Hashtable ht = new Hashtable();
 
 
            ht.Add("001", "Zara Ali");
            ht.Add("002", "Abida Rehman");
            ht.Add("003", "Joe Holzner");
            ht.Add("004", "Mausam Benazir Nur");
            ht.Add("005", "M. Amlan");
            ht.Add("006", "M. Arif");
            ht.Add("007", "Ritesh Saikia");
 
            if (ht.ContainsValue("Nuha Ali"))
            {
                Console.WriteLine("This student name is already in the list");
            }
            else
            {
                ht.Add("008", "Nuha Ali");
            }
            // 获取键的集合 
            ICollection key = ht.Keys;
 
            foreach (string k in key)
            {
                Console.WriteLine(k + ": " + ht[k]);
            }
            Console.ReadKey();
        }
    }
}

using System;
using System.Collections.Generic;
namespace HelloWorldApplication
{
    class A
    {
        static void Main(string[] args)
        {
            var a = new Dictionary<int, int>();
            a.Add(12, 14);
            a.Add(0, 1);
            Console.WriteLine("删去前的Count" + a.Count);
            a.Remove(0);
            Console.WriteLine(a[12]);
            Console.WriteLine(a.Count);
            Console.WriteLine(a.ContainsKey(12));
            Console.ReadKey();
        }
    }
}

using System;
using System.Collections;
 
namespace CollectionsApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            SortedList sl = new SortedList();
 
            sl.Add("003", "Joe Holzner");
            sl.Add("001", "Zara Ali");
            sl.Add("004", "Mausam Benazir Nur");
            sl.Add("002", "Abida Rehman");
            sl.Add("107", "Ritesh Saikia");
            sl.Add("006", "M. Arif");
            sl.Add("00A", "M. Amlan");
 
            if (sl.ContainsValue("Nuha Ali"))
            {
                Console.WriteLine("This student name is already in the list");
            }
            else
            {
                sl.Add("008", "Nuha Ali");
            }
 
            // 获取键的集合 
            ICollection key = sl.Keys;
 
            foreach (string k in key)
            {
                Console.WriteLine(k + ": " + sl[k]);
            }
        }
    }
}

using System;
using System.Collections;
 
namespace CollectionsApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Stack st = new Stack();
 
            st.Push('A');
            st.Push('M');
            st.Push('G');
            st.Push('W');
            
            Console.WriteLine("Current stack: ");
            foreach (char c in st)
            {
                Console.Write(c + " ");
            }
            Console.WriteLine();
            
            st.Push('V');
            st.Push('H');
            Console.WriteLine("The next poppable value in stack: {0}", 
            st.Peek());
            Console.WriteLine("Current stack: ");           
            foreach (char c in st)
            {
               Console.Write(c + " ");
            }
            Console.WriteLine();
 
            Console.WriteLine("Removing values ");
            st.Pop();
            st.Pop();
            st.Pop();
            
            Console.WriteLine("Current stack: ");
            foreach (char c in st)
            {
               Console.Write(c + " "); 
            }
        }
    }
}

using System;
using System.Collections;
 
namespace CollectionsApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Queue q = new Queue();
 
         q.Enqueue('A');
         q.Enqueue('M');
         q.Enqueue('G');
         q.Enqueue('W');
         
         Console.WriteLine("Current queue: ");
         foreach (char c in q)
            Console.Write(c + " ");
         Console.WriteLine();
         q.Enqueue('V');
         q.Enqueue('H');
         Console.WriteLine("Current queue: ");         
         foreach (char c in q)
            Console.Write(c + " ");
         Console.WriteLine();
         Console.WriteLine("Removing some values ");
         char ch = (char)q.Dequeue();
         Console.WriteLine("The removed value: {0}", ch);
         ch = (char)q.Dequeue();
         Console.WriteLine("The removed value: {0}", ch);
         Console.ReadKey();
      }
   }
}

using System;
using System.Collections;
 
namespace CollectionsApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            // 创建两个大小为 8 的点阵列
            BitArray ba1 = new BitArray(8);
            BitArray ba2 = new BitArray(8);
            byte[] a = { 60 };
            byte[] b = { 13 };
 
            // 把值 60 和 13 存储到点阵列中
            ba1 = new BitArray(a);
            ba2 = new BitArray(b);
 
            // ba1 的内容
            Console.WriteLine("Bit array ba1: 60");
            for (int i = 0; i < ba1.Count; i++)
            {
                Console.Write("{0, -6} ", ba1[i]);
            }
            Console.WriteLine();
 
            // ba2 的内容
            Console.WriteLine("Bit array ba2: 13");
            for (int i = 0; i < ba2.Count; i++)
            {
                Console.Write("{0, -6} ", ba2[i]);
            }
            Console.WriteLine();
 
 
            BitArray ba3 = new BitArray(8);
            ba3 = ba1.And(ba2);
 
            // ba3 的内容
            Console.WriteLine("Bit array ba3 after AND operation: 12");
            for (int i = 0; i < ba3.Count; i++)
            {
                Console.Write("{0, -6} ", ba3[i]);
            }
            Console.WriteLine();
 
            ba3 = ba1.Or(ba2);
            // ba3 的内容
            Console.WriteLine("Bit array ba3 after OR operation: 61");
            for (int i = 0; i < ba3.Count; i++)
            {
                Console.Write("{0, -6} ", ba3[i]);
            }
            Console.WriteLine();
 
            Console.ReadKey();
        }
    }
}

using System;
using System.Collections.Generic;
 
delegate T NumberChanger<T>(T n);
namespace GenericDelegateAppl
{
    class TestDelegate
    {
        static int num = 10;
        public static int AddNum(int p)
        {
            num += p;
            return num;
        }
 
        public static int MultNum(int q)
        {
            num *= q;
            return num;
        }
        public static int getNum()
        {
            return num;
        }
 
        static void Main(string[] args)
        {
            // 创建委托实例
            NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
            NumberChanger<int> nc2 = new NumberChanger<int>(MultNum);
            // 使用委托对象调用方法
            nc1(25);
            Console.WriteLine("Value of Num: {0}", getNum());
            nc2(5);
            Console.WriteLine("Value of Num: {0}", getNum());
            Console.ReadKey();
        }
    }
}

// 示例：使用 Lambda 表达式定义一个委托
Func<int, int, int> add = (a, b) => a + b;
Console.WriteLine(add(2, 3)); // 输出 5
 
// 示例：使用 Lambda 表达式过滤数组中的元素
int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0);
foreach (var num in evenNumbers)
{
    Console.WriteLine(num); // 输出 2 4
}

using System;
 
delegate void NumberChanger(int n);
namespace DelegateAppl
{
    class TestDelegate
    {
        static int num = 10;
        public static void AddNum(int p)
        {
            num += p;
            Console.WriteLine("Named Method: {0}", num);
        }
 
        public static void MultNum(int q)
        {
            num *= q;
            Console.WriteLine("Named Method: {0}", num);
        }
 
        static void Main(string[] args)
        {
            // 使用匿名方法创建委托实例
            NumberChanger nc = delegate(int x)
            {
               Console.WriteLine("Anonymous Method: {0}", x);
            };
            
            // 使用匿名方法调用委托
            nc(10);
 
            // 使用命名方法实例化委托
            nc =  new NumberChanger(AddNum);
            
            // 使用命名方法调用委托
            nc(5);
 
            // 使用另一个命名方法实例化委托
            nc =  new NumberChanger(MultNum);
            
            // 使用命名方法调用委托
            nc(2);
            Console.ReadKey();
        }
    }
}

using System;
 
delegate void NumberChanger(int n);
 
namespace DelegateAppl
{
    class TestDelegate
    {
        static int num = 10;
 
        public static void AddNum(int p)
        {
            num += p;
            Console.WriteLine("Named Method: {0}", num);
        }
 
        public static void MultNum(int q)
        {
            num *= q;
            Console.WriteLine("Named Method: {0}", num);
        }
 
        static void Main(string[] args)
        {
            // 使用 lambda 表达式创建委托实例
            NumberChanger nc = x => Console.WriteLine($"Lambda Expression: {x}");
 
            // 使用 lambda 表达式调用委托
            nc(10);
 
            // 使用命名方法实例化委托
            nc = new NumberChanger(AddNum);
 
            // 使用命名方法调用委托
            nc(5);
 
            // 使用另一个命名方法实例化委托
            nc = new NumberChanger(MultNum);
 
            // 使用命名方法调用委托
            nc(2);
 
            Console.ReadKey();
        }
    }
}

using System;
namespace UnsafeCodeApplication
{
    class Program
    {
        static unsafe void Main(string[] args)
        {
            int var = 20;
            int* p = &var;
            Console.WriteLine("Data is: {0} ",  var);
            Console.WriteLine("Address is: {0}",  (int)p);
            Console.ReadKey();
        }
    }
}

using System;
using System.Threading;
 
namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            try
            {
 
                Console.WriteLine("Child thread starts");
                // 计数到 10
                for (int counter = 0; counter <= 10; counter++)
                {
                    Thread.Sleep(500);
                    Console.WriteLine(counter);
                }
                Console.WriteLine("Child Thread Completed");
 
            }
            catch (ThreadAbortException e)
            {
                Console.WriteLine("Thread Abort Exception");
            }
            finally
            {
                Console.WriteLine("Couldn't catch the Thread Exception");
            }
 
        }
 
        static void Main(string[] args)
        {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Creating the Child thread");
            Thread childThread = new Thread(childref);
            childThread.Start();
            // 停止主线程一段时间
            Thread.Sleep(2000);
            // 现在中止子线程
            Console.WriteLine("In Main: Aborting the Child thread");
            childThread.Abort();  // 终止子线程
            Console.ReadKey();
        }
    }
}