分类： Csharp

Visual Studio 语言设置

2023年5月8日 by admin·0评论

按照的是中文的visual studio，用起来很不方便，因为程序员的都是英文版，平时交流时也是英文的名字

转换语言时发现只有中文和跟随windows系统的设置

官方给的文档看的不是很清楚

查阅资料后总结下步骤：

1、进入到设置–选项–区域设置，发现没有英文语言

2、进入工具–获取工具和功能

3、等待加载完毕后，然后选择语言包–选择语言，确定修改

4、修改完成后再次进入到设置–选项–区域设置，切换语言为英语，确定

重启visual studio后语言切换到英语，如下图

设置成功

C#.NET 高性能序列化组件：MessagePack

2023年4月20日 by admin·0评论

C#是一种流行的编程语言，而MessagePack是一种二进制序列化格式，用于在网络上高效传递数据。在C#中使用MessagePack可以通过安装和使用MessagePack NuGet包来实现。以下是使用MessagePack的示例代码：

首先，安装MessagePack NuGet包。可以使用Visual Studio中的NuGet包管理器来安装它，或在命令行中使用以下命令安装它：

Install-Package MessagePack

然后，在代码中使用MessagePack进行序列化和反序列化。以下是一个使用MessagePack进行序列化和反序列化的示例：

using System;
using MessagePack;

[MessagePackObject]
public class Person
{
    [Key(0)]
    public string Name { get; set; }

    [Key(1)]
    public int Age { get; set; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 使用MessagePack序列化对象
        var person = new Person("Tom", 20);
        var bytes = MessagePackSerializer.Serialize(person);

        // 使用MessagePack反序列化对象
        var deserializedPerson = MessagePackSerializer.Deserialize<Person>(bytes);

        Console.WriteLine($"Name: {deserializedPerson.Name}, Age: {deserializedPerson.Age}");
    }
}

在上面的示例中，定义了一个Person类，它包含了Name和Age两个属性，并使用MessagePackObject和Key属性来标记需要进行序列化和反序列化的属性。

在Main方法中，创建了一个Person对象，并使用MessagePackSerializer.Serialize方法将其序列化为二进制数据，然后使用MessagePackSerializer.Deserialize方法将二进制数据反序列化为Person对象。最后输出了反序列化后的Person对象的属性。

需要注意的是，使用MessagePack进行序列化和反序列化时，需要保证序列化和反序列化的类型是一致的。否则可能会出现异常。

C# 使用正则表达式替换字符串

2023年3月30日 by admin·0评论

C# 中使用正则表达式替换字符串可以使用 Regex 类的 Replace 方法。方法定义如下：

public static string Replace(string input, string pattern, string replacement);

其中，input 表示要进行替换的字符串，pattern 表示要匹配的正则表达式模式，replacement 表示要替换成的字符串。

例如，假设要把一个字符串中所有的数字替换为”#”，可以使用以下代码：

string input = "1234567890";
string pattern = @"d";
string replacement = "#";
string result = Regex.Replace(input, pattern, replacement);

其中，正则表达式模式 @”d” 表示匹配任意一个数字字符。执行完以上代码后，result 的值应该是”##########”。

一个深度克隆PooledList示例方法

2023年3月28日 by admin·0评论

为了深度克隆PooledList<T>，你需要将原始列表中的元素逐个复制到新列表中。由于是“深度”克隆，所以必须创建后生成的新列表包含与原始列表相同类型的新对象，而不是原始列表中对象的引用。

以下是一个示例方法，可用于深度克隆PooledList<T>：

public static PooledList<T> Clone<T>(PooledList<T> original) where T : class, new()
{
    var newList = new PooledList<T>();
    for (int i = 0; i < original.Count; i++)
    {
        T originalItem = original[i];
        T newItem = new T();
        //然后将原始项目中的值复制到新项目中
        //在此之前，请确保T类型具有可复制的属性或字段
        newList.Add(newItem);
    }
    return newList;
}

请注意，为了深度克隆PooledList<T>，T类型必须满足以下条件：

1. 它必须是引用类型（即类或接口）；
2. 它必须具有默认构造函数（即无参构造函数）；
3. 它的字段或属性必须是可复制的。

如果上述条件不被满足，那么需要使用自定义方法来处理T类型的深度复制过程。

一个 .net core 7.0 的 dockerfile 示例

2023年3月15日 by admin·0评论

以下是一个示例的Dockerfile，用于构建.NET Core 7.0应用程序的容器：

# 设置基础镜像
FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build-env
WORKDIR /app

# 复制应用程序项目并生成
COPY *.csproj ./
RUN dotnet restore
COPY . ./
RUN dotnet publish -c Release -o out

# 使用最新的microsoft/dotnet镜像
FROM mcr.microsoft.com/dotnet/aspnet:7.0
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "MyApp.dll"]

Dockerfile将基础镜像设置为.NET Core 7.0 SDK，并在其中构建应用程序。然后它使用最新的.NET Core 7.0运行时映像作为基础镜像。最后，将生成的应用程序复制到容器中并设置entrypoint以运行该应用程序。

C#.NET 使用管理对象提供的WMI获取显卡信息

2023年3月15日 by admin·0评论

要获取C#中的显卡信息，你可以使用管理对象提供的WMI（Windows Management Instrumentation）类。

下面是实现代码示例:

using System.Management;

public static void GetGraphicsCardInformation()
{
    ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_VideoController");
    foreach (ManagementObject obj in searcher.Get())
    {
        Console.WriteLine("Name  -  " + obj["Name"].ToString());
        Console.WriteLine("Adapter Compatibility  -  " + obj["AdapterCompatibility"].ToString());
        Console.WriteLine("Adapter RAM  -  " + obj["AdapterRAM"].ToString());
        Console.WriteLine("Driver Version  -  " + obj["DriverVersion"].ToString());
        Console.WriteLine("Video Processor  -  " + obj["VideoProcessor"].ToString());
    }
}

此代码使用WMI查询了所有Win32_VideoController对象，通过迭代遍历每个对象并打印显卡的名称，适配器兼容性，适配器RAM，驱动程序版本和视频处理器信息。

C#.NET 利用PerformanceCounter类获取CPU各个核心使用率

2023年3月15日 by admin·0评论

要获取CPU各个核心的使用率，可以使用PerformanceCounter类。

以下是使用C#获取CPU各个核心使用率的示例代码：

using System;
using System.Diagnostics;

class Program
{
    static void Main(string[] args)
    {
        var cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
        var coresCounter = new PerformanceCounter("Processor", "% Processor Time", "0,1,2,3");

        while (true)
        {
            var cpuUsage = cpuCounter.NextValue();
            Console.WriteLine($"Total CPU Usage: {cpuUsage}%");

            var coreUsage = coresCounter.NextValue();
            Console.WriteLine($"Core 0 Usage: {coreUsage}%");

            coreUsage = coresCounter.NextValue();
            Console.WriteLine($"Core 1 Usage: {coreUsage}%");

            coreUsage = coresCounter.NextValue();
            Console.WriteLine($"Core 2 Usage: {coreUsage}%");

            coreUsage = coresCounter.NextValue();
            Console.WriteLine($"Core 3 Usage: {coreUsage}%");

            Console.WriteLine();
            Console.ReadLine();
        }
    }
}

该代码使用了两个PerformanceCounter实例，其中一个用于获取总CPU使用率，另一个用于获取每个核心的使用率。Processor是计算机中的一组性能计数器，与处理器相关的性能计数器都属于该组。

请注意，这只是一种可行的实现方法，实际上可能需要根据你的特定需求进行更详细的实现和优化。

C# 模拟退火算法实例

2023年2月6日 by admin·0评论

此片文章主要参考CSDN博主里头的一篇文章，将自己的理解写下来，以方便后期的查阅。

已知空间上若干点（xi, yi, zi）, 求空间上包含这些点的最小球半径 R, 以及球心坐标。

思路：球心与这些点的最大距离为半径，球心与最大距离点生成向量，将球心朝着该向量方向移动若干距离，再计算半径的变化。

namespace Test_BST
{
    public class Program
    {
        static void Main(string[] args)
        {
            // 初始化输入点
            List<Point> originPoints = new List<Point>() { ............};
            double radius = AnnealAlgorithm(originPoints);
        }

        private struct Point
        {
            public double x;
            public double y;
            public double z;
        }

        // square of a number
        private static double Sqr(double x) { return x * x; }

        // 两点之间的距离
        private static double Dist(Point A, Point B)
        {
            return Math.Sqrt(Sqr(A.x - B.x) + Sqr(A.y - B.y) + Sqr(A.z - B.z));
        }

        // 求最大半径
        private static double GetMaxRadius(Point p0, List<Point> pts)
        {
            double maxRadius = 0;
            foreach (var point in pts)
            {
                double radius = Dist(p0, point);
                maxRadius = radius > maxRadius ? radius : maxRadius;
            }

            return maxRadius;
        }

        private static double AnnealAlgorithm(List<Point> originPts)
        {
            Point center = new Point();
            center.x = 0;
            center.y = 0;
            center.z = 0;

            // 将初始化中心点设置为所有点的代数平均位置
            foreach (var pt in originPts)
            {
                center.x += pt.x;
                center.y += pt.y;
                center.z += pt.z;
            }
            center.x /= originPts.Count;
            center.y /= originPts.Count;
            center.z /= originPts.Count;

            double temp = 1e3; // 初始温度
            double coolingFactor = 0.98; // 降温因子
            double ans = GetMaxRadius(center, originPts); // 当前最小半径
            var random = new Random();

            while (temp > 1e-5)
            {
                Point newCenter = new Point();
                double max_r = 0;
                // 找到与当前中心点距离最远的点，将中心向着改点移动
                for (int i = 0; i < originPts.Count; i++)
                {
                    double r = Dist(center, originPts[i]);
                    if (r > max_r)
                    {
                        newCenter.x = (originPts[i].x - center.x) / r;
                        newCenter.y = (originPts[i].y - center.y) / r;
                        newCenter.z = (originPts[i].z - center.z) / r;
                        max_r = r;
                    }
                }
                newCenter.x = center.x + newCenter.x * temp;
                newCenter.y = center.y + newCenter.y * temp;
                newCenter.z = center.z + newCenter.z * temp;

                // 移动后的最大半径
                double tmp = GetMaxRadius(newCenter, originPts);

                if (tmp < ans) 
                {
                    center.x += newCenter.x * temp;
                    center.y += newCenter.y * temp;
                    center.z += newCenter.z * temp;
                }
                else if (Math.Exp((ans -tmp)/temp) > random.NextDouble() )
                {
                    center.x += newCenter.x * temp;
                    center.y += newCenter.y * temp;
                    center.z += newCenter.z * temp;
                }

                temp *= coolingFactor;
            }
            double miniRadius = GetMaxRadius(center, originPts);
            Console.WriteLine("the cooridnate of the center is {0}, the radius value is {1}", center, miniRadius));

            return miniRadius;
        }
    }
}

原文：http://blog.csdn.net/whai362/article/details/46980471#comments

C# TransactionScope.Complete 方法如何使用

2023年1月10日 by admin·0评论

示例

以下示例演示如何使用 TransactionScope 类定义代码块以参与事务。


C#

复制
// This function takes arguments for 2 connection strings and commands to create a transaction 
// involving two SQL Servers. It returns a value > 0 if the transaction is committed, 0 if the 
// transaction is rolled back. To test this code, you can connect to two different databases 
// on the same server by altering the connection string, or to another 3rd party RDBMS by 
// altering the code in the connection2 code block.
static public int CreateTransactionScope(
    string connectString1, string connectString2,
    string commandText1, string commandText2)
{
    // Initialize the return value to zero and create a StringWriter to display results.
    int returnValue = 0;
    System.IO.StringWriter writer = new System.IO.StringWriter();

    try
    {
        // Create the TransactionScope to execute the commands, guaranteeing
        // that both commands can commit or roll back as a single unit of work.
        using (TransactionScope scope = new TransactionScope())
        {
            using (SqlConnection connection1 = new SqlConnection(connectString1))
            {
                // Opening the connection automatically enlists it in the 
                // TransactionScope as a lightweight transaction.
                connection1.Open();

                // Create the SqlCommand object and execute the first command.
                SqlCommand command1 = new SqlCommand(commandText1, connection1);
                returnValue = command1.ExecuteNonQuery();
                writer.WriteLine("Rows to be affected by command1: {0}", returnValue);

                // If you get here, this means that command1 succeeded. By nesting
                // the using block for connection2 inside that of connection1, you
                // conserve server and network resources as connection2 is opened
                // only when there is a chance that the transaction can commit.   
                using (SqlConnection connection2 = new SqlConnection(connectString2))
                {
                    // The transaction is escalated to a full distributed
                    // transaction when connection2 is opened.
                    connection2.Open();

                    // Execute the second command in the second database.
                    returnValue = 0;
                    SqlCommand command2 = new SqlCommand(commandText2, connection2);
                    returnValue = command2.ExecuteNonQuery();
                    writer.WriteLine("Rows to be affected by command2: {0}", returnValue);
                }
            }

            // The Complete method commits the transaction. If an exception has been thrown,
            // Complete is not  called and the transaction is rolled back.
            scope.Complete();
        }
    }
    catch (TransactionAbortedException ex)
    {
        writer.WriteLine("TransactionAbortedException Message: {0}", ex.Message);
    }

    // Display messages.
    Console.WriteLine(writer.ToString());

    return returnValue;
}

注解

如果确信范围内的所有操作都已成功完成，则只应调用此方法一次，以通知事务管理器所有资源的状态都是一致的，并且可以提交事务。最好将调用作为块中的 using 最后一个语句。

未能调用此方法会中止事务，因为事务管理器将此解释为系统故障或在事务范围内引发的异常。但是，还应注意，调用此方法并不能保证事务的提交。它只是一种将状态通知给事务管理器的方式。调用此方法后，无法再通过 Current 属性访问环境事务，并且尝试这样做会导致引发异常。

如果 TransactionScope 对象创建了事务，则资源管理器之间的实际提交工作将发生在 End Using 语句中。如果该对象未创建事务，则每当 Commit 对象的所有者调用 CommittableTransaction 时都会执行提交。此时，事务管理器会调用资源管理器，并根据是否在对象上 TransactionScope 调用此方法来通知它们提交或回滚。

24K PLUS

键盘侠的日志

分类： Csharp

Visual Studio 语言设置

C#.NET 高性能序列化组件：MessagePack

C# 使用正则表达式替换字符串

一个深度克隆PooledList示例方法

一个 .net core 7.0 的 dockerfile 示例

C#.NET 使用管理对象提供的WMI获取显卡信息

C#.NET 利用PerformanceCounter类获取CPU各个核心使用率

C# 模拟退火算法实例

C# TransactionScope.Complete 方法如何使用

示例

注解