第一部分：C#语言基础

绝地灬酷狼 2021-06-24 16:10 499阅读 0赞

## 第1章 C\#类型基础 ##

C\#中的两种类型：值类型和引用类型

#### 1.1 值类型和引用类型 ####

值类型包括了结构和枚举，引用类型则包括了类、接口、委托等。还有一种特殊的值类型，称为简单类型（Simple Type），比如byte，int等。

#### 1.2 对象判等 ####

#### 1.3 对象复制 ####

###### 1.3.1 浅度复制 ######

浅度复制和深度复制是以如何复制对象的成员来区分的。  
  浅度复制结果就是：新对象的引用成员和复制对象的引用成员指向了同一个对  
象。

###### 1.3.2 深度 ######

深度复制就是将引用成员指向的对象也进行复制。实际的过程是创建新的引用成员指向的对象，然后复制对象中所包含的数据。

## 第2章 C\#中的泛型 ##

#### 2.1 理解泛型 ####

###### 2.1.1 为什么要有泛型 ######

以下是一个类里面定一个一个普通方法和一个泛型方法，泛型的有点无疑是简洁了代码。  
提供冒泡排序的类:

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace SortHelper
    {
        //int 类型
        public class BubbleSortHelper
        {
            public int[] BubbleSortIntArray(int[] intArray)
            {
                int[] array = new int[intArray.Count()];
                if (intArray.Count() == 0)
                {
                    return array;
                }
                int length = intArray.Length;
                int temp = 0;
                for (int i = 0; i < length - 1; i++)//冒泡排序，两两比较，小的在前，大的在后
                {
                    for (int j = 0; j < length - 1 - i; j++)
                    {
                        if (intArray[j] > intArray[j + 1])
                        {
                            temp = intArray[j];
                            intArray[j] = intArray[j + 1];
                            intArray[j + 1] = temp;
                        }
                    }
                }
    
                array = intArray;
                return array;
            }
            /// <summary>
            /// fan泛型
            /// </summary>
            /// <param name="Array"></param>
            /// <returns></returns>
            public T[] BubbleSortTArray<T>(T[] Array) where T : IComparable
            {
                T[] array = new T[Array.Count()];
                if (Array.Count() == 0)
                {
                    return array;
                }
                int length = Array.Length;
                T temp;
                for (int i = 0; i < length - 1; i++)//冒泡排序，两两比较，小的在前，大的在后
                {
                    for (int j = 0; j < length - 1 - i; j++)
                    {
                        if (Array[j].CompareTo(Array[j + 1]) > 0)
                        {
                            temp = Array[j];
                            Array[j] = Array[j + 1];
                            Array[j + 1] = temp;
                        }
                    }
                }
    
                array = Array;
                return array;
            }
    
    
            public int CompareTo(object obj)
            {
                throw new NotImplementedException();
            }
        }
    }

在主方法调用一下：

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace SortHelper
    {
        class Program
        {
            static void Main(string[] args)
            {
                //调用冒泡排序的int 数组
                int[] testArray = { 1, 3, 9, 4, 5, 3, 2, 5, 4, 5, 8, 8, 8 };
                BubbleSortHelper bsh = new BubbleSortHelper();
                int[] result = bsh.BubbleSortTArray(testArray);
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < result.Count(); i++)
                {
                    sb.Append(result[i] + ",");
                }
                sb.Remove(sb.Length - 1, 1);
                Console.WriteLine(sb);
    
                //使用泛型方法
                char[] TArray = { 'a','f','b' };
                BubbleSortHelper bsh1 = new BubbleSortHelper();
                char[] result1 = bsh1.BubbleSortTArray<char>(TArray);
                StringBuilder sb1 = new StringBuilder();
                for (int i = 0; i < result1.Count(); i++)
                {
                    sb1.Append(result1[i] + ",");
                }
                sb1.Remove(sb1.Length - 1, 1);
                Console.WriteLine(sb1);
    
                Console.ReadLine();
            }
        }
    }

执行结果：

![2789632-967d78097e27eabf.png][]

冒泡排序使用泛型

小技巧：当程序大量使用泛型类型的时候，或者泛型的类型参数个数比较多的时候，代码可能看着比较散乱，不够简洁。此时可以使用using指令来声明一个代表着泛型类型的集合：

using IntList = List<int>;
    class Program {
    static void Main(string[] args) {
    IntList list = new IntList();
    list.Add(100);
    // 其余代码略
    }
    }

这样看上去简单多了，但是还有一个问题，就是不能跨文件使用，换而言之，在同一项目同一命名空间下的另一个文件中，无法使用这个IntList集合。此时，可以采用继承泛型类的方式来解决，例如声明下面这样一个类：

public class IntList :List<int> {}

## 第3章 C\#中的委托和事件 ##

#### 3.1 理解委托 ####

###### 3.1.1 将方法作为方法的 ######

委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使程序具有更好的可扩展性。

#### 3.2 事件的由来 ####

使用事件不仅能获得比委托更好的封装性，还能限制含有事件的类型的能力。

[2789632-967d78097e27eabf.png]: /images/20210615/a1eadd209d8142b69267fdc51e91584f.png