关于C#的一些东西

最近又看了看C#发现大部分自己只是知道 并不是明白 理解 ，所以写了写 ， 下一篇准备从最基础的开始写起，如果大佬有好的意见请留言。。。。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using System;
delegate int CubeName(int age);
public class CShap : MonoBehaviour {
    /*
     * 自己做的练习题。。。。。。。。。。。。
     * 有个高档的热水器，包含一个加热器，一个报警器和一个现实屏，我们给热水器它通上电，当水温超过95度的时候：

    1、报警器会开始发出语音，告诉你水的温度；

    2、液晶屏也会改变水温的显示，来提示水已经快烧开了。
        int Water = 90;
        delegate void WaterHeater(int heater);

        event WaterHeater WaterEvent;


        public void CallPolice(int heater)
        {
            Debug.Log("当前水温到达" + heater);
        }

        public void Display(int heater)
        {
            if (heater < 100)
            {
                Debug.Log("当前水温" + heater + "水已经快烧开了");
            }
            else
            {
                Debug.Log("当前水温" + heater + "水已经烧开了");
            }
        }

        private void Update()
        {

            Water++;

            if (Water>90&&Water<102)
            {
                WaterHeater wh = new WaterHeater(CallPolice);
                WaterEvent += CallPolice;
                WaterEvent += Display;
                WaterEvent(Water);
            }
            else 
            {
                Debug.Log("温度高于102度");
            }



        }



        //学习中。。。。。。。。。。。
        delegate void Morning(string s);

         void  EnglishGreeting(string name)
        {
            Debug.Log("Hello,GoodMorning"+name);

        }

        void ChineseGreeting(string name)
        {
            Debug.Log("你好，早上好"+name);
        }

        void GreetPeson(string name,Morning make)
        {
            make(name);

        }
        private void Start()
        {
            GreetPeson("张三",ChineseGreeting);
            GreetPeson("zhangsan", EnglishGreeting);
        }



        int num = 10;
        int Person(int a)
        {
            num += a;
            Debug.Log("person__________"+num );
            return num;
        }

        int  Person2(int b)
        {
            num *= b;
            Debug.Log("person2__________" + num);
            return num;
        }
        int Person3()
        {
            return num;
        }


        private void Start()
        {
            CubeName cn2;

            CubeName cn = new CubeName(Person);

            CubeName cn1 = new CubeName(Person2);

            cn2 = cn;
            cn2 += cn1;
            cn2(5);
            Debug.Log("Person______"+Person3());
        }
        */

    /*  文件的输入与输出
   //private void Start()
   //{

   //        string [] name = new string[] { "buzhihua", "26" };
   //        StreamWriter sw = new StreamWriter("C:/textIO.txt");

   //        for (int i=0; i<name.Length;i++)
   //    {

   //        sw.WriteLine(name[i]);
   //    }
   //    sw.Close();
   //    try
   //    {
   //        // 创建一个 StreamReader 的实例来读取文件 
   //        // using 语句也能关闭 StreamReader
   //        using (StreamReader sr = new StreamReader("C:/textIO.txt"))
   //        {
   //            string line;

   //            // 从文件读取并显示行，直到文件的末尾 
   //            while ((line = sr.ReadLine()) != null)
   //            {
   //                Debug.Log(line);
   //            }
   //        }
   //    }
   //    catch (Exception e)
   //    {
   //        // 向用户显示出错消息
   //        Debug.Log("The file could not be read:");
   //        Debug.Log(e.Message);
   //    }
   //}






    //private void Start()
    //{

    //    try
    //    {

    //        StreamReader sr = new StreamReader("C:/textIO.txt");
    //        Debug.Log(sr.ReadLine());
    //        string s = sr.ReadLine();
    //        Debug.Log("s+++++++++++" + s);
    //        sr.Close();
    //    }

    //    catch(Exception e)
    //    {

    //        Debug.Log(e.Message);
    //    }
        //try
        //{
        //    // 创建一个 StreamReader 的实例来读取文件 
        //    // using 语句也能关闭 StreamReader
        //    using (StreamReader sr = new StreamReader("c:/textIO.txt"))
        //    {
        //        string line;

        //        // 从文件读取并显示行，直到文件的末尾 
        //        while ((line = sr.ReadLine()) != null)
        //        {
        //           Debug.Log(line);
        //        }
        //    }
        //}
        //catch (Exception e)
        //{
        //    // 向用户显示出错消息
        //    Debug.Log("The file could not be read:");
        //    Debug.Log(e.Message);
        //}

        //  sr.Close();
    }

    */



    /*结构体 struct 
     * //结构体与类的区别
     * 1.结构体中声明的字段无法赋予初始值，类可以
     * 2.结构是值类型，他在栈中分配空间； 类是引用类型，他在堆中分配空间，栈空间小，访问速度快
    struct Person
    {
        public string Name;
        public int Age;
        public double Height;
        public  void GetPerson(string name,int age,double height)
        {

            Name = name;
            Age = age;
            Height = height;

        }
    }

    void Start()
    {
        Person p = new Person();
        p.GetPerson("张三",25,1.75f);
        Debug.Log(p.Name+     p.Age+        p.Height);
    }
    */


    /*string 类中有多个方法
     * 1	public static int Compare( string strA, string strB )
              比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。该方法区分大小写。
       2	public static int Compare( string strA, string strB, bool ignoreCase )
              比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。但是，如果布尔参数为真时，该方法不区分大小写。
       3	public static string Concat( string str0, string str1 )
               连接两个 string 对象。
       4	public static string Concat( string str0, string str1, string str2 )
               连接三个 string 对象。
       5	public static string Concat( string str0, string str1, string str2, string str3 )
               连接四个 string 对象。
       6	public bool Contains( string value )
               返回一个表示指定 string 对象是否出现在字符串中的值。
       7	public static string Copy( string str )
               创建一个与指定字符串具有相同值的新的 String 对象。
       8	public void CopyTo( int sourceIndex, char[] destination, int destinationIndex, int count )
               从 string 对象的指定位置开始复制指定数量的字符到 Unicode 字符数组中的指定位置。
       9	public bool EndsWith( string value )
              判断 string 对象的结尾是否匹配指定的字符串。
      10	public bool Equals( string value )
              判断当前的 string 对象是否与指定的 string 对象具有相同的值。
      11	public static bool Equals( string a, string b )
              判断两个指定的 string 对象是否具有相同的值。
      12	public static string Format( string format, Object arg0 )
              把指定字符串中一个或多个格式项替换为指定对象的字符串表示形式。
      13	public int IndexOf( char value )
              返回指定 Unicode 字符在当前字符串中第一次出现的索引，索引从 0 开始。
      14	public int IndexOf( string value )
              返回指定字符串在该实例中第一次出现的索引，索引从 0 开始。
      15	public int IndexOf( char value, int startIndex )
              返回指定 Unicode 字符从该字符串中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。
      16	public int IndexOf( string value, int startIndex )
              返回指定字符串从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。
      17	public int IndexOfAny( char[] anyOf )
              返回某一个指定的 Unicode 字符数组中任意字符在该实例中第一次出现的索引，索引从 0 开始。
      18	public int IndexOfAny( char[] anyOf, int startIndex )
              返回某一个指定的 Unicode 字符数组中任意字符从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。
      19	public string Insert( int startIndex, string value )
              返回一个新的字符串，其中，指定的字符串被插入在当前 string 对象的指定索引位置。
      20	public static bool IsNullOrEmpty( string value )
              指示指定的字符串是否为 null 或者是否为一个空的字符串。
      21	public static string Join( string separator, string[] value )
              连接一个字符串数组中的所有元素，使用指定的分隔符分隔每个元素。
      22	public static string Join( string separator, string[] value, int startIndex, int count )
              连接接一个字符串数组中的指定位置开始的指定元素，使用指定的分隔符分隔每个元素。
      23	public int LastIndexOf( char value )
              返回指定 Unicode 字符在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。
      24	public int LastIndexOf( string value )
              返回指定字符串在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。
      25	public string Remove( int startIndex )
              移除当前实例中的所有字符，从指定位置开始，一直到最后一个位置为止，并返回字符串。
      26	public string Remove( int startIndex, int count )
              从当前字符串的指定位置开始移除指定数量的字符，并返回字符串。
      27	public string Replace( char oldChar, char newChar )
              把当前 string 对象中，所有指定的 Unicode 字符替换为另一个指定的 Unicode 字符，并返回新的字符串。
      28	public string Replace( string oldValue, string newValue )
              把当前 string 对象中，所有指定的字符串替换为另一个指定的字符串，并返回新的字符串。
      29	public string[] Split( params char[] separator )
              返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。
      30	public string[] Split( char[] separator, int count )
              返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。int 参数指定要返回的子字符串的最大数目。
      31	public bool StartsWith( string value )
              判断字符串实例的开头是否匹配指定的字符串。
      32	public char[] ToCharArray()
              返回一个带有当前 string 对象中所有字符的 Unicode 字符数组。
      33	public char[] ToCharArray( int startIndex, int length )
              返回一个带有当前 string 对象中所有字符的 Unicode 字符数组，从指定的索引开始，直到指定的长度为止。
      34	public string ToLower()
              把字符串转换为小写并返回。
      35	public string ToUpper()
             把字符串转换为大写并返回。
      36	public string Trim()
             移除当前 String 对象中的所有前导空白字符和后置空白字符。
                                      上面的方法列表并不详尽，请访问 MSDN 库，查看完整的方法列表和 String 类构造函数。
    string s1 = "Bu";
    string s2 = "BuZhiHua";

    private void Start()
    {
         if (string.Compare(s1,s2)==0)
        {
            print(121212);

        }
        else
        {

            print(212121);
        }
    }
    */
    /* 可空类型
    // Null合并运算符（？？）
    // 相似于三元运算符     运用时 成员变量后面加上 ？？    比较时 如果第一个值为空 那么返回第二个操作值，如果第一个不为空，那么返回第一个值
    int? i=null;
    int? c = 5;
    double temp;
    private void Start()
    {
         temp = i ?? 3.14f;
        print(temp);
        temp = c ?? 3.11f;
        print(temp);
    }




    // C#的单问号 
    // ？ 单问号用于int double bool 等无法赋值为null 的数据类型进行null的赋值;
    int? ii;
    int? i = 4;
    double?  d=new double?();
    bool? boola=new bool?();
    private void Start()
    {
        print(ii);
        print(i);
        print(d);
        print(boola);
    }
    */
    /*C#方法

    // 输出传递参数
    // 输出传递参数 会把方法里面的值传给自己，其他和引用传递相似
     void Tast4(out int a, out int b)
    {
        int temp=1;
        a = temp ;
        b = a;
    }

    private void Start()
    {
        int x = 10;
        int y = 20;
        Tast4(out x, out y);
        print("x" + x + "y" + y);
    }


     //按引用传递参数
     // 引用参数是一个对变量的内存位置的引用，引用参数和值参数的不同是，引用参数不会有一个新的储存位置，在C#中，使用ref 关键字来声明引用参数
    void Tast4( ref int a,ref  int b)
    {
        int temp;
        temp = a;
        a = b;
        b = temp;
    }

    private void Start()
    {
        int x = 10;
        int y = 20;
        Tast4(ref x,ref  y);
        print("x" + x + "y" + y);
    }

    //按值传递参数
     // 这是参数传递的默认方式，当调用一个方法时 ，会给每个值参数创建一个新的储存位置，实际参数的值会复制给形参，实参和形参使用的是两个不同内存中的值。所以，形参的值发生改变，不会影响实参，从而保证实参数据不会更改
       void  Tast4(int a, int b)
        {
            int temp;
            temp = a;
            a = b;
            b = temp;
        }

        private void Start()
        {
            int x = 10;
            int y = 20;
            Tast4(x, y);
            print("x"+x+"y"+ y);
        }
        */


    /*递归  阶乘
        //递归  阶乘
        public int factorial(int num)
        {
            int result;

            if (num==1)
            {
                return 1;
            }
            else
            {
                result = factorial(num-1)*num;
                return result;
            }
        }

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.A))
            {
                print(factorial(3));

            }
            if (Input.GetKeyDown(KeyCode.B))
            {
                print(factorial(7));
            }
        }
        */

    /* foreach循环
        //foreach循环

         int[] ForEach = new int[] { 1, 3, 4, 5, 6, 1, 2 };

        private void Start()
        {
            foreach (int arry in ForEach)
            {
                print(arry);
            }
        }
        */


    //三元运算符
    /*
      下面是阶乘的递归算法
     if (Input.GetKeyDown(KeyCode.A))
        {
            int i = c(0);
            print(i);
        }
        if (Input.GetKeyDown(KeyCode.B))
        {
            int q= c(15);
            print(q);
        }
    int c(int v)
    {
       return  v > 1 ? 20 : 10;

    }



     常规用法
        if (Input.GetKeyDown(KeyCode.A))
        {
            int c = 10;
            int b = (c == 10) ? 20 : 1;
            print("第一个"+b);
        }
        if (Input.GetKeyDown(KeyCode.B))
        {
            int c = 1;
            int b = (c == 10) ? 20 : 1;
            print("第二个"+b);
        }

    */
}
rp