主頁 > .NET開發 > .NET Core 多執行緒的用法,以及用例

.NET Core 多執行緒的用法,以及用例

2023-03-21 16:50:42 .NET開發

1.使用 Thread 類
Thread 類是 .NET 中最基本的多執行緒操作方式之一，可以使用它創建并啟動新執行緒，以下是一個簡單的例子，創建一個新的執行緒并運行：

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread t = new Thread(new ThreadStart(ThreadProc));
        t.Start();
        
        // 等待執行緒執行結束
        t.Join();
        
        Console.WriteLine("Main thread exiting.");
    }
    
    static void ThreadProc()
    {
        Console.WriteLine("ThreadProc starting...");
        Thread.Sleep(1000);
        Console.WriteLine("ThreadProc ending.");
    }
}

2.使用 Task 類
Task 類是 .NET 中推薦使用的多執行緒操作方式之一，它可以更方便地管理異步操作和多個任務，以下是一個簡單的例子，創建一個新的 Task 并啟動：

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        await Task.Run(() =>
        {
            Console.WriteLine("Task starting...");
            Thread.Sleep(1000);
            Console.WriteLine("Task ending.");
        });

        Console.WriteLine("Main thread exiting.");
    }
}

3.使用 Parallel 類
Parallel 類可以讓我們更方便地進行并行化操作，它提供了一系列方法，可以將一個任務分割成多個小任務，并讓多個執行緒同時執行這些小任務，以下是一個簡單的例子：

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Parallel.For(0, 10, i =>
        {
            Console.WriteLine("Task {0} starting...", i);
            Thread.Sleep(1000);
            Console.WriteLine("Task {0} ending.", i);
        });

        Console.WriteLine("Main thread exiting.");
    }
}

4.使用 async/await
在 .NET Core 中，可以使用 async/await 關鍵字進行異步操作，這是一種非常方便的操作多執行緒的方式，async/await 讓代碼看起來像是同步的，但實際上是在后臺使用多執行緒異步執行的，以下是一個簡單的例子：

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Main thread starting...");

        await Task.Run(() =>
        {
            Console.WriteLine("Task starting...");
            Thread.Sleep(1000);
            Console.WriteLine("Task ending.");
        });

        Console.WriteLine("Main thread exiting.");
    }
}

5.使用 Concurrent 類
Concurrent 類提供了執行緒安全的集合和佇列，它們可以在多個執行緒中同時訪問和修改，而不會發生沖突和資料損壞，以下是一個簡單的例子，使用 ConcurrentQueue 存盤資料：

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        ConcurrentQueue<int> queue = new ConcurrentQueue<int>();

        // 并行化生產資料
        Parallel.For(0, 10, i =>
        {
            Console.WriteLine("Task {0} producing...", i);
            queue.Enqueue(i);
        });

        // 并行化消費資料
        Parallel.For(0, 10, i =>
        {
            int value;
            if (queue.TryDequeue(out value))
            {
                Console.WriteLine("Task {0} consuming {1}...", i, value);
            }
            else
            {
                Console.WriteLine("Task {0} found queue empty...", i);
            }
        });

        Console.WriteLine("Main thread exiting.");
    }
}

以下是一些高級和復雜一些的操作多執行緒的用法和技巧：

1.使用 Lock 和 Monitor
在多執行緒中，如果多個執行緒同時訪問和修改共享資源，會導致資料損壞和程式崩潰，為了避免這種情況，可以使用 lock 和 Monitor 關鍵字進行同步，lock 和 Monitor 用于獲取物件的鎖，并保證在同一時間只有一個執行緒可以訪問該物件，以下是一個簡單的例子：

using System;
using System.Threading;

class Program
{
    static object _lock = new object();
    static int _counter = 0;

    static void Main()
    {
        Thread t1 = new Thread(IncrementCounter);
        Thread t2 = new Thread(IncrementCounter);

        t1.Start();
        t2.Start();

        t1.Join();
        t2.Join();

        Console.WriteLine("Counter = {0}", _counter);
    }

    static void IncrementCounter()
    {
        for (int i = 0; i < 100000; i++)
        {
            lock (_lock)
            {
                _counter++;
            }
        }
    }
}

2.使用 CancellationToken 和 TaskCompletionSource
在異步操作中，有時需要取消任務或等待任務完成后執行其他操作，為了實作這些功能，可以使用 CancellationToken 和 TaskCompletionSource 類，CancellationToken 用于取消任務，TaskCompletionSource 用于等待任務完成并回傳結果，以下是一個簡單的例子：

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using (CancellationTokenSource cts = new CancellationTokenSource())
        {
            Task<int> task = DoWorkAsync(cts.Token);

            // 等待任務完成或取消
            Task completedTask = await Task.WhenAny(task, Task.Delay(5000));
            if (completedTask == task)
            {
                Console.WriteLine("Result = {0}", await task);
            }
            else
            {
                Console.WriteLine("Task cancelled.");
                cts.Cancel();
            }
        }
    }

    static async Task<int> DoWorkAsync(CancellationToken cancellationToken)
    {
        try
        {
            await Task.Delay(2000, cancellationToken);
            return 42;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("DoWorkAsync cancelled.");
            throw;
        }
    }
}

3.使用 ThreadLocal 和 ExecutionContext
在某些情況下，需要在多個執行緒中共享變數，并且每個執行緒需要使用不同的值，為了實作這個目標，可以使用 ThreadLocal 類，ThreadLocal 類為每個執行緒提供一個獨立的變數副本，使得每個執行緒都可以使用不同的值，以下是一個簡單的例子：

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static ThreadLocal<int> _counter = new ThreadLocal<int>(() => 0);

    static void Main()
    {
        Parallel.For(0, 10, i =>
        {
            _counter.Value++;
            Console.WriteLine("Thread {0} counter = {1}", Thread.CurrentThread.ManagedThreadId, _counter.Value);
        });

        Console.WriteLine("Main thread exiting.");
    }
}
ExecutionContext 類可以用于在多個執行緒中共享資料

4.使用 Parallel 類和 PLINQ
Parallel 類和 PLINQ（Parallel LINQ）是 .NET Framework 中用于并行處理資料的工具，Parallel 類提供了一些方法，如 For 和 ForEach，可以輕松地將回圈并行化，PLINQ 則是 LINQ 的并行版本，它可以將查詢操作并行化，以下是一個簡單的例子：

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        int[] numbers = Enumerable.Range(0, 1000000).ToArray();

        // 并行回圈
        Parallel.ForEach(numbers, number =>
        {
            Console.WriteLine("Thread {0} processing number {1}.", Thread.CurrentThread.ManagedThreadId, number);
        });

        // 并行查詢
        var result = numbers.AsParallel().Where(number => number % 2 == 0).Sum();
        Console.WriteLine("Result = {0}", result);
    }
}

5.使用 SemaphoreSlim 和 CountdownEvent
SemaphoreSlim 和 CountdownEvent 是用于控制多個執行緒之間的同步和協作的類，SemaphoreSlim 可以用于限制同時訪問某些資源的執行緒數量，CountdownEvent 可以用于在所有執行緒完成某些操作后恢復執行，以下是一個簡單的例子：

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static SemaphoreSlim _semaphore = new SemaphoreSlim(2);
    static CountdownEvent _countdown = new CountdownEvent(2);

    static void Main()
    {
        Task t1 = Task.Run(() => DoWork(1));
        Task t2 = Task.Run(() => DoWork(2));
        Task t3 = Task.Run(() => DoWork(3));
        Task t4 = Task.Run(() => DoWork(4));

        Task.WaitAll(t1, t2, t3, t4);

        Console.WriteLine("Main thread exiting.");
    }

    static void DoWork(int id)
    {
        _semaphore.Wait();

        try
        {
            Console.WriteLine("Thread {0} working.", id);
            Thread.Sleep(2000);
        }
        finally
        {
            _semaphore.Release();
            _countdown.Signal();
        }
    }
}

在這個例子中，SemaphoreSlim 限制了同時執行的執行緒數量，CountdownEvent 則用于在所有執行緒完成后恢復執行

6.使用 TaskCompletionSource 和 async/await
TaskCompletionSource 可以用于將異步操作轉換為 Task 物件，這使得異步操作可以與同步代碼一樣進行操作，async/await 則是 .NET Framework 4.5 中引入的關鍵字，它可以將異步代碼看作同步代碼，使得異步編程更加簡單和直觀，以下是一個簡單的例子

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Main thread started.");

        Task<int> task = DoWorkAsync();
        int result = await task;

        Console.WriteLine("Result = {0}.", result);
        Console.WriteLine("Main thread exiting.");
    }

    static async Task<int> DoWorkAsync()
    {
        Console.WriteLine("Worker thread started.");
        await Task.Delay(2000);
        Console.WriteLine("Worker thread completed.");
        return 42;
    }
}
在這個例子中，DoWorkAsync 方法使用 async/await 異步地執行作業，并回傳一個 Task<int> 物件，Main 方法則使用 await 等待 DoWorkAsync 方法的執行，并獲取回傳值，這使得異步編程更加簡單和直觀

7.使用 Dataflow
Dataflow 是 .NET Framework 4.5 中引入的一種并發編程模型，它可以用于建立資料流管道，將多個資料處理步驟連接起來，形成一個完整的資料處理流程，Dataflow 可以處理包括異步和同步操作在內的各種資料處理任務，以下是一個簡單的例子

using System;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Main thread started.");

        // 創建資料流管道
        var pipeline = new TransformBlock<int, int>(async x =>
        {
            Console.WriteLine("Thread {0} processing number {1}.", Thread.CurrentThread.ManagedThreadId, x);
            await Task.Delay(1000);
            return x * 2;
        });

        // 將多個資料處理步驟連接起來
        pipeline.LinkTo(new ActionBlock<int>(x =>
        {
            Console.WriteLine("Thread {0} processed number {1}.", Thread.CurrentThread.ManagedThreadId, x);
        }));

        // 將資料發送到管道中
        for (int i = 0; i < 10; i++)
        {
            pipeline.Post(i);
        }

        // 等待管道處理完成
        pipeline.Complete();
        await pipeline.Completion;

        Console.WriteLine("Main thread exiting.");
    }
}
在這個例子中，使用 TransformBlock 和 ActionBlock 創建了一個資料流管道，將多個資料處理步驟連接起來，在管道中發送資料時，每個資料處理步驟會異步地處理資料，并將處理結果傳遞給下一個資料處理步驟，使用 Dataflow 可以更加方便地處理復雜的資料處理任務，

8.使用 Parallel 和 PLINQ
Parallel 和 PLINQ 是 .NET Framework 中提供的兩種并發編程模型，它們都可以用于并行執行多個操作，提高代碼的性能和并發度，以下是一個簡單的例子：

using System;
using System.Linq;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Console.WriteLine("Main thread started.");

        int[] numbers = Enumerable.Range(1, 10).ToArray();

        // 使用 Parallel.For 并行處理資料
        Parallel.For(0, numbers.Length, i =>
        {
            Console.WriteLine("Thread {0} processing number {1}.", Thread.CurrentThread.ManagedThreadId, numbers[i]);
            Thread.Sleep(1000);
        });

        // 使用 PLINQ 并行處理資料
        var results = numbers.AsParallel().Select(x =>
        {
            Console.WriteLine("Thread {0} processing number {1}.", Thread.CurrentThread.ManagedThreadId, x);
            Thread.Sleep(1000);
            return x * 2;
        }).ToList();

        Console.WriteLine("Results: {0}.", string.Join(", ", results));
        Console.WriteLine("Main thread exiting.");
    }
}
在這個例子中，使用 Parallel.For 和 PLINQ 并行處理了一個陣列中的資料，Parallel.For 使用指定的起始和結束索引并行執行多個操作，而 PLINQ 使用 AsParallel 方法將資料集合并行化，并在多個執行緒上執行 LINQ 操作，使用 Parallel 和 PLINQ 可以更加方便地提高代碼的性能和并發度，

9.使用 ThreadLocal
ThreadLocal 是 .NET Framework 中提供的一種執行緒區域存盤機制，它可以讓每個執行緒擁有自己獨立的資料副本，避免了執行緒之間的競爭和同步問題，以下是一個簡單的例子

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static ThreadLocal<int> _count = new ThreadLocal<int>(() => 0);

    static void Main()
    {
        Console.WriteLine("Main thread started.");

        // 創建多個執行緒并執行任務
        var tasks = new Task[3];
        for (int i = 0; i < 3; i++)
        {
            tasks[i] = Task.Factory.StartNew(() =>
            {
                _count.Value++;
                Console.WriteLine("Thread {0} count = {1}.", Thread.CurrentThread.ManagedThreadId, _count.Value);
                Thread.Sleep(1000);
                _count.Value--;
            });
        }

        Task.WaitAll(tasks);

        Console.WriteLine("Main thread exiting.");
    }
}
在這個例子中，使用 ThreadLocal 創建了一個執行緒區域變數，每個執行緒都擁有自己獨立的資料副本，在多個執行緒執行任務時，可以使用 _count.Value 獲取每個執行緒獨立的資料副本，使用 ThreadLocal 可以避免執行緒之間的競爭和同步問題，

10.使用 SemaphoreSlim
SemaphoreSlim 是 .NET Framework 中提供的一種輕量級信號量機制，它可以用于控制并發度和資源訪問，以下是一個簡單的例子：

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
static SemaphoreSlim _semaphore = new SemaphoreSlim(2);
static void Main()
{
    Console.WriteLine("Main thread started.");

    // 創建多個執行緒并執行任務
    var tasks = new Task[5];
    for (int i = 0; i < 5; i++)
    {
        tasks[i] = Task.Factory.StartNew(async () =>
        {
            Console.WriteLine("Thread {0} waiting for semaphore.", Thread.CurrentThread.ManagedThreadId);

            // 等待信號量
            await _semaphore.WaitAsync();

            try
            {
                Console.WriteLine("Thread {0} acquired semaphore.", Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(1000);
            }
            finally
            {
                // 釋放信號量
                _semaphore.Release();
                Console.WriteLine("Thread {0} released semaphore.", Thread.CurrentThread.ManagedThreadId);
            }
        });
    }

    Task.WaitAll(tasks);

    Console.WriteLine("Main thread exiting.");
}
}

在這個例子中，使用 SemaphoreSlim 創建了一個信號量，它的初始計數為 2，表示最多有兩個執行緒同時訪問，在多個執行緒執行任務時，可以使用 _semaphore.WaitAsync() 獲取信號量并等待資源，使用 _semaphore.Release() 釋放信號量，使用 SemaphoreSlim 可以控制并發度和資源訪問，避免資源競爭和死鎖問題，

總結：
.NET Core 中提供了豐富的多執行緒編程模型和工具，包括 Task、async/await、ThreadPool、Thread、Concurrent、Parallel、PLINQ、ThreadLocal 和 SemaphoreSlim 等，這些工具可以幫助我們更加方便地實作并發編程，提高代碼的性能和并發度，在使用多執行緒編程時，我們需要注意避免常見的執行緒安全問題，例如資源競爭、死鎖和資料不一致等，同時，我們還可以使用一些工具和技術來幫助我們發現和解決執行緒安全問題，例如代碼審查、單元測驗和性能分析等，

解決執行緒安全問題是多執行緒編程中非常重要的一環，下面我將介紹幾種解決執行緒安全問題的方法：

1.使用鎖機制：鎖機制可以確保在同一時刻只有一個執行緒能夠訪問共享資源，可以使用 lock 關鍵字或 Monitor 類來實作鎖機制，

2.使用互斥量：互斥量也可以用來控制對共享資源的訪問，與鎖機制不同的是，互斥量可以跨行程使用，

3.使用信號量：信號量可以用來限制對共享資源的訪問，它可以控制同時訪問共享資源的執行緒數量，

4.使用原子操作：原子操作是一種特殊的操作，它能夠確保在執行操作期間沒有其他執行緒能夠訪問同一共享資源，

5.使用并發集合：并發集合是一種特殊的資料結構，它們專門設計用來在多執行緒環境下安全地訪問共享資源，.NET Core 提供了許多種并發集合，例如 ConcurrentDictionary、ConcurrentQueue、ConcurrentBag 等，

6.盡量避免共享資源：如果可能的話，可以嘗試避免共享資源的使用，這樣可以減少執行緒之間的競爭和沖突，

7.使用執行緒安全的型別：在撰寫多執行緒代碼時，可以使用執行緒安全的型別，例如 Interlocked、Volatile 和 ThreadLocal 等，

總之，在解決執行緒安全問題時，需要注意避免死鎖、饑餓、活鎖等問題，并在撰寫代碼時仔細考慮多執行緒訪問的順序、資料的同步和共享資源的保護，同時，進行代碼審查、單元測驗和性能分析等，可以幫助我們發現和解決執行緒安全問題，

下面是幾個具體的示例，演示如何解決常見的執行緒安全問題，
1.使用鎖機制

class BankAccount
{
    private object accountLock = new object();
    private decimal balance;

    public void Deposit(decimal amount)
    {
        lock (accountLock)
        {
            balance += amount;
        }
    }

    public void Withdraw(decimal amount)
    {
        lock (accountLock)
        {
            balance -= amount;
        }
    }
}

在這個示例中，使用 lock 關鍵字來確保在 Deposit 和 Withdraw 方法執行期間，同一時刻只有一個執行緒能夠訪問 balance 變數，

2.使用并發集合

ConcurrentDictionary<string, int> dict = new ConcurrentDictionary<string, int>();

dict.TryAdd("one", 1);
dict.TryAdd("two", 2);
dict.TryAdd("three", 3);

foreach (var item in dict)
{
    Console.WriteLine($"{item.Key}: {item.Value}");
}
在這個示例中，使用 ConcurrentDictionary 類來存盤鍵值對，ConcurrentDictionary 是執行緒安全的，多個執行緒可以同時訪問它而不會產生競爭和沖突，

3.使用互斥量

class MyMutex
{
    private Mutex mutex = new Mutex();
    private int count = 0;

    public void AddCount()
    {
        mutex.WaitOne();
        try
        {
            count++;
        }
        finally
        {
            mutex.ReleaseMutex();
        }
    }

    public int GetCount()
    {
        mutex.WaitOne();
        try
        {
            return count;
        }
        finally
        {
            mutex.ReleaseMutex();
        }
    }
}
在這個示例中，使用 Mutex 類來實作互斥量，在 AddCount 和 GetCount 方法執行期間，同一時刻只有一個執行緒能夠訪問 count 變數，

總之，以上示例演示了如何使用不同的技術解決執行緒安全問題，需要根據具體情況選擇最適合的方法，同時注意代碼的效率和性能，

4.避免死鎖
1.下面是一個可能導致死鎖的示例：

class DeadlockExample
{
    private object lockA = new object();
    private object lockB = new object();

    public void MethodA()
    {
        lock (lockA)
        {
            Console.WriteLine("MethodA acquired lockA.");
            lock (lockB)
            {
                Console.WriteLine("MethodA acquired lockB.");
            }
        }
    }

    public void MethodB()
    {
        lock (lockB)
        {
            Console.WriteLine("MethodB acquired lockB.");
            lock (lockA)
            {
                Console.WriteLine("MethodB acquired lockA.");
            }
        }
    }
}
這個示例中，兩個方法 MethodA 和 MethodB 都需要獲取兩個鎖 lockA 和 lockB，如果兩個方法在不同的執行緒上同時執行，那么可能會發生死鎖，導致兩個執行緒互相等待對方釋放鎖，最終導致程式停滯不前，

為了避免死鎖，可以改變鎖的獲取順序，例如，在上面的示例中，可以將 MethodB 中獲取鎖的順序改為 lockA, lockB，這樣就避免了死鎖的問題，

2.使用執行緒安全的資料結構

如果您需要在多個執行緒之間共享資料，可以使用執行緒安全的資料結構，例如 BlockingCollection、ConcurrentQueue 和 ConcurrentStack，這些資料結構都是執行緒安全的，可以避免多個執行緒同時訪問同一個變數的問題，

例如，下面的示例演示了如何使用 BlockingCollection 來實作生產者-消費者模式：

class ProducerConsumerExample
{
    private BlockingCollection<int> queue = new BlockingCollection<int>(10);

    public void Produce()
    {
        for (int i = 0; i < 20; i++)
        {
            queue.Add(i);
        }
        queue.CompleteAdding();
    }

    public void Consume()
    {
        foreach (var item in queue.GetConsumingEnumerable())
        {
            Console.WriteLine(item);
        }
    }
}
在這個示例中，一個生產者執行緒使用 Add 方法向佇列中添加資料，一個消費者執行緒使用 GetConsumingEnumerable 方法獲取資料，由于 BlockingCollection 是執行緒安全的，因此不需要擔心資料訪問的競爭和沖突問題，

總之，執行緒安全是一個非常重要的問題，需要特別注意，使用適當的技術和方法，可以避免大多數執行緒安全問題，

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/547583.html

標籤：.NET Core

上一篇：讀C#代碼整潔之道筆記02_類、物件和資料結構及撰寫整潔函式

下一篇：面試常考：C#用兩個執行緒交替列印1-100的五種方法

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • WebAPI簡介

    Web體系結構： 有三個核心：資源(resource)，URL(統一資源識別符號)和表示 他們的關系是這樣的：一個資源由一個URL進行標識，HTTP客戶端使用URL定位資源，表示是從資源回傳資料，媒體型別是資源回傳的資料格式。 接下來我們說下HTTP. HTTP協議的系統是一種無狀態的方式，使用請求/ ......

    uj5u.com 2020-09-09 22:07:47 more
  • asp.net core 3.1 入口：Program.cs中的Main函式

    本文分析Program.cs 中Main()函式中代碼的運行順序分析asp.net core程式的啟動，重點不是剖析原始碼，而是理清程式開始時執行的順序。到呼叫了哪些實體，哪些法方。asp.net core 3.1 的程式入口在專案Program.cs檔案里，如下。ususing System; us ......

    uj5u.com 2020-09-09 22:07:49 more
  • asp.net網站作為websocket服務端的應用該如何寫

    最近被websocket的一個問題困擾了很久，有一個需求是在web網站中搭建websocket服務。客戶端通過網頁與服務器建立連接，然后服務器根據ip給客戶端網頁發送資訊。 其實，這個需求并不難，只是剛開始對websocket的內容不太了解。上網搜索了一下，有通過asp.net core 實作的、有 ......

    uj5u.com 2020-09-09 22:08:02 more
  • ASP.NET 開源匯入匯出庫Magicodes.IE Docker中使用

    Magicodes.IE在Docker中使用 更新歷史 2019.02.13 【Nuget】版本更新到2.0.2 【匯入】修復單列匯入的Bug，單元測驗“OneColumnImporter_Test”。問題見（https://github.com/dotnetcore/Magicodes.IE/is ......

    uj5u.com 2020-09-09 22:08:05 more
  • 在webform中使用ajax

    如果你用過Asp.net webform， 說明你也算是.NET 開發的老兵了。WEBform應該是2011 2013左右，當時還用visual studio 2005、 visual studio 2008。后來基本都用的是MVC。 如果是新開發的專案，估計沒人會用webform技術。但是有些舊版 ......

    uj5u.com 2020-09-09 22:08:50 more
  • iis添加asp.net網站，訪問提示：由于擴展配置問題而無法提供您請求的

    今天在iis服務器配置asp.net網站，遇到一個問題，記錄一下： 問題：由于擴展配置問題而無法提供您請求的頁面。如果該頁面是腳本，請添加處理程式。如果應下載檔案，請添加 MIME 映射。 WindowServer2012服務器，添加角色安裝完.netframework和iis之后，運行aspx頁面 ......

    uj5u.com 2020-09-09 22:10:00 more
  • WebAPI-處理架構

    帶著問題去思考，大家好！ 問題1：HTTP請求和回傳相應的HTTP回應資訊之間發生了什么？ 1：首先是最底層，托管層，位于WebAPI和底層HTTP堆疊之間 2：其次是 訊息處理程式管道層，這里比如日志和快取。OWIN的參考是將訊息處理程式管道的一些功能下移到堆疊下端的OWIN中間件了。 3：控制器處理 ......

    uj5u.com 2020-09-09 22:11:13 more
  • 微信門戶開發框架-使用指導說明書

    微信門戶應用管理系統，采用基于 MVC + Bootstrap + Ajax + Enterprise Library的技術路線，界面層采用Boostrap + Metronic組合的前端框架，資料訪問層支持Oracle、SQLServer、MySQL、PostgreSQL等資料庫。框架以MVC5，... ......

    uj5u.com 2020-09-09 22:15:18 more
  • WebAPI-HTTP編程模型

    帶著問題去思考，大家好！它是什么？它包含什么？它能干什么？ 訊息 HTTP編程模型的核心就是訊息抽象，表示為：HttPRequestMessage,HttpResponseMessage.用于客戶端和服務端之間交換請求和回應訊息。 HttpMethod類包含了一組靜態屬性： private stat ......

    uj5u.com 2020-09-09 22:15:23 more
  • 部署WebApi隨筆

    一、跨域 NuGet參考Microsoft.AspNet.WebApi.Cors WebApiConfig.cs中配置： // Web API 配置和服務 config.EnableCors(new EnableCorsAttribute("*", "*", "*")); 二、清除默認回傳XML格式 ......

    uj5u.com 2020-09-09 22:15:48 more
最新发布
  • C#多執行緒學習(二) 如何操縱一個執行緒

    <a href="https://www.cnblogs.com/x-zhi/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/2943582/20220801082530.png" alt="" /></...

    uj5u.com 2023-04-19 09:17:20 more
  • C#多執行緒學習(二) 如何操縱一個執行緒

    C#多執行緒學習(二) 如何操縱一個執行緒 執行緒學習第一篇：C#多執行緒學習(一) 多執行緒的相關概念 下面我們就動手來創建一個執行緒，使用Thread類創建執行緒時，只需提供執行緒入口即可。（執行緒入口使程式知道該讓這個執行緒干什么事） 在C#中，執行緒入口是通過ThreadStart代理（delegate）來提供的 ......

    uj5u.com 2023-04-19 09:16:49 more
  • 記一次 .NET某醫療器械清洗系統 卡死分析

    <a href="https://www.cnblogs.com/huangxincheng/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/214741/20200614104537.png" alt="" /&g...

    uj5u.com 2023-04-18 08:39:04 more
  • 記一次 .NET某醫療器械清洗系統 卡死分析

    一：背景 1. 講故事 前段時間協助訓練營里的一位朋友分析了一個程式卡死的問題，回過頭來看這個案例比較經典，這篇稍微整理一下供后來者少踩坑吧。 二：WinDbg 分析 1. 為什么會卡死 因為是表單程式，理所當然就是看主執行緒此時正在做什么? 可以用 ~0s ; k 看一下便知。 0:000> k # ......

    uj5u.com 2023-04-18 08:33:10 more
  • SignalR, No Connection with that ID，IIS

    <a href="https://www.cnblogs.com/smartstar/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/u36196.jpg" alt="" /></a>...

    uj5u.com 2023-03-30 17:21:52 more
  • 一次對pool的誤用導致的.net頻繁gc的診斷分析

    <a href="https://www.cnblogs.com/dotnet-diagnostic/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/3115652/20230225090434.png" alt=""...

    uj5u.com 2023-03-28 10:15:33 more
  • 一次對pool的誤用導致的.net頻繁gc的診斷分析

    <a href="https://www.cnblogs.com/dotnet-diagnostic/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/3115652/20230225090434.png" alt=""...

    uj5u.com 2023-03-28 10:13:31 more
  • C#遍歷指定檔案夾中所有檔案的3種方法

    <a href="https://www.cnblogs.com/xbhp/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/957602/20230310105611.png" alt="" /></a&...

    uj5u.com 2023-03-27 14:46:55 more
  • C#/VB.NET：如何將PDF轉為PDF/A

    <a href="https://www.cnblogs.com/Carina-baby/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/2859233/20220427162558.png" alt="" />...

    uj5u.com 2023-03-27 14:46:35 more
  • 武裝你的WEBAPI-OData聚合查詢

    <a href="https://www.cnblogs.com/podolski/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/616093/20140323000327.png" alt="" /><...

    uj5u.com 2023-03-27 14:46:16 more

Copyright © 2010-2020 有解無憂