• 公共方法 StartsWith(String) 确定此字符串实例的开头是否与指定的字符串匹配。
• 公共方法 StartsWith(String, StringComparison) 确定在使用指定的比较选项进行比较时此字符串实例的开头是否与指定的字符串匹配。
• 公共方法 StartsWith(String, Boolean, CultureInfo) 确定在使用指定的区域性进行比较时此字符串实例的开头是否与指定的字符串匹配。
• 公共方法 Trim() 从当前 String 对象移除所有前导空白字符和尾部空白字符。
• 公共方法 Trim(Char[]) 从当前 String 对象移除数组中指定的一组字符的所有前导匹配项和尾部匹配项。
• 公共方法 TrimEnd 从当前 String 对象移除数组中指定的一组字符的所有尾部匹配项。
• 公共方法 TrimStart 从当前 String 对象移除数组中指定的一组字符的所有前导匹配项。
• 公共方法 IndexOf  从当前String的0索引开始查找第一次出现指定的字符与字符串，如果没有找到则返回-1。
• Equals ：确定两个String对象是否具有相同的值。String.Equals Method (System) | Microsoft Learn
• ToCharArray  ：将String实例中的字符复制到 Unicode 字符数组。

public char[] ToCharArray ();
//返回值：一个 Unicode 字符数组（Char数组），其元素是该实例的各个字符。如果此实例是空字符串，则返回的数组为空且长度为零。
public char[] ToCharArray (int startIndex, int length);
//startIndex：String实例中子字符串的起始位置。length：String实例中子字符串的长度。返回值：一个 Unicode 字符数组（Char数组），其元素是此实例中从字符位置 startIndex 开始的字符长度。

• Split：已指定的Unicode字符（Char）和字符串（string）对目标字符串进行分割。返回一个字符串数组； String.Split Method (System) | Microsoft Learn

System.Linq.Enumerable

• 公共方法 静态成员  All<TSource> 确定序列中的所有元素（TSource）是否满足条件。
• 公共方法 静态成员  Any<TSource>(IEnumerable<TSource>) 确定序列是否包含任何元素（TSource）。
• 公共方法 静态成员  Any<TSource>(IEnumerable<TSource>, Func<TSource, Boolean>) 确定序列中是否存在元素（TSource）满足条件。

public class CaseInsensitiveComparer : IComparer<string>
{
    public int Compare(string x, string y)
    {
        return string.Compare(x, y, true);
    }
}

public static void ThenByDescendingEx1()
{
    string[] fruits = { "apPLe", "baNanA", "apple", "APple", "orange", "BAnana", "ORANGE", "apPLE" };

    // Sort the strings first ascending by their length and
    // then descending using a custom case insensitive comparer.
    IEnumerable<string> query =
        fruits
        .OrderBy(fruit => fruit.Length)//返回值类型IOrderedEnumerable<TSource>
        .ThenByDescending(fruit => fruit, new CaseInsensitiveComparer());

    foreach (string fruit in query)
    {
        Console.WriteLine(fruit);
    }
}

/*
    This code produces the following output:

    apPLe
    apple
    APple
    apPLE
    orange
    ORANGE
    baNanA
    BAnana
*/

• 求两个集合之间的交集：Enumerable.Intersect<TSource>(IEnumerable<Tsource> first,IEnumerable<TSource> second);异常：first或者second为空
• First<TSource>(this IEnumerable<TSoure> soure,Func<TSoure,Boolean> predicate) ：返回第一个满足条件的元素；异常：source或者predicate为空。如果没有找到匹配的元素将会引发异常。要在未找到匹配元素时返回默认值，可以使用 FirstOrDefault 方法。

List的底层实现:

一个 List<T> 的字符串创建并填充 5 个字符串。创建一个空字符串数组 15 个元素，
与 CopyTo(T[]) 方法重载可用于将列表的所有元素都复制到数组的第一个元素开始的数组。 
CopyTo(T[], Int32) 方法重载可用于所有的元素复制到数组索引 6 开头数组列表 （将索引 5 留为空）。
最后， CopyTo(Int32,T[], Int32, Int32) 使用方法重载来复制从列表中，索引 2 开始的 3 个元素，使用到数组开头的数组索引 12 （将索引 11 留为空）。然后显示该数组的内容。
using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Brachiosaurus");
        dinosaurs.Add("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        // Declare an array with 15 elements.
        string[] array = new string[15];

        dinosaurs.CopyTo(array);
        dinosaurs.CopyTo(array, 6);
        dinosaurs.CopyTo(2, array, 12, 3);

        Console.WriteLine("\nContents of the array:");
        foreach(string dinosaur in array)
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Compsognathus

Contents of the array:
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Compsognathus

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Compsognathus

Mamenchisaurus
Brachiosaurus
Compsognathus
 */

Dictionary<TKey,TValue>

• TryAdd(Tkey key,TValue value): 

public virtual object Peek()
    {
      if (this.Count == 0)
        throw new InvalidOperationException("Queue empty.");
      return this._array[this._head];
    }

判断某个值是否处于队列中：

public virtual bool Contains(object obj)
    {
      int index = this._head;
      int size = this._size;
      while (size-- > 0)
      {
        if (obj == null)
        {
          if (this._array[index] == null)
            return true;
        }
        else if (this._array[index] != null && this._array[index].Equals(obj))
          return true;
        index = (index + 1) % this._array.Length;
      }
      return false;
    }

获取元素：

    internal object GetElement(int i) => this._array[(this._head + i) % this._array.Length];

Stack 栈

主要字段 ：
object[] _array  用于存储数据
int _size 栈中数据的长度

进栈操作：

public virtual void Push(object obj)
    {
      if (this._size == this._array.Length)
      {
        object[] destinationArray = new object[2 * this._array.Length];
        Array.Copy((Array) this._array, 0, (Array) destinationArray, 0, this._size);
        this._array = destinationArray;
      }
      this._array[this._size++] = obj;
      ++this._version;
    }

出栈操作：

public virtual object Pop()
    {
      if (this._size == 0)
        throw new InvalidOperationException("Stack empty.");
      ++this._version;
      object obj = this._array[--this._size];
      this._array[this._size] = (object) null;
      return obj;
    }

取栈顶元素：

public virtual object Peek()
    {
      return this._size != 0 ? this._array[this._size - 1] : throw new InvalidOperationException("Stack empty.");
    }

判断某个值是否处于栈中：

public virtual bool Contains(object obj)
    {
      int size = this._size;
      while (size-- > 0)
      {
        if (obj == null)
        {
          if (this._array[size] == null)
            return true;
        }
        else if (this._array[size] != null && this._array[size].Equals(obj))
          return true;
      }
      return false;
    }