文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

适合每位开发人员的 60 个 C# 代码片段

2024-11-30 09:58

关注

嘿！ 今天，我有一些特别的东西要与大家分享 - 60 个 C# 代码片段的汇编，我发现它们对我自己的工作非常有帮助。

在本文中，我们不仅要了解这些片段如何解决日常编程问题，还要了解它们为何如此工作。 这是为了建立更深入的理解，而不仅仅是快速复制粘贴工作。

如果您一直在使用 C# 并且曾经发现自己陷入问题，不确定如何有效地解决它，那么这些片段适合您。 如果您对 C# 比较陌生并且正在尝试了解如何更有效地使用该语言，那么它们也适合您。

好了，说够了。 让我们一起开始探索这些代码片段。 我希望你发现它们和我一样有用。

在我们继续之前，在提供的示例中，我尝试添加一点幽默感并列出一些用例。 希望这也能让你开心，因为至少我总是更容易记住有趣的事情:)让我们开始吧！

10 个复杂的所有类型片段

1、二分查找

public int BinarySearch(int[] arr, int target)
{
    int left = 0;
    int right = arr.Length - 1;
    while (left <= right)
    {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target)
            return mid;
        if (arr[mid] < target)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return -1;
}

将此代码视为搜索方法中的福尔摩斯。 您知道，与其浪费时间到处寻找特定的物品，不如直接切入正题不是很好吗？ 这正是二分查找的作用——它通过划分和征服来节省你的时间（和理智）！

用例：

2、冒泡排序

public void BubbleSort(int[] arr)
{
    int len = arr.Length;
    for (int i = 0; i < len - 1; i++)
        for (int j = 0; j < len - i - 1; j++)
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
}

就像你有时把所有衣服扔到空中然后排列它们一样（来吧，我们都会这样做，对吧？），冒泡排序会随机排列数组中的数字，直到它们处于完美的顺序。 虽然这不是最快的排序，但它绝对是一个有趣的观看方式。

用例：

3、图上的深度优先搜索（DFS）

public void DFS(int v, bool[] visited, List[] adj)
{
    visited[v] = true;
    Console.Write(v + " ");
    foreach (int neighbour in adj[v])
    {
        if (!visited[neighbour])
            DFS(neighbour, visited, adj);
    }
}

DFS就像那个朋友，当你们一起去徒步旅行时，只需探索每一个角落。 在考虑尝试一条新道路之前，它会尽可能深入地探索一条道路。 当您需要对图表的所有节点进行彻底、全面的搜索时，请使用它。

用例：

4、斐波那契数列

public void PrintFibonacci(int n)
{
    int a = 0, b = 1, c;
    for(int i = 0; i < n; i++)
    {
        Console.Write(a + " ");
        c = a + b;
        a = b;
        b = c;
    }
}

想要享受一些优雅的数字吗？ 斐波那契数列就像数字的交响曲，每个数字都是前两个数字的和谐融合。 此代码片段可帮助您生成由“n”项组成的斐波那契数列。

用例：

5、阶乘计算

public int Factorial(int n)
{
    if (n == 0)
        return 1;
    else
        return n * Factorial(n - 1);
}

还记得你以为自己可以吃无数块饼干，然后意识到自己可能吃不完 10 块吗？ 嗯，阶乘有点像这样——它们涉及将所有正整数乘以某个数字，并且它们很快就会变大！ 当您需要计算阶乘时，请使用此代码片段。

用例：

6、矩阵乘法

public int[,] MultiplyMatrix(int[,] a, int[,] b)
{
    int[,] result = new int[a.GetLength(0),b.GetLength(1)];
    for (int i = 0; i < result.GetLength(0); i++)
    {
        for (int j = 0; j < result.GetLength(1); j++)
        {
            result[i, j] = 0;
            for (int k = 0; k < a.GetLength(1); k++) // or k

矩阵乘法就像一个聚会，其中第一个矩阵的每一行都与第二个矩阵的每一列混合在一起。 结果呢？ 一个全新的矩阵，其元素是根据乘法对的总和创建的。 因此，当您希望矩阵举办派对时，此片段将成为您的 DJ！

用例：

7、回文检查器

public bool IsPalindrome(string str)
{
    str = str.ToLower();
    int i = 0, j = str.Length - 1;
    while (i < j)
    {
        if (str[i++] != str[j--])
            return false;
    }
    return true;
}

如果您不确定某个单词或短语是否是秘密回文，此功能可以为您提供支持。

用例：

8、埃拉托斯特尼筛法（查找 n 以内的所有素数）

public List SieveOfEratosthenes(int n)
{
    bool[] prime = new bool[n + 1];
    for (int i = 0; i <= n; i++)
        prime[i] = true;

    for (int p = 2; p * p <= n; p++)
    {
        if (prime[p] == true)
        {
            for (int i = p * p; i <= n; i += p)
            {
                prime[i] = false;
            }
        }
    }

    List primeNumbers = new List();

    for (int i = 2; i <= n; i++)
    {
        if (prime[i])
        {
            primeNumbers.Add(i);
        }
    }

    return primeNumbers;
}

埃拉托斯特尼筛法是一种古老（但却是黄金）的算法，用于找出给定数字“n”之前的所有素数。 这就像一个筛子筛掉合数，只留下素数。

用例：

9、快速排序算法

public void QuickSort(int[] arr, int low, int high)
{
    if (low < high)
    {
        int pi = Partition(arr, low, high);
        QuickSort(arr, low, pi - 1);
        QuickSort(arr, pi + 1, high);
    }
}

int Partition(int[] arr, int low, int high)
{
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high - 1; j++)
    {
        if (arr[j] < pivot)
        {
            i++;
            Swap(arr, i, j);
        }
    }
    Swap(arr, i + 1, high);
    return (i + 1);
}

void Swap(int[] arr, int a, int b)
{
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

QuickSort，顾名思义，是一种快速高效的排序算法。 它选择一个主元元素，然后围绕该主元对数组进行分区。

用例：

10、查找链表的长度（迭代）

public int GetLength(ListNode head)
{
    int count = 0;
    ListNode current = head;
    while (current != null)
    {
        count++;
        current = current.next;
    }
    return count;
}

这个函数会遍历链表，就像你来回踱步一样，不耐烦地等待你的咖啡因修复，并计算节点的数量。

用例：

10 个词典片段

1、使用Linq 填充字典

string[] fruits = { "apple", "banana", "cherry" };
var fruitsDictionary = fruits.Select((fruit, index) => new { fruit, index })
                             .ToDictionary(x => x.fruit, x => x.index);

我们都注重效率，Linq 是一个很棒的工具，可以帮助我们在单个语句中填充字典。 在此代码片段中，我将获取一个水果数组并将其转换为字典，使用水果名称作为键，使用索引作为值。

用例：

2、创建嵌套字典

Dictionary> nestedDictionary =
    new Dictionary>();
nestedDictionary["Fruits"] = new Dictionary { { "Apple", 1 }, { "Banana", 2 } };

嵌套字典就像数据结构的初始：字典中的字典。 当您需要存储复杂的数据并且需要维护不同实体之间的关系时，这些功能非常有用。

用例：

3、使用ConcurrentDictionary进行线程安全操作

ConcurrentDictionary concurrentDictionary = new ConcurrentDictionary();
concurrentDictionary.TryAdd("Apple", 1);
concurrentDictionary.TryUpdate("Apple", 2, 1);

当您需要同时添加或更新条目时，它可确保线程安全操作。 这就像在繁忙的十字路口有一个交通管制员。

用例：

4、使用 Linq 按键对字典进行排序

Dictionary fruits = new Dictionary { { "Apple", 1 }, { "Banana", 2 }, { "Cherry", 3 } };
var sortedDictionary = fruits.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value);

有时，按键对字典进行排序可能是一个方便的功能，特别是当您想要按特定顺序显示条目时。 使用 Linq，您可以轻松实现这一点，使您的字典成为一个有序的集合。

用例：

5、字典作为简单的缓存

public class SimpleCache
{
    private Dictionary cache = new Dictionary();
    public TValue Get(TKey key, Func valueFactory)
    {
        if (!cache.TryGetValue(key, out TValue value))
        {
            value = valueFactory(key);
            cache[key] = value;
        }
        return value;
    }
}

我觉得这特别酷。 使用字典，您可以构建一个简单的缓存，以避免昂贵的计算或网络调用。 您可以使用密钥和工厂函数调用 Get。 如果键不在字典中，它将使用该函数创建值，将其添加到字典中，然后返回它。

用例：

6、UsingDictionary.ValueCollection

Dictionary fruits = new Dictionary { { "Apple", 1 }, { "Banana", 2 } };
Dictionary.ValueCollection fruitValues = fruits.Values;

许多人忘记了可以使用 Values 属性将字典值作为集合直接访问。 当您只需要使用字典中的值而不是键时，这会很方便。

用例：

7、使用 AsParallel 进行并行操作

Dictionary largeDictionary = ... // Large dictionary
var modifiedDictionary = largeDictionary.AsParallel().Select(kvp => new { kvp.Key, Value = kvp.Value * 2 }).ToDictionary(x => x.Key, x => x.Value);

LINQ 中的 AsParallel 方法提供了一种并行执行操作的方法，这可以在处理大型字典时显着提高性能。 请注意，您应该谨慎使用它，因为它可能不会为较小的字典带来好处，甚至可能由于并行性的开销而降低性能。

用例：

8、UsingDictionary.KeyCollection

Dictionary fruits = new Dictionary { { "Apple", 1 }, { "Banana", 2 } };
Dictionary.KeyCollection fruitKeys = fruits.Keys;

与我们之前讨论的 ValueCollection 类似，KeyCollection 使您可以直接访问字典中的键。 这是迭代键而不用担心值的好方法。

用例：

9、使用HashSet删除重复项

Dictionary fruitsWithDuplicates = new Dictionary { { "Apple", 1 }, { "Apple", 1 }, { "Banana", 2 } };
Dictionary fruitsWithoutDuplicates = new HashSet(fruitsWithDuplicates.Keys).ToDictionary(x => x, x => fruitsWithDuplicates[x]);

HashSet 是一个经常被忽视但功能强大的工具，用于从集合中删除重复项。 当与字典结合使用时，它可以用于删除重复的键并创建新的字典。

用例：

10、使用SortedDictionary进行自动排序

SortedDictionary sortedFruits = new SortedDictionary { { "Apple", 1 }, { "Banana", 2 } };

SortedDictionary 自动对字典中的键进行排序。 当您不断需要数据处于排序状态时，它会很有用。 但请注意，排序过程可能会带来性能成本。

用例：

10 个线程片段

1、任务.运行快捷方式

Task.Run(() => 
{
    // Long running operation...
});

Task.Run 是启动后台任务的便捷快捷方式。 这相当于创建一个新任务然后调用 Start()，但代码更少。 谁不喜欢简洁？

用例：

2、取消令牌

CancellationTokenSource cts = new CancellationTokenSource();
Task.Run(() => 
{
    // Check the cancellation token regularly
    while (!cts.Token.IsCancellationRequested)
    {
        // Do some work...
    }
}, cts.Token);

// Cancel the task
cts.Cancel();

取消令牌可让您优雅地停止正在执行的任务。 这就像友好地拍一下你的肩膀，告诉你的任务是时候停止了。

用例：

3、使用Interlocked.Increment进行安全更新

int counter = 0;
Parallel.For(0, 10000, i => Interlocked.Increment(ref counter));

Interlocked 类为多个线程共享的变量提供原子操作。 Interlocked.Increment 是一种在多线程环境中安全递增计数器的方法。 它确保您的计数不会错过任何一个节拍。

用例：

4、与Mutex同步

Mutex mutex = new Mutex();
mutex.WaitOne();
try 
{
    // Do some work...
}
finally 
{
    mutex.ReleaseMutex();
}

互斥体就像线程的红绿灯。 它们确保一次只有一个线程可以访问一段代码，从而防止出现令人不快的意外情况。

用例：

5、使用BlockingCollection进行线程安全数据处理

BlockingCollection data = new BlockingCollection();
Task.Run(() => 
{
    while (!data.IsCompleted) 
    {
        int item;
        if (data.TryTake(out item))
        {
            // Process item...
        }
    }
});

BlockingCollection 提供了一种线程安全的方式来跨多个线程处理数据。 这就像为您的共享数据提供一个安全的保管库。

用例：

6、任务延续 withContinueWith

Task t = Task.Run(() => 42);
t.ContinueWith((antecedent) => Console.WriteLine(antecedent.Result));

任务延续允许您指定任务完成后应该发生的情况。 这就像设置一排多米诺骨牌，其中一个会触发下一个。

用例：

7、任务中的异常处理

Task task = Task.Run(() => { throw new Exception("Oops!"); });
try 
{
    task.Wait();
} 
catch (AggregateException ex) 
{
    Console.WriteLine(ex.InnerExceptions[0].Message);  // Prints "Oops!"
}

如果任务中的异常处理不正确，可能会导致整个应用程序崩溃。 通过这个技巧，您可以优雅地处理任务中的异常，就像处理一杯香槟一样。

用例：

8、ThreadLocal 的线程本地存储

ThreadLocal threadLocal = new ThreadLocal(() => 42);
Console.WriteLine(threadLocal.Value);  // Prints 42

ThreadLocal 允许您定义每个线程唯一的数据。 这就像为每个线程提供了自己的私有存储柜。

用例：

9、使用SemaphoreSlim限制并发

SemaphoreSlim semaphore = new SemaphoreSlim(2);  // Limit to 2 threads
Task.Run(() => 
{
    semaphore.Wait();
    try 
    {
        // Do some work...
    }
    finally 
    {
        semaphore.Release();
    }
});

信号量非常适合控制对容量有限的资源的访问。 它就像夜总会的保镖，控制可以进入的线程数量。

用例：

10、跨线程同步的手动重置事件

ManualResetEvent mre = new ManualResetEvent(false);
Task.Run(() => 
{
    // Wait for the event to be set
    mre.WaitOne();
    // Do some work...
});
// Set the event
mre.Set();

手动重置事件是跨多个线程同步操作的绝佳工具。 它就像比赛中的发令枪，向所有线程发出开始运行的信号。

用例：

10 个集合片段

1、只读集合

List myList = new List {"A", "B", "C"};
ReadOnlyCollection myReadOnlyList = myList.AsReadOnly();

您可以使用 AsReadOnly 方法创建只读集合。 这可以确保集合不会被意外修改，这在处理重要数据时至关重要。 就像博物馆里的无价之宝一样，它只能看，但不能触摸！

用例：

2、隐式类型数组

var array = new[] { "A", "B", "C" };

您可以使用 new[] 关键字创建隐式类型数组。 这可以节省输入并保持代码干净简单。 这就像数组创建的洗碗机！

用例：

3、队列和堆栈

Queue queue = new Queue();
queue.Enqueue(1);
queue.Enqueue(2);
int first = queue.Dequeue();

Stack stack = new Stack();
stack.Push(1);
stack.Push(2);
int last = stack.Pop();

Queue 和 Stack 类提供了处理有序集合的有效方法。 队列遵循“先进先出”(FIFO) 策略，堆栈遵循“后进先出”(LIFO) 策略。 这些非常适合模拟现实世界的情况，例如售票亭的队列或一堆盘子。

用例：

4、用于快速查找的HashSet

HashSet hashSet = new HashSet { "A", "B", "C" };
bool containsA = hashSet.Contains("A");  // True

HashSet 是一个提供快速查找特定元素是否存在的集合。 它就像收藏界的 Google，只是速度更快！

用例：

5、LINQ查询

List list = new List { 1, 2, 3, 4, 5 };
IEnumerable evenNumbers = list.Where(x => x % 2 == 0);

LINQ 提供了一种强大的声明性方式来查询集合。 只需一行代码，您就可以进行过滤、排序、转换等等。 这就像您的收藏有一位私人助理！

用例：

6、可观察集合

ObservableCollection collection = new ObservableCollection();
collection.CollectionChanged += (s, e) => {  };
collection.Add("A");

可观察集合使您可以轻松地对集合中的更改做出反应。 这就像每当有人发布新的猫视频时都会收到通知！

用例：

7、并发收集

ConcurrentDictionary concurrentDictionary = new ConcurrentDictionary();

System.Collections.Concurrent 命名空间提供了多个可以在多个线程中安全使用的集合。 这使您不必处理锁和其他同步原语。 它就像一个预先打包的、无麻烦的多线程解决方案！

用例：

8、IComparer和IEqualityComparer接口

class MyComparer : IComparer
{
    public int Compare(int x, int y)
    {
        // Reverse order
        return y.CompareTo(x);
    }
}

List list = new List { 1, 2, 3, 4, 5 };
list.Sort(new MyComparer());

IComparer 和 IEqualityComparer 接口允许您自定义元素的比较方式以及它们是否被视为相等。 这就像决定自己的游戏规则一样！

用例：

9、使用GroupBy对元素进行分组

List list = new List { 1, 2, 3, 4, 5 };
var groups = list.GroupBy(x => x % 2 == 0 ? "Even" : "Odd");

GroupBy 方法允许您根据特定标准对元素进行分组。 这就像按颜色和尺寸整理袜子抽屉一样！

用例：

10、AnyandAll方法

List list = new List { 1, 2, 3, 4, 5 };
bool anyEven = list.Any(x => x % 2 == 0);  // True
bool allPositive = list.All(x => x > 0);  // True

Any 和 All 方法提供了一种声明性方式来检查集合中的任何或所有元素是否满足条件。 这就像快速检查盒子里是否还有巧克力，或者篮子里的所有苹果是否都熟了！

用例：

10 个代表和活动片段

1、组播代表

Action action1 = x => Console.WriteLine($"Action 1: {x}");
Action action2 = x => Console.WriteLine($"Action 2: {x}");

Action combined = action1 + action2;
combined(5);  // Executes both actions

您可以将多个委托合并为一个多播委托。 这就像邀请所有朋友参加同一个聚会！

用例：

2、弱事件模式

public class WeakEventHandler
{
    private readonly WeakReference _targetReference;
    private readonly MethodInfo _method;

    public WeakEventHandler(EventHandler eventHandler)
    {
        _targetReference = new WeakReference(eventHandler.Target);
        _method = eventHandler.Method;
    }

    public void Invoke(object sender, TEventArgs e)
    {
        if (_targetReference.IsAlive)
            _method.Invoke(_targetReference.Target, new object[] { sender, e });
    }
}

即使事件源仍然存在，弱事件模式也允许对侦听器进行垃圾收集。 这就像在没有人注意到的情况下离开聚会一样！

用例：

3、通用委托

public delegate TResult MyFunc(T1 arg1, T2 arg2);

您可以定义适用于任何类型的通用委托。 它就像代表代表类型的瑞士军刀！

用例：

4、具有自定义 EventArgs 的事件

public class MyEventArgs : EventArgs
{
    public string Message { get; set; }
}

public class MyClass
{
    public event EventHandler MyEvent;
    protected virtual void OnMyEvent(string message)
    {
        MyEvent?.Invoke(this, new MyEventArgs { Message = message });
    }
}

您可以定义自定义 EventArgs 以提供有关事件的更多信息。 这就像发送详细的报告而不是简短的通知！

用例：

5、委托中的协变和逆变

Func objectFunc = () => new object();
Func stringFunc = objectFunc;  // Covariance

Action stringAction = str => Console.WriteLine(str);
Action objectAction = stringAction;  // Contravariance
协变和逆变允许您以保留类型兼容性的方式分配委托。 这就像将方钉安装到圆孔中，但是以类型安全的方式！
用例：
  • 当您需要互相分配代表时。
  • 创建更灵活且可重用的委托代码。
6、匿名代表
Func square = delegate(int x) { return x * x; };
您可以匿名定义委托，而无需声明单独的方法。 这就像创建一家快闪店而不是一家永久性商店！
用例：
  • 当您想内联定义委托时。
  • 让委托代码靠近使用它的地方。
7、异步委托
Func slowFunc = x => { Thread.Sleep(1000); return x * x; };
IAsyncResult asyncResult = slowFunc.BeginInvoke(5, null, null);
// Do other work...
int result = slowFunc.EndInvoke(asyncResult);  // Waits for the result
您可以使用 BeginInvoke 和 EndInvoke 方法异步执行委托。 这就像写信而不是打电话一样！
用例：
  • 当您需要执行长时间运行的操作时。
  • 让您的 UI 保持响应能力。
8、委托作为实例变量
class MyClass
{
    private Func _myFunc = x => x * x;
    public void SetFunc(Func func)
    {
        _myFunc = func;
    }
    public int Compute(int x)
    {
        return _myFunc(x);
    }
}
您可以使用委托作为实例变量来创建高度可定制的类。 这就像在汽车行驶时更换发动机一样！
用例：
  • 当您需要自定义类的行为时。
  • 创建灵活且可扩展的类。
9、EventHandler委托
public class MyClass
{
    public event EventHandler MyEvent;
    protected virtual void OnMyEvent(string value)
    {
        MyEvent?.Invoke(this, value);
    }
}
EventHandler 委托提供了声明事件的标准方法。 这就像在活动中普遍接受的握手！
用例：
  • 当你需要声明一个事件时。
  • 确保您的事件与 .NET 约定兼容。
10、代表表达
Func isEven = x => x % 2 == 0;
List numbers = Enumerable.Range(0, 10).ToList();
List evenNumbers = numbers.Where(isEven).ToList();
委托是封装表达式并传递它们的好方法。 这就像在你的口袋里携带一个便携式数学方程！
用例：
  • 当您需要传递复杂的表达式时。
  • 让您的代码更具表现力和灵活性。
10 个异常处理片段
1、Try-Catch-Finally 语句
try
{
    // Potentially dangerous code here...
}
catch (SpecificException ex)
{
    // Handle a specific exception
}
catch
{
    // Handle any other exceptions
}
finally
{
    // Cleanup code that always executes
}
经典的 try-catch-finally 语句。 它就像一张安全网，可以防止任何意外的空中飞人跌倒！
用例：
  • 执行可能抛出异常的代码时。
  • 确保清理代码始终运行。
2、抛出新的异常
catch (Exception ex)
{
    throw new MyException("Something bad happened", ex);
}
使用附加信息重新引发异常。 这就像退回有缺陷的产品，但附有投诉信！
用例：
  • 当您需要向异常添加附加信息时。
  • 创建详细的异常历史记录。
3、过滤异常
catch (Exception ex) when (ex.Message.Contains("specific"))
{
    // Handle the exception
}
根据条件过滤异常。 它就像一个例外的保镖，只允许某些人进入！
用例：
  • 当你只想处理某些异常时。
  • 创建更具可读性和更高效的异常处理代码。
4、内部异常
catch (Exception ex)
{
    Console.WriteLine(ex.InnerException);
}
访问异常的内部异常。 就像剥洋葱，露出它的层一样！
用例：
  • 当您需要发现异常的根本原因时。
  • 显示或记录更详细的异常信息。
5、聚合异常
try
{
    // Parallel or async code that throws multiple exceptions...
}
catch (AggregateException ae)
{
    ae.Handle(ex =>
    {
        // Handle each exception
        return true;
    });
}
处理从并行或异步代码引发的多个异常。 就像一张网捕捉一群蜜蜂一样！
用例：
  • 执行可能引发多个异常的并行或异步代码时。
  • 单独处理每个异常。
6、非捕获异常处理程序
try
{
    // Dangerous code...
}
catch (Exception ex) when (LogException(ex))
{
}

bool LogException(Exception ex)
{
    // Log the exception and return false
    return false;
}
记录异常而不捕获它们。 就像闭路电视摄像机观察一切但不干预！
用例：
  • 当您需要记录异常但允许它们传播时。
  • 监视代码中的异常。
7、ExceptionDispatchInfo类
ExceptionDispatchInfo capturedException;

try
{
    // Dangerous code...
}
catch (Exception ex)
{
    capturedException = ExceptionDispatchInfo.Capture(ex);
}
// Later...
capturedException?.Throw();
捕获并重新抛出异常，同时保留原始堆栈跟踪。 这就像一个例外的时间胶囊！
用例：
  • 当您需要跨线程或异步方法抛出异常时。
  • 保留异常的原始堆栈跟踪。
8、自定义例外
public class MyException : Exception
{
    public MyException(string message) : base(message) { }
    public MyException(string message, Exception inner) : base(message, inner) { }
}
为特定错误场景创建自定义异常。 这就像为特定的亡命徒制作一张通缉海报！
用例：
  • 当您需要在代码中表示特定的错误条件时。
  • 创建更具表现力和更详细的例外。
9、检查异常来源
catch (Exception ex)
{
    if (ex.Source == "MyAssembly")
    {
        // Handle the exception
    }
}
检查异常的来源。 这就像追踪电话的来源一样！
用例：
  • 当您需要处理来自特定来源的异常时。
  • 区分来自不同程序集或类的异常。
10、MVC中的OnException方法
public class MyController : Controller
{
    protected override void OnException(ExceptionContext filterContext)
    {
        // Handle exceptions for the entire controller
    }
}
处理整个 MVC 控制器的异常。 就像建筑物的安全检查员一样！
用例：
  • 当您想要处理 MVC 控制器中的所有异常时。
  • 将异常处理代码集中在 MVC 应用程序中。
来源：今日头条内容投诉
免责声明：
① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。 
② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
软考中级精品资料免费领 
  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 资料下载
  • 历年真题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）
     难度      813人已做 
     查看 
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析
     难度      354人已做 
     查看 
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析
     难度      318人已做 
     查看 
  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）
     难度      435人已做 
     查看 
  • 2024年上半年系统架构设计师考试综合知识真题
     难度      224人已做 
     查看 
相关文章
发现更多好内容
猜你喜欢
AI推送时光机
适合每位开发人员的 60 个 C# 代码片段
后端开发C#代码片段2024-11-30
 位置：首页-资讯-后端开发
 咦！没有更多了？去看看其它编程学习网 内容吧 
首页课程
资料下载问答资讯