Csharp on LeafCxy's Blog

WaitCallback

Thu, 24 Jul 2025 05:08:14 +0000

WaitCallback 委托一般用于将方法异步执行到线程池线程上。线程池是一组可重用的线程，可以在需要时分配线程来执行工作，而不需要创建新的线程。使用线程池可以避免频繁地创建和销毁线程，从而提高应用程序的性能和可伸缩性。

通常，您可以使用 ThreadPool.QueueUserWorkItem 方法将方法异步执行到线程池线程上，并使用 WaitCallback 委托来表示要执行的方法。在这种情况下，WaitCallback 委托的参数是一个 object 类型的对象，该对象可以包含要传递给方法的数据。

例如，以下代码演示了如何使用 WaitCallback 委托和 ThreadPool.QueueUserWorkItem 方法：

WaitCallback callback = new WaitCallback(MyMethod);
ThreadPool.QueueUserWorkItem(callback, data);

private void MyMethod(object state)
{
 // 执行一些工作
}

在这个例子中，MyMethod 方法将在线程池线程上异步执行。data 对象将作为 state 参数传递给 MyMethod 方法。

yield

Thu, 24 Jul 2025 05:00:54 +0000

在 C# 中，yield 關鍵字用於定義一個迭代器方法（Iterator Method），這個方法可以產生一個可枚舉的序列。當迭代器方法被調用時，它不會立即執行方法體中的程式碼，而是返回一個 IEnumerator 對象。當使用者對這個 IEnumerator 對象調用 MoveNext() 方法時，才會執行迭代器方法中的程式碼，並返回序列中的下一個元素。

使用 yield 關鍵字可以讓我們更簡潔地定義一個可枚舉的序列，而不需要手動實現 IEnumerator 和 IEnumerable 接口。此外，在使用 yield 關鍵字時，我們可以使用 yield break 來提前結束序列的產生。

好的，以下是一個使用 yield 關鍵字定義可枚舉序列的簡單範例：

using System;
using System.Collections.Generic;

class Program
{
 static void Main(string[] args)
 {
 // 創建一個可枚舉序列
 var sequence = CountTo(5);

 // 使用 foreach 迴圈枚舉序列中的元素
 foreach (var number in sequence)
 {
 Console.WriteLine(number);
 }
 }

 // 定義一個可枚舉序列，使用 yield 關鍵字
 static IEnumerable<int> CountTo(int max)
 {
 for (int i = 1; i <= max; i++)
 {
 // 使用 yield 關鍵字返回序列中的下一個元素
 yield return i;
 }
 }
}

在這個範例中，我們使用 CountTo 方法定義了一個可枚舉序列，這個序列包含了從 1 到指定的最大值的整數。在 CountTo 方法中，我們使用 yield return 關鍵字返回序列中的下一個元素，這個方法被調用時不會立即執行，而是返回一個 IEnumerable<int> 對象。在 Main 方法中，我們使用 foreach 迴圈來枚舉這個序列中的元素，這時才會執行 CountTo 方法中的程式碼並產生序列。

Tuple

Thu, 24 Jul 2025 04:49:40 +0000

可以通过nuget安装 NetLegacySupport.Tuple。这是从.Net 4.5移植到.Net 2.0和3.5的Tuple类

下面是一个使用 Tuple 的简单示例：

using System;

class Program
{
 static void Main(string[] args)
 {
 // 创建一个包含两个元素的 Tuple
 var tuple = Tuple.Create("John", 30);

 // 访问 Tuple 中的元素
 Console.WriteLine("Name: " + tuple.Item1);
 Console.WriteLine("Age: " + tuple.Item2);

 // 创建一个包含三个元素的 Tuple
 var tuple2 = Tuple.Create("Mary", 25, "Female");

 // 访问 Tuple 中的元素
 Console.WriteLine("Name: " + tuple2.Item1);
 Console.WriteLine("Age: " + tuple2.Item2);
 Console.WriteLine("Gender: " + tuple2.Item3);
 }
}

在上面的示例中，我们使用 Tuple.Create 方法创建了两个不同元素数量的 Tuple，并访问了其中的元素。Tuple 的元素可以通过 Item1、Item2、Item3 等属性访问，也可以使用解构语法将元素分解成多个变量。

当我们运行上面的代码时，输出结果如下：

Name: John
Age: 30
Name: Mary
Age: 25
Gender: Female

可以看到，我们成功地创建了两个不同元素数量的 Tuple，并成功访问了其中的元素。需要注意的是，Tuple 是一个不可变类型，一旦创建，就不能修改其元素的值。如果需要修改 Tuple 中的元素，需要先创建一个新的 Tuple。

C#中异步调用函数的方法有哪些

Thu, 24 Jul 2025 03:18:21 +0000

在 C# 中，有几种方法可以进行异步调用函数：

使用 async/await 关键字：async/await 是 C# 中用于编写异步代码的关键字组合。你可以将需要异步执行的函数标记为 async，然后在其中使用 await 关键字来等待异步操作完成。这样可以使函数在异步操作执行期间不阻塞，并在操作完成后继续执行。例如：

public async Task MyAsyncMethod()
{
 // 异步操作
 await Task.Delay(1000);

 // 异步操作完成后的代码
 Console.WriteLine("异步操作完成");
}

使用 Task.Run 方法：Task.Run 方法可以将一个方法或代码块包装成一个 Task 对象，并在后台线程上执行。这样可以实现异步调用函数的效果。例如：

public void MyMethod()
{
 // 异步调用函数
 Task.Run(async () =>
 {
 // 异步操作
 await Task.Delay(1000);

 // 异步操作完成后的代码
 Console.WriteLine("异步操作完成");
 });

 // 继续执行其他代码
 Console.WriteLine("异步调用进行中");
}

使用委托和回调函数：你可以定义一个异步委托，并使用回调函数来处理异步操作完成后的结果。例如：

public delegate void MyAsyncDelegate();

public void MyMethod()
{
 // 创建异步委托实例
 MyAsyncDelegate asyncDelegate = new MyAsyncDelegate(MyAsyncMethod);

 // 异步调用委托
 asyncDelegate.BeginInvoke(MyAsyncCallback, null);

 // 继续执行其他代码
 Console.WriteLine("异步调用进行中");
}

public void MyAsyncMethod()
{
 // 异步操作
 Thread.Sleep(1000);
}

public void MyAsyncCallback(IAsyncResult result)
{
 // 异步操作完成后的代码
 Console.WriteLine("异步操作完成");
}

这些是在 C# 中进行异步调用函数的几种常见方法。你可以根据具体的需求选择适合的方法来实现异步操作。

特性和反射

Wed, 23 Jul 2025 02:26:22 +0000

以下是一个示例，展示了如何定义和使用特性，并使用反射来获取特性信息：

using System;
using System.Reflection;

// 自定义特性类
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
class MyCustomAttribute : Attribute
{
 public string Description { get; }

 public MyCustomAttribute(string description)
 {
 Description = description;
 }
}

// 带有特性的类
[MyCustom("This is a class attribute")]
class MyClass
{
 [MyCustom("This is a method attribute")]
 public void MyMethod()
 {
 Console.WriteLine("Hello from MyMethod");
 }
}

class Program
{
 static void Main()
 {
 // 使用反射获取类的特性
 Type classType = typeof(MyClass);
 MyCustomAttribute[] classAttributes = (MyCustomAttribute[])classType.GetCustomAttributes(typeof(MyCustomAttribute), true);
 foreach (MyCustomAttribute attribute in classAttributes)
 {
 Console.WriteLine("Class Attribute: " + attribute.Description);
 }

 // 使用反射获取方法的特性
 MethodInfo methodInfo = classType.GetMethod("MyMethod");
 MyCustomAttribute[] methodAttributes = (MyCustomAttribute[])methodInfo.GetCustomAttributes(typeof(MyCustomAttribute), true);
 foreach (MyCustomAttribute attribute in methodAttributes)
 {
 Console.WriteLine("Method Attribute: " + attribute.Description);
 }

 // 等待用户输入，防止控制台窗口关闭
 Console.ReadLine();
 }
}

在这个示例中，我们首先定义了一个自定义特性类 MyCustomAttribute，它继承自 Attribute。然后，我们在 MyClass 类和 MyMethod 方法上应用了 MyCustomAttribute 特性，并传入了相应的描述信息。

Microsoft.Jet.OLEDB.4.0驱动程序

Tue, 22 Jul 2025 08:40:01 +0000

在64位程序中运行使用Microsoft.Jet.OLEDB.4.0需要特别注意，因为Microsoft.Jet.OLEDB.4.0驱动程序是为32位环境设计的。在64位操作系统和64位应用程序中，它可能无法正常工作。

如果你需要在64位程序中使用Microsoft.Jet.OLEDB.4.0，你可以尝试以下方法：

使用WoW64（Windows on Windows 64）桥接器：WoW64是Windows提供的一种机制，允许32位应用程序在64位环境中运行。你可以通过在64位程序中调用WoW64桥接器来访问Microsoft.Jet.OLEDB.4.0驱动程序。这可以通过编程方式实现，例如使用系统调用来调用适当的WoW64函数。使用32位版本的数据库引擎：如果你有权限安装额外的软件，你可以尝试安装32位版本的数据库引擎，例如Microsoft Access，它包含了Microsoft.Jet.OLEDB.4.0驱动程序。然后，你可以在64位程序中使用这个32位版本的数据库引擎来访问数据库。使用替代的数据库连接驱动程序：如果可能，考虑使用与64位环境兼容的其他数据库连接驱动程序，例如MySQL或SQLite。这些驱动程序可以在64位环境中正常运行，并且提供了与Microsoft.Jet.OLEDB.4.0相似的功能。请注意，这些方法可能并不适用于所有情况，具体取决于你的应用程序和需求。在进行任何更改之前，请确保备份你的数据，并测试你的应用程序以确保其正常工作。

SerialPort串口编程

Tue, 22 Jul 2025 08:32:21 +0000

从Microsoft .Net 2.0版本以后，就默认提供了System.IO.Ports.SerialPort类，用户可以非常简单地编写少量代码就完成串口的信息收发程序。

串口端口号搜索

string[] portList = System.IO.Ports.SerialPort.GetPortNames();
for (int i = 0; i < portList.Length; i++)
{
 string name = portList[i];
 comboBox.Items.Add(name);
}

串口属性参数设置

SerialPort mySerialPort = new SerialPort("COM2");//端口
mySerialPort.BaudRate = 9600;//波特率
mySerialPort.Parity = Parity.None;//校验位
mySerialPort.StopBits = StopBits.One;//停止位
mySerialPort.DataBits = 8;//数据位
mySerialPort.Handshake = Handshake.Non;
mySerialPort.ReadTimeout = 1500;
mySerialPort.DtrEnable = true;//启用数据终端就绪信息
mySerialPort.Encoding = Encoding.UTF8;
mySerialPort.ReceivedBytesThreshold = 1;//DataReceived触发前内部输入缓冲器的字节数
mySerialPort.DataReceived += new SerialDataReceivedEvenHandler(DataReceive_Method);

mySerialPort.Open();

串口发送信息

// Write a string
port.Write("Hello World");

// Write a set of bytes
port.Write(new byte[] { 0x0A, 0xE2, 0xFF }, 0, 3);

// Close the port
port.Close();

串口接收信息

string serialReadString;
private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
 serialReadString = port.ReadExisting());
 this.txt1.Invoke( new MethodInvoker(delegate { this.txt1.AppendText(serialReadString); }));
}

循环接收数据

void com_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
 // Use either the binary OR the string technique (but not both)
 // Buffer and process binary data
 while (com.BytesToRead > 0)
 bBuffer.Add((byte)com.ReadByte());
 ProcessBuffer(bBuffer);

 // Buffer string data
 sBuffer += com.ReadExisting();
 ProcessBuffer(sBuffer);
}

private void ProcessBuffer(string sBuffer)
{
 // Look in the string for useful information
 // then remove the useful data from the buffer
}

private void ProcessBuffer(List<byte> bBuffer)
{
 // Look in the byte array for useful information
 // then remove the useful data from the buffer
}

STAThread

Tue, 22 Jul 2025 08:30:26 +0000

[STAThread] STAThread：Single Thread Apartment Thread.(单一线程单元线程) []是用来表示Attributes；

[STAThread] 是一种线程模型，用在程序的入口方法上（在C#和VB.NET里是Main()方法），来指定当前线程的ApartmentState 是STA。用在其他方法上不产生影响。在aspx页面上可以使用AspCompat = “true” 来达到同样的效果。这个属性只在 Com Interop 有用，如果全部是 managed code 则无用。简单的说法:[STAThread]指示应用程序的默认线程模型是单线程单元 (STA)。启动线程模型可设置为单线程单元或多线程单元。如果未对其进行设置，则该线程不被初始化。也就是说如果你用的.NET Framework，并且没有使用COM Interop，一般不需要这个Attribute。其它的还有MTA（多线程套间）、Free Thread（自由线程）。

[STAThread] attribute指示应用程序的 COM 线程模型是单线程单元。而于此对应的多线程单元则是 [MTAThread] （多线程单元线程）

COM 线程模型只适用于使用 COM interop 的应用程序。如果将此属性应用到不使用 COM interop 的应用程序，将没有任何效果。

COM 线程模型可设置为单线程单元或多线程单元。如果应用程序线程实际调用了 COM 组件，则仅为 COM interop 初始化该线程。如果没有使用 COM interop，则不初始化该线程。

.ctor&.cctor&对象的构造过程

Tue, 22 Jul 2025 08:26:40 +0000

.ctor 构造函数，在类被实例化时，它会被自动调用。

.cctor 类型初始化器，是一个静态方法，无参数无返回值，不能直接调用，最多只有一个

在继承中对象构造过程,看下面这段程序：

public class A
{
 public int x = 1;
 public A() { m1(); }
 public void m1() { }
}

public class B : A
{
 public int y = 2;
 public static string sb = "B";
 public B() { m2(); }
 public void m2() { }
}

public class C : B
{
 public int z = 3;
 public static string sc = "C";
 public C() { m3(); }
 public void m3() { }
}

可以看到三者都有一个.ctor，B、C中有.cctor，而A没有，打开B,C的.cctor，可以看到它们都负责初始化自己的静态字段，现在主要来看它们的.ctor。

总结

.ctor是构造方法；
.cctor是类型初始化器，在C#中也就是静态构造函数；
当类C实例化时，会先对声明时就进行赋值的字段赋值，然后调用基类的构造函数，基类再以同样的方法构造自己，一直到顶层的System.Object，然后再回来执行C的显式构造方法中的代码，就是这么一个递归的过程。

csharp中的析构函数

Tue, 22 Jul 2025 01:23:53 +0000

析构函数

析构函数(destructor) 与构造函数相反，当对象脱离其作用域时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

以C++语言为例，析构函数名也应与类名相同，只是在函数名前面加一个波浪符~，例如~stud( )，以区别于构造函数。它不能带任何参数，也没有返回值（包括void类型）。只能有一个析构函数，不能重载。如果用户没有编写析构函数，编译系统会自动生成一个缺省的析构函数，它也不进行任何操作。所以许多简单的类中没有用显式的析构函数。

解构器

我们知道，‘解构器’被用来清除类的事例。当我们在C#中使用解构器是，我们必须记住以下几点：

一个类只能有一个解构器。
解构器不能被继承或重载。
解构器不能被调用。他们是自动被（编译器）调用的。
解构器不能带修饰或参数。

下面是类MyClass解构器的一个声明：

~ Class()
{
 //Cleaning up code goes here
}

程序员不能控制解构器何时将被执行因为这是由垃圾收集器决定的。垃圾收集器检查不在被应用程序使用的对象。它认为这些条件是符合清楚的并且收回它们的内存。解构器也在程序退出时被调用。当解构器执行时其背后所发生的那一幕是解构器隐式调用对象基类的Object.Finalize方法。因此上述解构器代码被隐含转化成：

protected override void Finalize()
{
 try
 {
 //Cleaning up.
 }
 finally
 {
 base.Finalize();
 }
}

使用完对象你就想调用解构器，该怎么做？有两个方法：

调用垃圾搜集器来清理GC.Collect(); 。
实现IDisposable的Dispose方法。

尽管如此我们花费一些时间实现IDisposable接口，如果不能合适地调用它们会怎样？为此C#有一个酷的解决方案。‘using’代码块。它看起来像这样：

using (MyClass objCls =new MyClass())
{

}

https://www.cnblogs.com/paper/archive/2009/07/31/1535998.html

csharp互操作

Tue, 22 Jul 2025 01:15:46 +0000

Platform Invoke(P/Invoke)，即平台调用,主要用于调用C库函数和Windows API

using System;

// 使用平台调用技术进行互操作性之前，首先需要添加这个命名空间
using System.Runtime.InteropServices;

namespace 平台调用Demo
{
 class Program
 {
 // 在托管代码中对非托管函数进行声明，并且附加平台调用所需要属性
 // 在默认情况下，CharSet为CharSet.Ansi
 // 指定调用哪个版本的方法有两种——通过DllImport属性的CharSet字段和通过EntryPoint字段指定
 // 在托管函数中声明注意一定要加上 static 和extern 这两个关键字 [DllImport("user32.dll")]
 public static extern int MessageBox1(IntPtr hWnd, String text, String caption, uint type);

 // 在默认情况下，CharSet为CharSet.Ansi
 [DllImport("user32.dll")]
 public static extern int MessageBoxA(IntPtr hWnd, String text, String caption, uint type);

 // 在默认情况下，CharSet为CharSet.Ansi
 [DllImport("user32.dll")]
 public static extern int MessageBox(IntPtr hWnd, String text, String caption, uint type);

 // 第一种指定方式，通过CharSet字段指定
 [DllImport("user32.dll", CharSet = CharSet.Unicode)]
 public static extern int MessageBox2(IntPtr hWnd, String text, String caption, uint type);

 // 通过EntryPoint字段指定
 [DllImport("user32.dll", EntryPoint="MessageBoxA")]
 public static extern int MessageBox3(IntPtr hWnd, String text, String caption, uint type);

 [DllImport("user32.dll", EntryPoint = "MessageBoxW")]
 public static extern int MessageBox4(IntPtr hWnd, String text, String caption, uint type);
 static void Main(string[] args)
 {
 // 在托管代码中直接调用声明的托管函数
 // 使用CharSet字段指定的方式，要求在托管代码中声明的函数名必须与非托管函数名一样
 // 否则就会出现找不到入口点的运行时错误
 //MessageBox1(new IntPtr(0), "Learning Hard", "欢迎", 0);

 // 下面的调用都可以运行正确
 //MessageBoxA(new IntPtr(0), "Learning Hard", "欢迎", 0);
 //MessageBox(new IntPtr(0), "Learning Hard", "欢迎", 0);

 // 使用指定函数入口点的方式调用
 //MessageBox3(new IntPtr(0), "Learning Hard", "欢迎", 0);

 // 调用Unicode版本的会出现乱码
 MessageBox4(new IntPtr(0), "Learning Hard", "欢迎", 0);
 }
 }
}

C++ Introp, 主要用于Managed C++(托管C++)中调用C++类库

第二部分主要向大家介绍了第一种互操作性技术，然后我们也可以使用C++ Interop技术来实现与非托管代码进行交互。然而C++ Interop 方式有一个与平台调用不一样的地方，就是C++ Interop 允许托管代码和非托管代码存在于一个程序集中，甚至同一个文件中。 C++ Interop 是在源代码上直接链接和编译非托管代码来实现与非托管代码进行互操作的，而平台调用是加载编译后生成的非托管DLL并查找函数的入口地址来实现与非托管函数进行互操作的。 C++ Interop使用托管C++来包装非托管C++代码，然后编译生成程序集，然后再托管代码中引用该程序集，从而来实现与非托管代码的互操作。

不能在控制元件上呼叫Invoke

Tue, 22 Jul 2025 01:13:36 +0000

在Window窗體程式開發的時候，如果使用多執行緒程式設計，在子執行緒中訪問主執行緒窗體內的控制元件，就需要使用控制元件的Control.Invoke方法或者BeginInvoke方法。但是有時候因為Window執行速度太快，尤其是你寫程式碼的時候在InitializeComponent();完成之前起了一個執行緒去執行某些操作，涉及到窗體控制元件的，當你在呼叫Control.Invoke的時候，就可能出現 “在建立視窗控制代碼之前，不能在控制元件上呼叫 Invoke 或 BeginInvoke

解決的辦法就是讓執行緒等待，直到視窗控制代碼建立完畢：

while (!this.IsHandleCreated)
{
 ;
}
this.BeginInvoke(new ProListIndexChangedDelegate(GetProLyric));

//根據不同情況也可以： 
if (this.IsHandleCreated)
BeginInvoke(new ProListIndexChangedDelegate(GetProLyric));

有一個更巧妙的方法，只要在BeginInvoke方法的呼叫語句前再加一句：IntPtr i = this.Handle;就OK了，這比死迴圈配合this.IsHandleCreated的判斷方法更簡潔，因為this.Handle這個屬性本身就對應一個方法，取不到控制代碼，程式就不會向下進行。

无依赖的LitJSON

Sat, 19 Jul 2025 02:10:07 +0000

将JSON映射到对象，反之亦然

为了在内部使用JSON格式的数据。网络程序，自然我想到的方法是使用JSON文本填充新实例属于某一特定类别；要么是定制的，与结构相匹配输入JSON文本或充当字典的更通用的文本。

相反地为了从存储在对象中的数据构建新的JSON字符串，一个简单的export-like操作听起来是个好主意。

为此，LitJSON包括JsonMapper类，它提供了两种主要的方法来处理JSON-to-object和对象到JSON转换。这些方法是 JsonMapper.ToObject和JsonMapper.ToJson。

简单的`JsonMapper`示例

如下例所示，ToObject方法具有泛型变体JsonMapper.ToObject<T>，用于指定待归还的物品。

using LitJson;
using System;

public class Person
{
 // C# 3.0 auto-implemented properties
 public string Name { get; set; }
 public int Age { get; set; }
 public DateTime Birthday { get; set; }
}

public class JsonSample
{
 public static void Main()
 {
 PersonToJson();
 JsonToPerson();
 }

 public static void PersonToJson()
 {
 Person bill = new Person();

 bill.Name = "William Shakespeare";
 bill.Age = 51;
 bill.Birthday = new DateTime(1564, 4, 26);

 string json_bill = JsonMapper.ToJson(bill);

 Console.WriteLine(json_bill);
 }

 public static void JsonToPerson()
 {
 string json = @"
 {
 ""Name"" : ""Thomas More"",
 ""Age"" : 57,
 ""Birthday"" : ""02/07/1478 00:00:00""
 }";

 Person thomas = JsonMapper.ToObject<Person>(json);

 Console.WriteLine("Thomas' age: {0}", thomas.Age);
 }
}

示例输出：