C#常用合集

字符串

数字字符串互转

• 数字转字符串

    string str = num.ToString();
    str = num + "";

• 数组转字符串

    int[] nums = {1, 2, 3, 4, 5};
    string str = string.Join(",", nums);

若对数组使用ToString()，返回的是数组类型的名称，如

strNums = nums.ToString()

输出为

System.Int32[]。

连接字符串

1. 使用+运算符

   str = str1 + " " + str2;

2. 使用String.Concat()

   res = String.Concat(str1, ",", str2)

3. 使用StringBuilder类：

StringBuilder sb = new StringBuilder();
sb.Append("Hello");
sb.Append(" ");
sb.Append("World");
string result = sb.ToString();

使用StringBuilder类在连接大量字符串时效率更高，因为可以避免每次连接都创建一个新的字符串对象。

使用特定分隔符将数组连接成字符串 string.Join(',', List<string>)

使用Concat方法可以将两个数组连接起来： 创建了一个新数组，其中包含两个原始数组的元素。

int[] arr1 = {1,2,3}
int[] arr2 = {4,5,6}
int[] concatArr = arr1.Concat(arr2).ToArray();

字符串插值

int x = 5;
int y = 10;
string result = $"The sum of {x} and {y} is {x + y}.";

使用@符号的字符串插值：

string name = "Alice";
int age = 25;
string sentence = $@"My name is {name} and I am {age} years old.";

使用 @ 符号的字符串插值可以避免在字符串中使用转义字符。

对象拷贝

浅拷贝vs深拷贝：

• 浅拷贝指对象中的值类型字段拷贝到新对象中，引用类型复制一个引用到目标对象。
• 深拷贝不仅复制对象值类型，也复制对象，相当于创建了一个新对象，将当前对象的多有字段进行逐位复制并支持递归（不管值类型还是引用类型，不管静态字段还是非静态字段）。

注：string类型浅拷贝作值类型对象处理。

浅拷贝

使用Object类MemberwiseClone：创建当前Object的浅表副本。

public class Person{
    public int Age {get; set;}
    public string Name {get; set;}
    public OtherAttr Other {get; set;}
    public object Clone(){
        return this.MemberwiseClone();
    }
}

赋值操作(=)vs使用MemberwiseClone:浅拷贝对引用类型中的值类型字段进行了逐位复制，赋值运算符只是把源对象的引用赋值给目的对象。浅拷贝后对象的值类型字段更改不影响源对象，而赋值运算符会。

深拷贝

1. 实现ICloneable接口，自定义拷贝功能。ICloneable接口包含一个成员Clone。

public class Person: ICloneable{
    public int Age {get; set;}
    public string Name {get; set;}
    public OtherAttr Other {get; set;}
    public object Clone(){
        Person tem = new Person();
        tem.Age = this.Age;
        tem.Name = this.Name;
        tem.Name = this.Name;
        tem.Other = new OtherAttr(this.Other);
        return tem;
    }
}

2. 反射机制实现

public static T DeepCopyByReflection<T>(T obj){
    if(obj is string || obj.GetType().IsValueType){
        return obj;
    }
    object val = Activator.CreateInstance(obj.GetType());
    FieldInfo[] fields = obj.GetType().GetFields();
    foreach(var field in fields){
        try{
            field.SetValue(val, DeepCopyByReflection(field.GetValue(obj)));
        }
        catch{}
    }
    return (T)val;
}

3. 序列化/反序列化实现

• 序列化是将对象或对象图形转换为线性字节序列，以存储或传输到另一个位置的过程。
• 反序列化是接受存储的信息并利用它重新创建对象的过程。
  使用序列化和反序列化，需要标记可序列化类型，即添加特性(Attribute)[Serializable]。

public static T DeepCopyByBinary<T>(T obj){
    object val;
    using(MemoryStream ms = new MemoryStream()){
        BinaryFormatter bf = new BinaryFormatter();
        bf.Serialize(ms, obj);
        ms.Seek(0, SeekOrigin.Begin);
        val = bf.Deserialize(ms);
        ms.Close();
    }
    return (T)val;
}

• DataSet的两个方法对比：Clone vs Copy
  • Clone：复制DataSet的架构、关系、约束，不复制数据。
  • Copy：复制DataSet的结构和数据。

利用itextSharp实现pdf合并

public static void Main(string[] args)
{
    string[] pdfFiles = { @"合并导出202306270211.pdf", @"合并导出202306270251.pdf" }; // 要合并的 PDF 文件路径
    string outputFile = @"C:\Users\10051\Desktop\merged.pdf"; // 合并后的输出文件路径
    MergePdfFiles(pdfFiles, outputFile);
    Console.WriteLine("PDF files merged successfully!");
}

public static void MergePdfFiles(string[] pdfFiles, string outputFile)
{
    using (FileStream stream = new FileStream(outputFile, FileMode.Create))
    {
        Document document = new Document();
        PdfCopy pdf = new PdfCopy(document, stream);
        document.Open();
        foreach (string file in pdfFiles)
        {
            PdfReader reader = new PdfReader(file);
            for (int i = 1; i <= reader.NumberOfPages; i++)
            {
                PdfImportedPage page = pdf.GetImportedPage(reader, i);
                pdf.AddPage(page);
            }
            reader.Close();
        }
        document.Close();
    }
}

排序方法

1. 使用Sort降序排序

   nodes.Sort((b, a)=>{return a.Cost.ComperaTo(b.Cost);})

   CompareTo 方法返回一个整数，表示两个对象的相对顺序。返回值的含义如下：

   • 如果调用对象小于传入对象，则返回一个负数（通常是 -1）。
   • 如果调用对象等于传入对象，则返回 0。
   • 如果调用对象大于传入对象，则返回一个正数（通常是 1）。

//重写排序：
class Obj{
    public int rank = 0;
    public string word = null;
}
public static int MySort(Obj A, Obj B){
    return B.rank.CompareTo(A.rank);
}
List<Obj> lst = new List<Obj>();
lst.Sort(MySort);

2. 使用LINQ排序

//LINQ方法语法：
int[] numbers = { 5, 2, 8, 1, 9 };
var sortedNumbers = numbers.OrderBy(num => num);
//LINQ查询语法：
var sortedNumbers = from num in numbers
                orderby num ascending
                select num;

//对字典排序重组
Dictionary<int, string> paths = new Dictionary<int, string>(){
    {1,"test1"},
    {3,"test5"},
    {2,"test6"}
}
string[] sortedArr = paths.OrderBy(pair => pair.Key).Select(pair => pair.Value).ToArray();