C#高级内容笔记

最新推荐文章于 2024-04-22 22:25:32 发布

AndySoeng

最新推荐文章于 2024-04-22 22:25:32 发布

阅读量292

点赞数

分类专栏： C#

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/qqagsd155451/article/details/104350739

版权

C# 专栏收录该内容

9 篇文章 4 订阅

订阅专栏

这里写目录标题

C#高级内容笔记

C#高级内容笔记

2018年12月19日

委托

C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。
委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。
定义一个委托，准备相应的调用方法。注意：定义一个委托相当于定义一个新类，所有可以定义类的地方都可以定义委托。

下面例子对技能进行委托，故英雄不需在意具体调用哪个技能:

using System;

public class Program
{
    public static void Main (string[] args)
    {
        Hero hero1 = new Hero();
        hero1.q = Skills.Skill1;

        Hero hero2 = new Hero();
        hero2.q = Skills.Skill2;

        Hero hero3 = new Hero();
        hero3.q = Skills.Skill3;

        hero1.q();
        hero2.q();
        hero3.q();

        Console.ReadKey();
    }
}

public class Hero
{
    //声明了委托类型后，委托对象不必须使用 new 关键字来创建。
    //public SkillDlegate q=new SkillDlegate();
    public SkillDlegate q;
}

//委托声名必须要和委托对象返回值、参数相同
public delegate void SkillDlegate();

public static class Skills
{
    public static void Skill1()
    {
        Console.WriteLine("Skill1 Invoke");
    }

    public static void Skill2()
    {
        Console.WriteLine("Skill2 Invoke");
    }

    public static void Skill3()
    {
        Console.WriteLine("Skill3 Invoke");
    }
}

委托的多播（Multicasting of a Delegate）

委托对象可使用 +运算符进行合并。一个合并委托调用它所合并的两个委托。只有相同类型的委托可被合并。- 运算符可用于从合并的委托中移除组件委托。
使用委托的这个有用的特点，可以创建一个委托被调用时要调用的方法的调用列表。这被称为委托的 多播（multicasting ，也叫组播。下面的程序演示了委托的多播：

using System;

public delegate void TestDelegate();
public class Program
{
    static void Main(string[] args)
    {
        TestDelegate td = MethodA;
        td += MethodB;
        td -= MethodA;
        td();
        Console.ReadLine();
    }

    public static void MethodA()
    {
        Console.WriteLine("MethodA Invoke");
    }
    public static void MethodB()
    {
        Console.WriteLine("MethodB Invoke");
    }
}

委托（Delegate）的用途

下面的实例演示了委托的用法。委托 printString 可用于引用带有一个字符串作为输入的方法，并不返回任何东西。

可以使用这个委托来调用两个方法，第一个把字符串打印到控制台，第二个把字符串打印到文件：

using System;
using System.IO;

namespace DelegateApplication
{
   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();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

The String is: Hello World

使用委托进行回调

设想：
Person类（包含DownloadData和DealWithData方法）中实例化一个DownloadTool类（包含DownloadData方法）对象，当Person对象使用DownloadData方法调用DownloadTool中DownloadData的下载完成后用DealWithData通知Person对象。
若是在DownloadTool类定义一个Person对象，后期代码进行拓展（新的类进行下载），代码则需大改。使用委托进行回调则只需在新类中指定下载完成后的处理方式即可。

解决：
声明一个委托public delegate void DownloadComplete(string result);
在DownloadTool中定义一个委托对象public DownloadComplete complete;
在DownloadTool中DownloadData方法下载完成后使用complete(“hello world”);
在Person类的DownloadData方法中指定下载完成后的处理方式tool.complete=DealWithData;

2018年12月20日

匿名函数、Lambda表达式

没有名称只有主体的方法叫做匿名函数，可用 delegate 代替方法名。
委托可以通过匿名方法调用，也可以通过命名方法调用，即，通过向委托对象传递方法参数。

using System;
public class Program
{
    delegate void TestDelegate();
    delegate int TestDelegate1(int x, int y);
    delegate int TestDelegate2(int x);
    static void Main(string[] args)
    {
        //匿名方法：没有方法名的方法
        //可用关键字delegate代替方法名
        TestDelegate td = delegate () { Console.WriteLine("hello world"); };
        TestDelegate1 td1 = delegate (int x, int y) { return x + y; };
        int result = td1(1, 1);
        Console.WriteLine(result);

        //Lambda表达式
        //=> Lambda运算符，读作gose to
        TestDelegate td3 = () => { Console.WriteLine("hello world"); };
        TestDelegate1 td4 = (int x, int y) => { return x + y; };
        //简化1：如果Lambda方法体中只有一个返回值，那么大括号和return可以省略
        td4 = (int x, int y) => x + y;
        //简化2：在Lambda参数列表中，参数类型可以省略
        td4 = (x, y) => x + y;
        //简化3：在Lambda中，如果参数列表只有一个参数，那么参数列表的小括号可以省略
        TestDelegate2 td5 = x => x * x;

        int result1 = td5(10);
        Console.WriteLine(result1);
        Console.ReadLine();
    }
}

事件（Event）

using System;

//订阅器（subscriber） 是一个接受事件并提供事件处理程序的对象。
//在发布器（publisher）类中的委托调用订阅器（subscriber）类中的方法（事件处理程序）。
public class Publisher
{
    //声明该事件的委托类型
    public delegate void PublisherDelegate();
    //声明一个基于委托的事件本身
    public event PublisherDelegate PublisherEvent;

    int value = 10;
    public void PublisherTrigger()
    {
        if (PublisherEvent != null)
        {
            PublisherEvent();
        }
        else
        {
            Console.WriteLine("event not fire");
            Console.ReadKey();
        }
    }
 
    public Publisher()
    {
        int n = 5;
        TestInPublisher(n);
    }

    public void TestInPublisher(int n)
    {
        if (value != n)
        {
            value = n;
            PublisherTrigger();
        }
    }
    
}

//订阅器（subscriber） 是一个接受事件并提供事件处理程序的对象。
//在发布器（publisher）类中的委托调用订阅器（subscriber）类中的方法（事件处理程序）。
public class Subscriber
{
    public void SubscriberTrigger()
    {   
        Console.WriteLine("event fire");
        Console.ReadLine();/***回车继续***/
    }

}

public class Program
{
    static void Main(string[] args)
    {
        Publisher p = new Publisher();/* 实例化对象,第一次没有触发事件 */

        //主体函数中根据需求组装事件，组装过程类似委托多播
        p.PublisherEvent += new Publisher.PublisherDelegate(Test); //并不会触发订阅器
        p.PublisherEvent += new Publisher.PublisherDelegate(new Subscriber().SubscriberTrigger); //触发订阅器
 
        p.TestInPublisher(20);
        p.TestInPublisher(15);
        // 执行操作，以触发事件
        p.PublisherTrigger();
        
        Console.ReadLine();
    }

    public static void Test()
    {
        Console.WriteLine("我是Proram中的Test，在主体Main函数中");
    }
}

结果为：

event not fire
我是Proram中的Test，在主体Main函数中     //p.PublisherEvent += new Publisher.PublisherDelegate(Test); //并不会触发订阅器
event fire                 //p.PublisherEvent += new Publisher.PublisherDelegate(new Subscriber().SubscriberTrigger); //触发订阅器

我是Proram中的Test，在主体Main函数中
event fire

我是Proram中的Test，在主体Main函数中
event fire

2018年12月21日

不安全代码

当一个代码块使用 unsafe 修饰符标记时，C# 允许在函数中使用指针变量。不安全代码或非托管代码是指使用了指针变量的代码块。

使用指针检索数据值

可以使用 ToString() 方法检索存储在指针变量所引用位置的数据。下面的实例演示了这点：

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

当上面的代码被编译和执行时，它会产生下列结果：

Data is: 20
Data is: 20
Address is: 77128984

传递指针作为方法的参数

可以向方法传递指针变量作为方法的参数。下面的实例说明了这点：

using System;
namespace UnsafeCodeApplication
{
   class TestPointer
   {
      public unsafe void swap(int* p, int *q)
      {
         int temp = *p;
         *p = *q;
         *q = temp;
      }

      public unsafe static void Main()
      {
         TestPointer p = new TestPointer();
         int var1 = 10;
         int var2 = 20;
         int* x = &var1;
         int* y = &var2;
         
         Console.WriteLine("Before Swap: var1:{0}, var2: {1}", var1, var2);
         p.swap(x, y);

         Console.WriteLine("After Swap: var1:{0}, var2: {1}", var1, var2);
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Before Swap: var1: 10, var2: 20
After Swap: var1: 20, var2: 10

使用指针访问数组元素

在 C# 中，数组名称和一个指向与数组数据具有相同数据类型的指针是不同的变量类型。例如，int *p 和 int[] p 是不同的类型。可以增加指针变量 p，因为它在内存中不是固定的，但是数组地址在内存中是固定的，所以不能增加数组 p。

因此，如果需要使用指针变量访问数组数据，可以像通常在 C 或 C++ 中所做的那样，使用 fixed 关键字来固定指针。

下面的实例演示了这点：

using System;
namespace UnsafeCodeApplication
{
   class TestPointer
   {
      public unsafe static void Main()
      {
         int[]  list = {10, 100, 200};
         fixed(int *ptr = list)

         /* 显示指针中数组地址 */
         for ( int i = 0; i < 3; i++)
         {
            Console.WriteLine("Address of list[{0}]={1}",i,(int)(ptr + i));
            Console.WriteLine("Value of list[{0}]={1}", i, *(ptr + i));
         }
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Address of list[0] = 31627168
Value of list[0] = 10
Address of list[1] = 31627172
Value of list[1] = 100
Address of list[2] = 31627176
Value of list[2] = 200

在unsafe不安全环境中，可以通过stackalloc在堆栈上分配内存，因为在堆栈上分配的内存不受内存管理器管理，因此其相应的指针不需要固定。

static unsafe void Main(string[] args)
{
  int *ptr = stackalloc int[1] ;
}

编译不安全代码

为了编译不安全代码，必须切换到命令行编译器指定 /unsafe 命令行。

例如，为了编译包含不安全代码的名为 prog1.cs 的程序，需在命令行中输入命令：

csc /unsafe prog1.cs

如果使用的是 Visual Studio IDE，那么需要在项目属性中启用不安全代码。

步骤如下：

通过双击资源管理器（Solution Explorer）中的属性（properties）节点，打开项目属性（project properties）。
点击 Build 标签页。
选择选项"Allow unsafe code"。

泛型（Generic）

泛型（Generic）允许延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。
在封装公共组件的时候，很多时候类/方法不需要关注调用者传递的实体是"什么"，这个时候就可以使用泛型。
通过数据类型的替代参数编写类或方法的规范。当编译器遇到类的构造函数或方法的函数调用时，它会生成代码来处理指定的数据类型。下面这个简单的实例将有助于理解这个概念：

using System;
using System.Collections.Generic;

namespace GenericApplication
{
    public class MyGenericArray<T>
    {
        private T[] array;
        public MyGenericArray(int size)
        {
            array = new T[size + 1];
        }
        public T getItem(int index)
        {
            return array[index];
        }
        public void setItem(int index, T value)
        {
            array[index] = value;
        }
    }
           
    class Tester
    {
        static void Main(string[] args)
        {
            // 声明一个整型数组
            MyGenericArray<int> intArray = new MyGenericArray<int>(5);
            // 设置值
            for (int c = 0; c < 5; c++)
            {
                intArray.setItem(c, c*5);
            }
            // 获取值
            for (int c = 0; c < 5; c++)
            {
                Console.Write(intArray.getItem(c) + " ");
            }
            Console.WriteLine();
            // 声明一个字符数组
            MyGenericArray<char> charArray = new MyGenericArray<char>(5);
            // 设置值
            for (int c = 0; c < 5; c++)
            {
                charArray.setItem(c, (char)(c+97));
            }
            // 获取值
            for (int c = 0; c < 5; c++)
            {
                Console.Write(charArray.getItem(c) + " ");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

0 5 10 15 20
a b c d e

泛型（Generic）的特性

使用泛型是一种增强程序功能的技术，具体表现在以下几个方面：

它有助于最大限度地重用代码、保护类型的安全以及提高性能。
可以创建泛型集合类。.NET 框架类库在 System.Collections.Generic 命名空间中包含了一些新的泛型集合类。可以使用这些泛型集合类来替代 System.Collections 中的集合类。
可以创建自己的泛型接口、泛型类、泛型方法、泛型事件和泛型委托。
可以对泛型类进行约束以访问特定数据类型的方法。
关于泛型数据类型中使用的类型的信息可在运行时通过使用反射获取。

泛型（Generic）方法

通过类型参数声明泛型方法。下面的程序说明了这个概念：

using System;
using System.Collections.Generic;

namespace GenericMethodAppl
{
    class Program
    {
        static void Swap<T>(ref T lhs, ref T rhs)
        {
            T temp;
            temp = lhs;
            lhs = rhs;
            rhs = temp;
        }
        static void Main(string[] args)
        {
            int a, b;
            char c, d;
            a = 10;
            b = 20;
            c = 'I';
            d = 'V';

            // 在交换之前显示值
            Console.WriteLine("Int values before calling swap:");
            Console.WriteLine("a = {0}, b = {1}", a, b);
            Console.WriteLine("Char values before calling swap:");
            Console.WriteLine("c = {0}, d = {1}", c, d);

            // 调用 swap
            Swap<int>(ref a, ref b);
            Swap<char>(ref c, ref d);

            // 在交换之后显示值
            Console.WriteLine("Int values after calling swap:");
            Console.WriteLine("a = {0}, b = {1}", a, b);
            Console.WriteLine("Char values after calling swap:");
            Console.WriteLine("c = {0}, d = {1}", c, d);
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Int values before calling swap:
a = 10, b = 20
Char values before calling swap:
c = I, d = V
Int values after calling swap:
a = 20, b = 10
Char values after calling swap:
c = V, d = I

泛型（Generic）委托
可以通过类型参数定义泛型委托。例如：

delegate T NumberChanger<T>(T n);

下面的实例演示了委托的使用：

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();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Value of Num: 35
Value of Num: 175

2018年12月22日

集合（Collection）

集合（Collection）类是专门用于数据存储和检索的类。这些类提供了对栈（stack）、队列（queue）、列表（list）和哈希表（hash table）的支持。大多数集合类实现了相同的接口。
集合（Collection）类服务于不同的目的，如为元素动态分配内存，基于索引访问列表项等等。这些类创建 Object 类的对象的集合。在 C# 中，Object 类是所有数据类型的基类。

动态数组（ArrayList）

动态数组（ArrayList）代表了可被单独索引的对象的有序集合。
它基本上可以替代一个数组。但是，与数组不同的是，可以使用索引在指定的位置添加和移除项目，动态数组会自动重新调整它的大小。它也允许在列表中进行动态内存分配、增加、搜索、排序各项。

ArrayList 类的方法和属性

下表列出了 ArrayList 类的一些常用的属性：

属性	描述
Capacity	获取或设置 ArrayList 可以包含的元素个数。
Count	获取 ArrayList 中实际包含的元素个数。
IsFixedSize	获取一个值，表示 ArrayList 是否具有固定大小。
IsReadOnly	获取一个值，表示 ArrayList 是否只读。
Item	获取或设置指定索引处的元素。

下表列出了 ArrayList 类的一些常用的方法：

序号	方法名 & 描述
1	public virtual int Add( object value ); 在 ArrayList 的末尾添加一个对象。
2	public virtual void AddRange( ICollection c ); 在 ArrayList 的末尾添加 ICollection 的元素。
3	public virtual void Clear(); 从 ArrayList 中移除所有的元素。
4	public virtual bool Contains( object item ); 判断某个元素是否在 ArrayList 中。
5	public virtual ArrayList GetRange( int index, int count ); 返回一个 ArrayList，表示源 ArrayList 中元素的子集。
6	public virtual int IndexOf(object); 返回某个值在 ArrayList 中第一次出现的索引，索引从零开始。
7	public virtual void Insert( int index, object value ); 在 ArrayList 的指定索引处，插入一个元素。
8	public virtual void InsertRange( int index, ICollection c ); 在 ArrayList 的指定索引处，插入某个集合的元素。
9	public virtual void Remove( object obj ); 从 ArrayList 中移除第一次出现的指定对象。
10	public virtual void RemoveAt( int index ); 移除 ArrayList 的指定索引处的元素。
11	public virtual void RemoveRange( int index, int count ); 从 ArrayList 中移除某个范围的元素。
12	public virtual void Reverse(); 逆转 ArrayList 中元素的顺序。
13	public virtual void SetRange( int index, ICollection c ); 复制某个集合的元素到 ArrayList 中某个范围的元素上。
14	public virtual void Sort(); 对 ArrayList 中的元素进行排序。
15	public virtual void TrimToSize(); 设置容量为 ArrayList 中元素的实际个数。

实例

下面的实例演示了动态数组（ArrayList）的概念：

using System;
using System.Collections;

namespace CollectionApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList al = new ArrayList();

            Console.WriteLine("Adding some numbers:");
            al.Add(45);
            al.Add(78);
            al.Add(33);
            al.Add(56);
            al.Add(12);
            al.Add(23);
            al.Add(9);
            
            Console.WriteLine("Capacity: {0} ", al.Capacity);
            Console.WriteLine("Count: {0}", al.Count);
                      
            Console.Write("Content: ");
            foreach (int i in al)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
            Console.Write("Sorted Content: ");
            al.Sort();
            foreach (int i in al)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Adding some numbers:
Capacity: 8
Count: 7
Content: 45 78 33 56 12 23 9
Content: 9 12 23 33 45 56 78

哈希表（Hashtable）

Hashtable 类代表了一系列基于键的哈希代码组织起来的键/值对。它使用键来访问集合中的元素。

当使用键访问元素时，则使用哈希表，而且可以识别一个有用的键值。哈希表中的每一项都有一个键/值对。键用于访问集合中的项目。

Hashtable 类的方法和属性

下表列出了 Hashtable 类的一些常用的属性：

属性	描述
Count	获取 Hashtable 中包含的键值对个数。
IsFixedSize	获取一个值，表示 Hashtable 是否具有固定大小。
IsReadOnly	获取一个值，表示 Hashtable 是否只读。
Item	获取或设置与指定的键相关的值。
Keys	获取一个 ICollection，包含 Hashtable 中的键。
Values	获取一个 ICollection，包含 Hashtable 中的值。

下表列出了 Hashtable 类的一些常用的方法：

序号	方法名 & 描述
1	public virtual void Add( object key, object value ); 向 Hashtable 添加一个带有指定的键和值的元素。
2	public virtual void Clear(); 从 Hashtable 中移除所有的元素。
3	public virtual bool ContainsKey( object key ); 判断 Hashtable 是否包含指定的键。
4	public virtual bool ContainsValue( object value ); 判断 Hashtable 是否包含指定的值。
5	public virtual void Remove( object key ); 从 Hashtable 中移除带有指定的键的元素。

实例

下面的实例演示了哈希表（Hashtable）的概念：

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();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

007: Ritesh Saikia
004: Mausam Benazir Nur
005: M. Amlan
008: Nuha Ali
002: Abida Rehman
003: Joe Holzner
001: Zara Ali
006: M. Arif

排序列表（SortedList）

SortedList 类代表了一系列按照键来排序的键/值对，这些键值对可以通过键和索引来访问。

排序列表是数组和哈希表的组合。它包含一个可使用键或索引访问各项的列表。如果使用索引访问各项，则它是一个动态数组（ArrayList），如果使用键访问各项，则它是一个哈希表（Hashtable）。集合中的各项总是按键值排序。

SortedList 类的方法和属性

下表列出了 SortedList 类的一些常用的属性：

属性	描述
Capacity	获取或设置 SortedList 的容量。
Count	获取 SortedList 中的元素个数。
IsFixedSize	获取一个值，表示 SortedList 是否具有固定大小。
IsReadOnly	获取一个值，表示 SortedList 是否只读。
Item	获取或设置与 SortedList 中指定的键相关的值。
Keys	获取 SortedList 中的键。
Values	获取 SortedList 中的值。

下表列出了 SortedList 类的一些常用的方法：

序号	方法名 & 描述
1	public virtual void Add( object key, object value ); 向 SortedList 添加一个带有指定的键和值的元素。
2	public virtual void Clear(); 从 SortedList 中移除所有的元素。
3	public virtual bool ContainsKey( object key ); 判断 SortedList 是否包含指定的键。
4	public virtual bool ContainsValue( object value ); 判断 SortedList 是否包含指定的值。
5	public virtual object GetByIndex( int index ); 获取 SortedList 的指定索引处的值。
6	public virtual object GetKey( int index ); 获取 SortedList 的指定索引处的键。
7	public virtual IList GetKeyList(); 获取 SortedList 中的键。
8	public virtual IList GetValueList(); 获取 SortedList 中的值。
9	public virtual int IndexOfKey( object key ); 返回 SortedList 中的指定键的索引，索引从零开始。
10	public virtual int IndexOfValue( object value ); 返回 SortedList 中的指定值第一次出现的索引，索引从零开始。
11	public virtual void Remove( object key ); 从 SortedList 中移除带有指定的键的元素。
12	public virtual void RemoveAt( int index ); 移除 SortedList 的指定索引处的元素。
13	public virtual void TrimToSize(); 设置容量为 SortedList 中元素的实际个数。

实例

下面的实例演示了排序列表（SortedList）的概念：

using System;
using System.Collections;

namespace CollectionsApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         SortedList sl = new SortedList();

         sl.Add("001", "Zara Ali");
         sl.Add("002", "Abida Rehman");
         sl.Add("003", "Joe Holzner");
         sl.Add("004", "Mausam Benazir Nur");
         sl.Add("005", "M. Amlan");
         sl.Add("006", "M. Arif");
         sl.Add("007", "Ritesh Saikia");

         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]);
         }
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

001: Zara Ali
002: Abida Rehman
003: Joe Holzner
004: Mausam Banazir Nur
005: M. Amlan 
006: M. Arif
007: Ritesh Saikia
008: Nuha Ali

堆栈（Stack）

堆栈（Stack）代表了一个后进先出的对象集合。当需要对各项进行后进先出的访问时，则使用堆栈。当在列表中添加一项，称为推入元素，当从列表中移除一项时，称为弹出元素。

Stack 类的方法和属性

下表列出了 Stack 类的一些常用的属性：

属性	描述
Count	获取 Stack 中包含的元素个数。

下表列出了 Stack 类的一些常用的方法：

序号	方法名 & 描述
1	public virtual void Clear(); 从 Stack 中移除所有的元素。
2	public virtual bool Contains( object obj ); 判断某个元素是否在 Stack 中。
3	public virtual object Peek(); 返回在 Stack 的顶部的对象，但不移除它。
4	public virtual object Pop(); 移除并返回在 Stack 的顶部的对象。
5	public virtual void Push( object obj ); 向 Stack 的顶部添加一个对象。
6	public virtual object[] ToArray(); 复制 Stack 到一个新的数组中。

实例

下面的实例演示了堆栈（Stack）的使用：

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 + " "); 
            }
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Current stack: 
W G M A
The next poppable value in stack: H
Current stack: 
H V W G M A
Removing values
Current stack: 
G M A

队列（Queue）

队列（Queue）代表了一个先进先出的对象集合。当需要对各项进行先进先出的访问时，则使用队列。当在列表中添加一项，称为入队，当从列表中移除一项时，称为出队。

Queue 类的方法和属性

下表列出了 Queue 类的一些常用的属性：

属性	描述
Count	获取 Queue 中包含的元素个数。

下表列出了 Queue 类的一些常用的方法：

序号	方法名 & 描述
1	public virtual void Clear(); 从 Queue 中移除所有的元素。
2	public virtual bool Contains( object obj ); 判断某个元素是否在 Queue 中。
3	public virtual object Dequeue(); 移除并返回在 Queue 的开头的对象。
4	public virtual void Enqueue( object obj ); 向 Queue 的末尾添加一个对象。
5	public virtual object[] ToArray(); 复制 Queue 到一个新的数组中。
6	public virtual void TrimToSize(); 设置容量为 Queue 中元素的实际个数。

实例

下面的实例演示了队列（Queue）的使用：

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();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Current queue: 
A M G W 
Current queue: 
A M G W V H 
Removing values
The removed value: A
The removed value: M

点阵列（BitArray）

BitArray 类管理一个紧凑型的位值数组，它使用布尔值来表示，其中 true 表示位是开启的（1），false 表示位是关闭的（0）。

当需要存储位，但是事先不知道位数时，则使用点阵列。可以使用整型索引从点阵列集合中访问各项，索引从零开始。

BitArray 类的方法和属性

下表列出了 BitArray 类的一些常用的属性：

属性	描述
Count	获取 BitArray 中包含的元素个数。
IsReadOnly	获取一个值，表示 BitArray 是否只读。
Item	获取或设置 BitArray 中指定位置的位的值。
Length	获取或设置 BitArray 中的元素个数。

下表列出了 BitArray 类的一些常用的方法：

序号	方法名 & 描述
1	public BitArray And( BitArray value ); 对当前的 BitArray 中的元素和指定的 BitArray 中的相对应的元素执行按位与操作。
2	public bool Get( int index ); 获取 BitArray 中指定位置的位的值。
3	public BitArray Not(); 把当前的 BitArray 中的位值反转，以便设置为 true 的元素变为 false，设置为 false 的元素变为 true。
4	public BitArray Or( BitArray value ); 对当前的 BitArray 中的元素和指定的 BitArray 中的相对应的元素执行按位或操作。
5	public void Set( int index, bool value ); 把 BitArray 中指定位置的位设置为指定的值。
6	public void SetAll( bool value ); 把 BitArray 中的所有位设置为指定的值。
7	public BitArray Xor( BitArray value ); 对当前的 BitArray 中的元素和指定的 BitArray 中的相对应的元素执行按位异或操作。

实例

下面的实例演示了点阵列（BitArray）的使用：

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();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Bit array ba1: 60 
False False True True True True False False 
Bit array ba2: 13
True False True True False False False False 
Bit array ba3 after AND operation: 12
False False True True False False False False 
Bit array ba3 after OR operation: 61
True False True True False False False False

反射

using System;
using System.Reflection;
//反射：可以通过类名、成员的名字来进行对象的实例化
class Person
{
    public int a;
    private int b;
    public static int c;
    private static int d;

    private Person()
    {
        Console.WriteLine("Person类无参的构造方法被调用");
    }

    private Person(int a, double b, string c)
    {
        Console.WriteLine("Person类有参的构造方法被调用");
    }

    public void ShowA() { }
    private void ShowB() { }
    public static void ShowC() { }
    private static void ShowD() { }
    public int Show(int a, double b)
    {
        return a;
    }
    public double Show(double a, int b)
    {
        return b;
    }
}

class Program
{
    static void Main(string[] args)
    {
        //实例化一个Person对象

        //通过类名来获取一个类型
        //命名空间：如果这个类在一个命名空间中，那么写类型名的时候需要加上命名空间
        //例如：System.Int32
        Type t = Type.GetType("Person");

        //实例化一个对象,默认会使用public权限无参的构造方法来实例化(internal也不行)
        //object obj =Activator.CreateInstance(t);
        //实例化一个对象,如果为true，表示可以匹配任何权限的无参构造方法（反射破单例）
        //object obj = Activator.CreateInstance(t, true);
        //实例化一个对象，是通过public权限的有参的构造方法来实例化
        //object obj = Activator.CreateInstance(t, 3, 3.1f, "hello");
        //实例化一个对象，通过非public权限的有参构造方法
        object obj = Activator.CreateInstance(t, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { 1, 3.1, "hello" }, null);

        /* 
         * BindingFlags:要访问的方法或字段的权限描述，必须要同时具备两个描述
         *      1、要有要访问的成员的访问权限描述
         *      2、要有要访问的成员的归属
         *      BindingFlags.Instance或BindingFlags.Static
         */

        //通过反射访问类中的字段
        //1、访问public权限的，非静态的字段a
        FieldInfo a = t.GetField("a");
        a.SetValue(obj, 1);                 //给t对象的a字段进行赋值，赋值为1
        object aa = a.GetValue(obj);        //获取对象obj的字段a的值

        //2、访问private权限的，费静态的字段b
        FieldInfo b = t.GetField("b", BindingFlags.NonPublic | BindingFlags.Instance);
        b.SetValue(obj, 3);
        object bb = b.GetValue(obj);

        //3、访问public权限的，静态的字段c
        FieldInfo c = t.GetField("c", BindingFlags.Public | BindingFlags.Static);
        c.SetValue(null, 3);        //如果要访问的是一个静态的成员，访问的主体是null
        object cc = c.GetValue(null);

        //4、访问private权限的，静态的字段d
        FieldInfo d = t.GetField("d", BindingFlags.NonPublic | BindingFlags.Static);
        d.SetValue(null, 4);
        object dd = d.GetValue(null);




        //通过反射访问类中的方法
        //1、获取没有参数的方法
        MethodInfo method0 = t.GetMethod("ShowD", BindingFlags.NonPublic | BindingFlags.Static);
        //方法调用，第一个参数：谁在调用方法 第二个参数：调用方法的实参列表
        method0.Invoke(null, null);

        //2、获取有参数有重载的方法
        //Type数组中传要访问的方法的参数列表
        MethodInfo method1 = t.GetMethod("Show", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(int), typeof(double) }, null);

        //第二个参数是实参列表
        //Invoke方法的返回值，就是method1方法的返回值
        object result = method1.Invoke(obj, new object[] { 1, 3.13 });

        Console.WriteLine(result);
        Console.ReadKey();
    }
}

2018年12月23日

多线程

线程被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果应用程序涉及到复杂的和耗时的操作，那么设置不同的线程执行路径往往是有益的，每个线程执行特定的工作。

线程是轻量级进程。一个使用线程的常见实例是现代操作系统中并行编程的实现。使用线程节省了 CPU 周期的浪费，同时提高了应用程序的效率。

到目前为止编写的程序是一个单线程作为应用程序的运行实例的单一的过程运行的。但是，这样子应用程序同时只能执行一个任务。为了同时执行多个任务，它可以被划分为更小的线程。

线程生命周期

线程生命周期开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。

下面列出了线程生命周期中的各种状态：

未启动状态：当线程实例被创建但 Start 方法未被调用时的状况。
就绪状态：当线程准备好运行并等待 CPU 周期时的状况。
不可运行状态：下面的几种情况下线程是不可运行的：
- 已经调用 Sleep 方法
- 已经调用 Wait 方法
- 通过 I/O 操作阻塞
死亡状态：当线程已完成执行或已中止时的状况。

主线程

在 C# 中，System.Threading.Thread 类用于线程的工作。它允许创建并访问多线程应用程序中的单个线程。进程中第一个被执行的线程称为主线程。

当 C# 程序开始执行时，主线程自动创建。使用 Thread 类创建的线程被主线程的子线程调用。可以使用 Thread 类的 CurrentThread 属性访问线程。

下面的程序演示了主线程的执行：

using System;
using System.Threading;

namespace MultithreadingApplication
{
    class MainThreadProgram
    {
        static void Main(string[] args)
        {
            Thread th = Thread.CurrentThread;
            th.Name = "MainThread";
            Console.WriteLine("This is {0}", th.Name);
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

This is MainThread

Thread 类常用的属性和方法

下表列出了 Thread 类的一些常用的属性：

属性	描述
CurrentContext	获取线程正在其中执行的当前上下文。
CurrentCulture	获取或设置当前线程的区域性。
CurrentPrinciple	获取或设置线程的当前负责人（对基于角色的安全性而言）。
CurrentThread	获取当前正在运行的线程。
CurrentUICulture	获取或设置资源管理器使用的当前区域性以便在运行时查找区域性特定的资源。
ExecutionContext	获取一个 ExecutionContext 对象，该对象包含有关当前线程的各种上下文的信息。
IsAlive	获取一个值，该值指示当前线程的执行状态。
IsBackground	获取或设置一个值，该值指示某个线程是否为后台线程。
IsThreadPoolThread	获取一个值，该值指示线程是否属于托管线程池。
ManagedThreadId	获取当前托管线程的唯一标识符。
Name	获取或设置线程的名称。
Priority	获取或设置一个值，该值指示线程的调度优先级。
ThreadState	获取一个值，该值包含当前线程的状态。

下表列出了 Thread 类的一些常用的方法：

序号	方法名 & 描述
1	public void Abort() 在调用此方法的线程上引发 ThreadAbortException，以开始终止此线程的过程。调用此方法通常会终止线程。
2	public static LocalDataStoreSlot AllocateDataSlot() 在所有的线程上分配未命名的数据槽。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
3	public static LocalDataStoreSlot AllocateNamedDataSlot( string name) 在所有线程上分配已命名的数据槽。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
4	public static void BeginCriticalRegion() 通知主机执行将要进入一个代码区域，在该代码区域内线程中止或未经处理的异常的影响可能会危害应用程序域中的其他任务。
5	public static void BeginThreadAffinity() 通知主机托管代码将要执行依赖于当前物理操作系统线程的标识的指令。
6	public static void EndCriticalRegion() 通知主机执行将要进入一个代码区域，在该代码区域内线程中止或未经处理的异常仅影响当前任务。
7	public static void EndThreadAffinity() 通知主机托管代码已执行完依赖于当前物理操作系统线程的标识的指令。
8	public static void FreeNamedDataSlot(string name) 为进程中的所有线程消除名称与槽之间的关联。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
9	public static Object GetData( LocalDataStoreSlot slot ) 在当前线程的当前域中从当前线程上指定的槽中检索值。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
10	public static AppDomain GetDomain() 返回当前线程正在其中运行的当前域。
11	public static AppDomain GetDomainID() 返回唯一的应用程序域标识符。
12	public static LocalDataStoreSlot GetNamedDataSlot( string name ) 查找已命名的数据槽。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
13	public void Interrupt() 中断处于 WaitSleepJoin 线程状态的线程。
14	public void Join() 在继续执行标准的 COM 和 SendMessage 消息泵处理期间，阻塞调用线程，直到某个线程终止为止。此方法有不同的重载形式。
15	public static void MemoryBarrier() 按如下方式同步内存存取：执行当前线程的处理器在对指令重新排序时，不能采用先执行 MemoryBarrier 调用之后的内存存取，再执行 MemoryBarrier 调用之前的内存存取的方式。
16	public static void ResetAbort() 取消为当前线程请求的 Abort。
17	public static void SetData( LocalDataStoreSlot slot, Object data ) 在当前正在运行的线程上为此线程的当前域在指定槽中设置数据。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
18	public void Start() 开始一个线程。
19	public static void Sleep( int millisecondsTimeout ) 让线程暂停一段时间。
20	public static void SpinWait( int iterations ) 导致线程等待由 iterations 参数定义的时间量。
21	public static byte VolatileRead( ref byte address ) public static double VolatileRead( ref double address ) public static int VolatileRead( ref int address ) public static Object VolatileRead( ref Object address ) 读取字段值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。此方法有不同的重载形式。这里只给出了一些形式。
22	public static void VolatileWrite( ref byte address, byte value ) public static void VolatileWrite( ref double address, double value ) public static void VolatileWrite( ref int address, int value ) public static void VolatileWrite( ref Object address, Object value ) 立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。此方法有不同的重载形式。这里只给出了一些形式。
23	public static bool Yield() 导致调用线程执行准备好在当前处理器上运行的另一个线程。由操作系统选择要执行的线程。

创建线程

线程是通过扩展 Thread 类创建的。扩展的 Thread 类调用 Start() 方法来开始子线程的执行。

下面的程序演示了这个概念：

using System;
using System.Threading;

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Child thread starts");
        }
        
        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();
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

In Main: Creating the Child thread
Child thread starts

解析：

Thread childThread = new Thread( new ThreadStart(CallToChildThread));

Thread childThread = new Thread(CallToChildThread);

这两种写法的效果是一样的。都是创建一个线程。后者只是 C# 的语法，编译时编译器会自动转换成第一种的形式。ThreadStart 是线程的入口，可以理解为一个函数指针，指向线程将要运行的函数。

C#在4.0后的3种创建线程的方式

Thread 自己创建的独立的线程, 优先级高,需要使用者自己管理。
ThreadPool 有 .Net 自己管理, 只需要把需要处理的方法写好, 然后交给.Net Framework, 后续只要方法执行完毕, 则自动退出。
Task 4.0 以后新增的线程操作方式, 类似 ThreadPool, 但效率测试比ThreadPool略高, Task对多核的支持更为明显,所以在多核的处理器中, Task的优势更为明显。

class Program
{  
    static void Main(string[] args)
    {  //独立创建线程
        Thread t = new Thread(ThreadProcess);
        t.Start(new object());
        
        //线程池
        ThreadPool.QueueUserWorkItem(ThreadProcess, new object());
        //Task方式创建线程
        System.Threading.Tasks.Task.Factory.StartNew(ThreadProcess, new object());

        //需要手动终止,当然现在终止可能线程还未运行完成,
        t.Abort();
    }
    private static void ThreadProcess(object tag)
    {
        int i = 100;
        while (i > 0)
        {
            Console.WriteLine(string.Format("i:{0} ", i));
            Thread.Sleep(10);
            i--;
        }
    }
}

管理线程

Thread 类提供了各种管理线程的方法。

下面的实例演示了 sleep() 方法的使用，用于在一个特定的时间暂停线程。

using System;
using System.Threading;

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Child thread starts");
            // 线程暂停 5000 毫秒
            int sleepfor = 5000; 
            Console.WriteLine("Child Thread Paused for {0} seconds", 
                              sleepfor / 1000);
            Thread.Sleep(sleepfor);
            Console.WriteLine("Child thread resumes");
        }
        
        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();
            Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

In Main: Creating the Child thread
Child thread starts
Child Thread Paused for 5 seconds
Child thread resumes

销毁线程

Abort() 方法用于销毁线程。

通过抛出 threadabortexception 在运行时中止线程。这个异常不能被捕获，如果有 finally 块，控制会被送至 finally 块。

下面的程序说明了这点：

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();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

In Main: Creating the Child thread
Child thread starts
0
1
2
In Main: Aborting the Child thread
Thread Abort Exception
Couldn't catch the Thread Exception

线程销毁方法

线程自动销毁

Thread a=new Thread(Method) th.start();

线程方法Method执行完结,线程a也自动终止.

如果是无限循环需要手动销毁
窗体应用程序的线程间通信
.net 2.0以后加强了安全机制，不允许在winform中直接跨线程访问控件的属性。
线程函数通过委托传递，是一种安全的线程间通信的方式。也是委托的功能之一。
但C#也可以关闭线程安全保护，自由的调用其他线程生成的控件。只要加上

Control.CheckForIllegalCrossThreadCalls = false;

带参函数的线程

线程函数通过委托传递，可以不带参数，也可以带参数（只能有一个参数），可以用一个类或结构体封装参数:

using System;
using System.Threading;

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(new ThreadStart(TestMethod));
            Thread t2 = new Thread(new ParameterizedThreadStart(TestMethod));
            t1.IsBackground = true;
            t2.IsBackground = true;
            t1.Start();
            t2.Start("hello");
            Console.ReadKey();
        }

        public static void TestMethod()
        {
            Console.WriteLine("不带参数的线程函数");
        }

        public static void TestMethod(object data)
        {
            string datastr = data as string;
            Console.WriteLine("带参数的线程函数，参数为：{0}", datastr);
        }
    }
}

2019年3月28日

C#中equal与==的区别

C#中，判断相等有两种方式，一种是传统的==操作，一种是object提供的Equals方法。二者的区别在于：

一、==操作符判断的是堆栈中的值，Equlas判断的是堆中的值。

C#提供值类型和引用类型，值类型存储在栈上，故用==判断是直接判断其值是否相等，因为值类型不存在堆中的数据，因此值类型的Equals也是判断数据。即，对于值类型而言，==与Equals相同，均是判断其值是否相等。

对于引用类型而言，其栈中存储的是对象的地址，那么==就是比较两个地址是否相等，即是否指向同一个对象；Equals函数则是比较两个对象在堆中的数据是否一样，即两个引用类型是否是对同一个对象的引用。

二、String类型特殊

String类型虽然是引用类型，但是对String对象的赋值却按照值类型操作。

例如：

String s1=“hello”;
String s2=“hello”;
对s2初始化的时候，并没有重新开辟内存，而是直接将其地址指向s1的内容“hello”。这样一来，string类型虽然是引用类型，但是其==操作和Equals操作都是一样的，均比较值是否相等。

三、与GetHashCode()的关系

若两对象Equals相等，那么其GetHashCode()必定相等；但是反过来，若GetHashCode()相等，那么这两个对象Equals方法比较结果不一定相同。（为了获取最佳性能，hash函数为对象内容生成的数字是随机分布的，这就意味着，内容不同的对象，有可能生成的数字是一样的，但可以认为这种概率非常小）。

下面示例说明：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class People
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public People(string name)
        {
            this.name = name;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            string a = "hello";
            string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
            Console.WriteLine(a == b);
            Console.WriteLine(a.Equals(b));
            Console.WriteLine("\n");

            Int32 m = 3;
            Int32 n = 3;
            Console.WriteLine(n == m);
            Console.WriteLine(n.Equals(m));
            Console.WriteLine("\n");

            object g = a;
            object h = b;
            Console.WriteLine(g == h);
            Console.WriteLine(g.Equals(h));
            Console.WriteLine(g.GetHashCode() + "   " + h.GetHashCode());
            Console.WriteLine("\n");

            People p1 = new People("Jimmy");
            People p2 = new People("Jimmy");
            Console.WriteLine(p1 == p2);
            Console.WriteLine(p1.Equals(p2));
            Console.WriteLine(p1.GetHashCode() + "  " + p2.GetHashCode());
            Console.WriteLine("\n");

            People p3 = new People("Jimmy");
            People p4 = p3;
            Console.WriteLine(p3 == p4);
            Console.WriteLine(p3.Equals(p4));

        }
    }
}

运行结果如下：

True   True    True    True    False    True    -695839   -695839    False    False    46104728  12289376    True    True      请按任意键继续. . .

在C#中，string 类型的特点有：

属于基本数据类型；
是引用类型；
只读；
string a=“1123”;
string b=“1123”;
那么a和b指向同一个内存地址；
但是并非2个相同值相等的字符串就对应同一个内存地址；
2个string 类型做“==”操作，先判断内存地址是否相同，如果相同，则立即返回true;如果内存地址不相同，则继续判断值是否相同。

下面示例说明：

static void Main(string[] args)
        {
            string a = new string(new char[] { 'c', h', e',n', '1' });
            string b = new string(new char[] { 'c', h', e',n', '1' });
            Console.WriteLine(a == b); //结果为true
            Console.WriteLine(a.Equals(b));//结果为true

            object g = a;
            object h = b;
            Console.WriteLine(g == h);//结果为false
            Console.WriteLine(g.Equals(h));//结果为true

            Person p1 = new Person("csw");
            Person p2 = new Person("csw");
            Console.WriteLine(p1 == p2);//结果为false
            Console.WriteLine(p1.Equals(p2));//结果为false


            Person p3 = new Person("csw");
            Person p4 = p3;
            Console.WriteLine(p3 == p4);//结果为true
            Console.WriteLine(p3.Equals(p4));//结果为true

            Console.ReadLine();
        }

2019年5月13日

接口、抽象类、密封类、虚方法、抽象方法、密封方法

//完全抽象 , 可多继承 , 方法不可实现 ,接口也不可实例化
//接口中只能声明方法，属性，事件，索引器 , 数据成员必须是常量 , 
interface IOrigin
{
    void Interface001();
    void Interface002();
    void Interface003();
}

//部分抽象 , 只可单继承 , 除抽象方法外其他方法需要实现 , 可间接进行实例化
//抽象类中可以有方法的实现 , 也可以定义非静态的类变量 , 可以提供某些方法的部分实现
abstract class Cell : IOrigin
{
    //实现接口
    public void Interface001() { }
    //以抽象方式实现接口
    public abstract void Interface002();
    //显式实现接口（实现的方法是属于接口的，而不是属于实现类的）
    void IOrigin.Interface003() { }

    //抽象类中的抽象方法是必须在第一继承的子类中实现 , 后续子类可实现也可不实现
    //抽象方法的声明不可以有方法体
    public abstract void AbstractRethodTest();

    //虚方法在子类中可实现也可不实现 , 可以只在需要的类中重写
    //虚方法的声明必须有方法体
    public virtual void VirtualRethodTest() { }

    //sealed 只可用于重写方法
    public virtual void SealedRethodTest() { }
}
class Animal : Cell
{
    public override void Interface002() { }

    //不可使用 this.AbstractRethodTest() 
    public override void AbstractRethodTest() { }

    //sealed 关键字只可用于重写方法
    public sealed override void SealedRethodTest() { }
}

class Lion : Animal
{
    public override void AbstractRethodTest() { }

    public override void VirtualRethodTest() { }
}
//重写方法中使用 this.XXX() 会调用父类的 XXX() 
//若父类没有重写 XXX() ,则会继续寻找父类的父类中的 XXX() 进行调用
//虚方法由于声明时无法实现 , 所以在 *第一子类* 重写虚方法时，无法调用 this.XXX()

//密封类 , 不可被继承 , 不能用作基类 , 主要用于防止派生 , 使得对密封类成员的调用速度略快
sealed class  SealedClass{ }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-luoCWwxi-1581865224753)(https://s2.ax1x.com/2019/05/13/E5ciWR.png)]

2020年6月18日

特性

/// <summary>
        /// 提示此方法已经过时
        /// </summary>
        [Obsolete("此方法已过时，请使用NewMethod")]
        static void OldMethod1()
        {
            Console.WriteLine("OldMethod1!");
        }
        /// <summary>
        /// 提示此方法已经过时，并发出警告
        /// </summary>
        [Obsolete("此方法已过时，请使用NewMethod",true)]
        static void OldMethod2()
        {
            Console.WriteLine("OldMethod2!");
        }


        #define IsDebugConditional
        /// <summary>
        /// 标记Conditional特性的方法仅当在启用对应宏定义时才会被真正调用（即便不启用宏定义，此方法也会被编译进入程序集）
        /// </summary>
        [Conditional("IsDebugConditional")]
        static void ConditionalMethod()
        {
            Console.WriteLine("ConditionalMethod!");
        }

        /// <summary>
        /// 调用者信息特性，获取调用处的文件路径、行号、调用者的方法（由系统自动进行赋值）
        /// </summary>
        /// <param name="callerFilePath"></param>
        /// <param name="callerLineNumber"></param>
        /// <param name="callerMemberName"></param>
        static void CallerMethod([CallerFilePath] string callerFilePath = "", [CallerLineNumber] int callerLineNumber = 0, [CallerMemberName] string callerMemberName = "")
        {
            Console.WriteLine("CallerMethod!");
            Console.WriteLine("CallerFilePath:"+callerFilePath);
            Console.WriteLine("CallerLineNumber:"+callerLineNumber);
            Console.WriteLine("CallerMemberName:"+callerMemberName);
        }

        /// <summary>
        /// 断点调试时会跳过标记此特性的方法
        /// </summary>
        [DebuggerStepThrough]
        static void DebuggerStepThroughMethod()
        {
            Console.WriteLine("DebuggerStepThroughMethod!");
        }

AndySoeng

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
C#高级内容笔记

C#高级内容笔记2018年12月19日委托C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate）是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。定义一个委托，准备相应的调用方法。注意：定义一个委托相当于...
复制链接

扫一扫