一：背景

1. 講故事

自從這個純內存項目進了大客戶之後，搞得我現在對內存和CPU特別敏感，跑一點數據內存幾個G的上下，特別沒有安全感，總想用windbg抓幾個dump看看到底是哪一塊導致的，是我的代碼還是同事的代碼？ 很多看過我博客的老朋友總是留言讓我出一套windbg的系列或者視頻，我也不會呀，沒辦法，人在江湖飄，遲早得挨上幾刀，逼着也得會幾個花架子，廢話不多說，這一篇就來看看 HashSet 是如何擴容的。

二：HashSet的擴容機制

1. 如何查看

了解如何擴容，最好的辦法就是翻看HashSet底層源碼，最粗暴的入口點就是 HashSet.Add 方法。

從圖中可以看到最後的初始化是用 Initialize 的，而且裏面有這麼一句神奇的代碼: int prime = HashHelpers.GetPrime(capacity);，從字面意思看是獲取一個質數，哈哈，有點意思，什麼叫質數？ 簡單說就是只能被 1 和 自身 整除的數就叫做質數，那好奇心就來了，一起看看質數是怎麼算的吧！ 再次截圖。

從圖中看，HashSet底層為了加速默認定義好了 72 個質數，最大的一個質數是 719w，換句話就是說當元素個數大於 719w 的時候，就只能使用 IsPrime 方法動態計算質數，如下代碼：

public static bool IsPrime(int candidate)
{
	if ((candidate & 1) != 0)
	{
		int num = (int)Math.Sqrt(candidate);
		for (int i = 3; i <= num; i += 2)
		{
			if (candidate % i == 0)
			{
				return false;
			}
		}
		return true;
	}
	return candidate == 2;
}

看完了整個流程，我想你應該明白了，當你第一次Add的時候，默認的空間佔用是 72 個預定義中最小的一個質數 3，看過我之前文章的朋友知道List的默認大小是4，後面就是簡單粗暴的 * 2 處理，如下代碼。

private void EnsureCapacity(int min)
{
	if (_items.Length < min)
	{
		int num = (_items.Length == 0) ? 4 : (_items.Length * 2);
	}
}

2. HashSet 二次擴容探究

當HashSet的個數達到3之後，很顯然要進行二次擴容，這一點不像List用一個 EnsureCapacity 方法搞定就可以了，然後細看一下怎麼擴容。

public static int ExpandPrime(int oldSize)
{
	int num = 2 * oldSize;
	if ((uint)num > 2146435069u && 2146435069 > oldSize)
	{
		return 2146435069;
	}
	return GetPrime(num);
}

從圖中可以看到，最後的擴容是在 ExpandPrime 方法中完成的，流程就是先 * 2， 再取最接近上限的一個質數，也就是 7 ，然後將 7 作為 HashSet 新的Size，如果你非要看演示，我就寫一小段代碼證明一下吧，如下圖：

2. 您嗅出風險了嗎？

<1> 時間上的風險

為了方便演示，我把 72 個預定義的最後幾個質數显示出來。

public static readonly int[] primes = new int[72]
{
	2009191,
	2411033,
	2893249,
	3471899,
	4166287,
	4999559,
	5999471,
	7199369
};

也就是說，當HashSet的元素個數為 2893249 的時候觸發擴容變成了 2893249 * 2 => 5786498 最接近的一個質數為：5999471，也就是 289w 暴增到了 599w，一下子就是 599w -289w = 310w 的空間虛占，這可是增加了兩倍多哦，嚇人不？ 下面寫個代碼驗證下。

        static void Main(string[] args)
        {
            var hashSet = new HashSet<int>(Enumerable.Range(0, 2893249));

            hashSet.Add(int.MaxValue);

            Console.Read();
        }

0:000> !clrstack -l

000000B8F4DBE500 00007ffaf00132ae ConsoleApplication3.Program.Main(System.String[]) [C:\4\ConsoleApp1\ConsoleApp1\Program.cs @ 16]
    LOCALS:
        0x000000B8F4DBE538 = 0x0000020e0b8fcc08
0:000> !DumpObj /d 0000020e0b8fcc08
Name:        System.Collections.Generic.HashSet`1[[System.Int32, System.Private.CoreLib]]
Size:        64(0x40) bytes
File:        C:\Program Files\dotnet\shared\Microsoft.NETCore.App\5.0.0-preview.5.20278.1\System.Collections.dll
Fields:
              MT    Field   Offset                 Type VT     Attr            Value Name
00007ffaf0096d10  4000017        8       System.Int32[]  0 instance 0000020e2025e9f8 _buckets
00007ffaf00f7ad0  4000018       10 ...ivate.CoreLib]][]  0 instance 0000020e2bea1020 _slots
00007ffaeffdf828  4000019       28         System.Int32  1 instance          2893250 _count
0:000> !DumpObj /d 0000020e2025e9f8
Name:        System.Int32[]
Size:        23997908(0x16e2dd4) bytes
Array:       Rank 1, Number of elements 5999471, Type Int32 (Print Array)
Fields:
None

而且最重要的是，這裡是一次性擴容的，而非像redis中實現的那樣漸進式擴容，時間開銷也是大家值得注意的。

<2> 空間上的風險

這個有什麼風險呢？可以看一下：289w 和 599w 兩個HashSet的佔用空間大小，這也是我最敏感的。

        static void Main(string[] args)
        {
            var hashSet1 = new HashSet<int>(Enumerable.Range(0, 2893249));

            var hashSet2 = new HashSet<int>(Enumerable.Range(0, 2893249));
            hashSet2.Add(int.MaxValue);

            Console.Read();
        }

0:000> !clrstack -l
OS Thread Id: 0x4a44 (0)
000000B1B4FEE460 00007ffaf00032ea ConsoleApplication3.Program.Main(System.String[]) [C:\4\ConsoleApp1\ConsoleApp1\Program.cs @ 18]
    LOCALS:
        0x000000B1B4FEE4B8 = 0x000001d13363cc08
        0x000000B1B4FEE4B0 = 0x000001d13363d648

0:000> !objsize 0x000001d13363cc08
sizeof(000001D13363CC08) = 46292104 (0x2c25c88) bytes (System.Collections.Generic.HashSet`1[[System.Int32, System.Private.CoreLib]])
0:000> !objsize 0x000001d13363d648
sizeof(000001D13363D648) = 95991656 (0x5b8b768) bytes (System.Collections.Generic.HashSet`1[[System.Int32, System.Private.CoreLib]])

可以看到， hashSet1的佔用： 46292104 / 1024 / 1024 = 44.1M， hashSet2 的佔用 : 95991656 / 1024 / 1024 = 91.5M,一下子就浪費了： 91.5 - 44.1 = 47.4M。

如果你真以為僅僅浪費了 47.4M 的話，那你就大錯特錯了，不要忘了底層在擴容的時候，使用新的 size 覆蓋了老的 size，而這個 老的 size 集合在GC還沒有回收的時候會一直佔用堆上空間的，這個能聽得懂嗎？ 如下圖：

要驗證的話可以用 windbg 去託管堆上抓一下 Slot[] m_slots 和 int[] m_buckets 兩個數組，我把代碼修改如下：

    static void Main(string[] args)
    {
        var hashSet2 = new HashSet<int>(Enumerable.Range(0, 2893249));
        hashSet2.Add(int.MaxValue);
        Console.Read();
    }


0:011> !dumpheap -stat
00007ffaf84f7ad0        3    123455868 System.Collections.Generic.HashSet`1+Slot[[System.Int32, System.Private.CoreLib]][]

這裏就拿 Slot[] 說事，從上面代碼可以看到，託管堆上有三個 Slot[] 數組，這就有意思了，怎麼有三個哈，是不是有點懵逼，沒關係，我們將三個 Slot[] 的地址找出來，一個一個看。

0:011> !DumpHeap /d -mt 00007ffaf84f7ad0
         Address               MT     Size
0000016c91308048 00007ffaf84f7ad0 16743180     
0000016c928524b0 00007ffaf84f7ad0 34719012     
0000016ce9e61020 00007ffaf84f7ad0 71993676  

0:011> !gcroot 0000016c91308048
Found 0 unique roots (run '!gcroot -all' to see all roots).
0:011> !gcroot 0000016c928524b0
Found 0 unique roots (run '!gcroot -all' to see all roots).
0:011> !gcroot 0000016ce9e61020
Thread 2b0c:
    0000006AFAB7E5F0 00007FFAF84132AE ConsoleApplication3.Program.Main(System.String[]) [C:\4\ConsoleApp1\ConsoleApp1\Program.cs @ 15]
        rbp-18: 0000006afab7e618
            ->  0000016C8000CC08 System.Collections.Generic.HashSet`1[[System.Int32, System.Private.CoreLib]]
            ->  0000016CE9E61020 System.Collections.Generic.HashSet`1+Slot[[System.Int32, System.Private.CoreLib]][]

從上面可以看到，我通過 gcroot 去找這三個地址的引用根，有兩個是沒有的，最後一個有的自然就是新的 599w 的size，對不對，接下來用 !do 打出這三個地址的值。

0:011> !do 0000016c91308048
Name:        System.Collections.Generic.HashSet`1+Slot[[System.Int32, System.Private.CoreLib]][]
Size:        16743180(0xff7b0c) bytes
Array:       Rank 1, Number of elements 1395263, Type VALUETYPE (Print Array)
Fields:
None

0:011> !do 0000016c928524b0
Name:        System.Collections.Generic.HashSet`1+Slot[[System.Int32, System.Private.CoreLib]][]
Size:        34719012(0x211c524) bytes
Array:       Rank 1, Number of elements 2893249, Type VALUETYPE (Print Array)
Fields:
None

0:011> !do 0000016ce9e61020
Name:        System.Collections.Generic.HashSet`1+Slot[[System.Int32, System.Private.CoreLib]][]
Size:        71993676(0x44a894c) bytes
Array:       Rank 1, Number of elements 5999471, Type VALUETYPE (Print Array)
Fields:
None

從上面的 Rank 1, Number of elements 信息中可以看到，原來託管堆不僅有擴容前的Size ：2893249，還有更前一次的擴容Size: 1395263，所以按這種情況算： 託管堆上的總大小近似為： 23.7M + 47.4M + 91.5M = 162.6M，我去，不簡單把。。。 也就是說：託管堆上有 162.6 - 91.5 =71.1M 的未回收垃圾 剛才的 47.4M 的空間虛佔用，總浪費為:118.5M，但願我沒有算錯。。。

3. 有解決方案嗎？

在List中大家可以通過 Capacity 去控制List的Size，但是很遺憾，在 HashSet 中並沒有類似的解決方案，只有一個很笨拙的裁剪方法: TrimExcess，用於將當前Size擴展到最接近的 質數 值， 如下代碼所示：

public void TrimExcess()
{
	int prime = HashHelpers.GetPrime(m_count);
	Slot[] array = new Slot[prime];
	int[] array2 = new int[prime];
	int num = 0;
	for (int i = 0; i < m_lastIndex; i++)
	{
		if (m_slots[i].hashCode >= 0)
		{
			array[num] = m_slots[i];
			int num2 = array[num].hashCode % prime;
			array[num].next = array2[num2] - 1;
			array2[num2] = num + 1;
			num++;
		}
	}
}

應用到本案例就是將 289w 限制到 347w，仍然有 58w的空間佔用。 如下圖：

三： 總結

HashSet的時間和空間上虛占遠比你想象的大很多，而且實占也不小，因為底層用到了雙數組 m_slots 和 m_buckets，每個Slot還有三個元素: struct Slot { int hashCode;internal int next;internal T value; }，所以了解完原理之後謹慎着用吧。

如您有更多問題與我互動，掃描下方進來吧~

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

系列文章

1. 基於 abp vNext 和 .NET Core 開發博客項目 – 使用 abp cli 搭建項目
2. 基於 abp vNext 和 .NET Core 開發博客項目 – 給項目瘦身，讓它跑起來
3. 基於 abp vNext 和 .NET Core 開發博客項目 – 完善與美化，Swagger登場
4. 基於 abp vNext 和 .NET Core 開發博客項目 – 數據訪問和代碼優先
5. 基於 abp vNext 和 .NET Core 開發博客項目 – 自定義倉儲之增刪改查
6. 基於 abp vNext 和 .NET Core 開發博客項目 – 統一規範API，包裝返回模型
7. 基於 abp vNext 和 .NET Core 開發博客項目 – 再說Swagger，分組、描述、小綠鎖
8. 基於 abp vNext 和 .NET Core 開發博客項目 – 接入GitHub，用JWT保護你的API
9. 基於 abp vNext 和 .NET Core 開發博客項目 – 異常處理和日誌記錄
10. 基於 abp vNext 和 .NET Core 開發博客項目 – 使用Redis緩存數據
11. 基於 abp vNext 和 .NET Core 開發博客項目 – 集成Hangfire實現定時任務處理
12. 基於 abp vNext 和 .NET Core 開發博客項目 – 用AutoMapper搞定對象映射
13. 基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰（一）
14. 基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰（二）
15. 基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰（三）
16. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（一）
17. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（二）
18. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（三）
19. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（四）
20. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（五）
21. 基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（一）
22. 基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（二）
23. 基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（三）
24. 基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（四）
25. 基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（五）
26. 基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（六）
27. 基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（七）
28. 基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（八）
29. 基於 abp vNext 和 .NET Core 開發博客項目 – Blazor 實戰系列（九）
30. 基於 abp vNext 和 .NET Core 開發博客項目 – 終結篇之發布項目

上一篇完成了標籤模塊和友情鏈接模塊的所有功能，本篇來繼續完成博客最後的模塊，文章的管理。

文章列表 & 刪除

先將分頁查詢的列表給整出來，這塊和首頁的分頁列表是類似的，就是多了個Id字段。

先添加兩條路由規則。

@page "/admin/posts"
@page "/admin/posts/{page:int}"

新建返回數據默認QueryPostForAdminDto.cs。

//QueryPostForAdminDto.cs
using System.Collections.Generic;

namespace Meowv.Blog.BlazorApp.Response.Blog
{
    public class QueryPostForAdminDto
    {
        /// <summary>
        /// 年份
        /// </summary>
        public int Year { get; set; }

        /// <summary>
        /// Posts
        /// </summary>
        public IEnumerable<PostBriefForAdminDto> Posts { get; set; }
    }
}

//PostBriefForAdminDto.cs
namespace Meowv.Blog.BlazorApp.Response.Blog
{
    public class PostBriefForAdminDto : PostBriefDto
    {
        /// <summary>
        /// 主鍵
        /// </summary>
        public int Id { get; set; }
    }
}

然後添加所需的參數：當前頁碼、限制條數、總頁碼、文章列表返回數據模型。

/// <summary>
/// 當前頁碼
/// </summary>
[Parameter]
public int? page { get; set; }

/// <summary>
/// 限制條數
/// </summary>
private int Limit = 15;

/// <summary>
/// 總頁碼
/// </summary>
private int TotalPage;

/// <summary>
/// 文章列表數據
/// </summary>
private ServiceResult<PagedList<QueryPostForAdminDto>> posts;

然後在初始化函數OnInitializedAsync()中調用API獲取文章數據.

/// <summary>
/// 初始化
/// </summary>
protected override async Task OnInitializedAsync()
{
    var token = await Common.GetStorageAsync("token");
    Http.DefaultRequestHeaders.Add("Authorization", $"Bearer {token}");

    // 設置默認值
    page = page.HasValue ? page : 1;

    await RenderPage(page);
}

/// <summary>
/// 點擊頁碼重新渲染數據
/// </summary>
/// <param name="page"></param>
/// <returns></returns>
private async Task RenderPage(int? page)
{
    // 獲取數據
    posts = await Http.GetFromJsonAsync<ServiceResult<PagedList<QueryPostForAdminDto>>>($"/blog/admin/posts?page={page}&limit={Limit}");

    // 計算總頁碼
    TotalPage = (int)Math.Ceiling((posts.Result.Total / (double)Limit));
}

在初始化中判斷page參數，如果沒有值給他設置一個默認值1。RenderPage(int? page)方法是調用API返回數據，並計算出總頁碼值。

最後在頁面上進行數據綁定。

<AdminLayout>
    @if (posts == null)
    {
        <Loading />
    }
    else
    {
        <div class="post-wrap archive">
            <NavLink style="float:right" href="/admin/post"><h3>~~~ 新增文章 ~~~</h3></NavLink>
            @if (posts.Success && posts.Result.Item.Any())
            {
                @foreach (var item in posts.Result.Item)
                {
                    <h3>@item.Year</h3>
                    @foreach (var post in item.Posts)
                    {
                        <article class="archive-item">
                            <NavLink title="刪除" @onclick="@(async () => await DeleteAsync(post.Id))"></NavLink>
                            <NavLink title="編輯" @onclick="@(async () => await Common.NavigateTo($"/admin/post/{post.Id}"))"></NavLink>
                            <NavLink target="_blank" class="archive-item-link" href="@("/post" + post.Url)">@post.Title</NavLink>
                            <span class="archive-item-date">@post.CreationTime</span>
                        </article>
                    }
                }
                <nav class="pagination">
                    @for (int i = 1; i <= TotalPage; i++)
                    {
                        var _page = i;

                        if (page == _page)
                        {
                            <span class="page-number current">@_page</span>
                        }
                        else
                        {
                            <a class="page-number" @onclick="@(() => RenderPage(_page))" href="/admin/posts/@_page">@_page</a>
                        }
                    }
                </nav>
            }
            else
            {
                <ErrorTip />
            }
        </div>
    }
</AdminLayout>

HTML內容放在組件AdminLayout中，當 posts 沒加載完數據的時候显示加載組件<Loading />。

在頁面上循環遍歷文章數據和翻頁頁碼，每篇文章標題前面添加兩個按鈕刪除和編輯，同時單獨加了一個新增文章的按鈕。

刪除文章調用DeleteAsync(int id)方法，需要傳遞參數，當前文章的id。

新增和編輯按鈕都跳轉到”/admin/post”頁面，當編輯的時候將id也傳過去即可，路由規則為：”/admin/post/{id}”。

刪除文章“方法如下：

/// <summary>
/// 刪除文章
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
private async Task DeleteAsync(int id)
{
    // 彈窗確認
    bool confirmed = await Common.InvokeAsync<bool>("confirm", "\n真的要幹掉這篇該死的文章嗎");

    if (confirmed)
    {
        var response = await Http.DeleteAsync($"/blog/post?id={id}");

        var result = await response.Content.ReadFromJsonAsync<ServiceResult>();

        if (result.Success)
        {
            await RenderPage(page);
        }
    }
}

刪除之前進行二次確認，避免誤刪，當確認刪除之後調用刪除文章API，最後重新渲染數據即可。

新增 & 更新文章

完成了後台文章列表的查詢和刪除，現在整個博客模塊功能就差新增和更新文章了，勝利就在前方，沖啊。

這塊的開發工作耗費了我太多時間，因為想使用 markdown 來寫文章，找了一圈下來沒有一個合適的組件，所以退而求次只能選擇現有的markdown編輯器來實現了。

我這裏選擇了開源的編輯器Editor.md，有需要的可以去 Github 自己下載，https://github.com/pandao/editor.md 。

將下載的資源包解壓放在 wwwroot 文件夾下，默認是比較大的，而且還有很多示例文件，我已經將其精簡了一番，可以去我 Github 下載使用。

先來看下最終的成品效果吧。

是不是感覺還可以，廢話不多說，接下里告訴大家如何實現。

在 Admin 文件夾下添加post.razor組件，設置路由，並且引用一個樣式文件，在頁面中引用樣式文件好像不太符合標準，不過無所謂了，這個後台就自己用，而且還就這一個頁面用得到。

@page "/admin/post"
@page "/admin/post/{id:int}"

<link href="./editor.md/css/editormd.css" rel="stylesheet" />

<AdminLayout>
    ...
</AdminLayout>

把具體HTML內容放在組件AdminLayout中。

因為新增和編輯放在同一個頁面上，所以當id參數不為空的時候需要添加一個id參數，同時默認一進來就讓頁面显示加載中的組件，當頁面和數據加載完成后在显示具體的內容，所以在指定一個布爾類型的是否加載參數isLoading。

我們的編輯器主要依賴JavaScript實現的，所以這裏不可避免要使用到JavaScript了。

在app.js中添加幾個全局函數。

switchEditorTheme: function () {
    editor.setTheme(localStorage.editorTheme || 'default');
    editor.setEditorTheme(localStorage.editorTheme === 'dark' ? 'pastel-on-dark' : 'default');
    editor.setPreviewTheme(localStorage.editorTheme || 'default');
},
renderEditor: async function () {
	await this._loadScript('./editor.md/lib/zepto.min.js').then(function () {
	    func._loadScript('./editor.md/editormd.js').then(function () {
	        editor = editormd("editor", {
	            width: "100%",
	            height: 700,
	            path: './editor.md/lib/',
	            codeFold: true,
	            saveHTMLToTextarea: true,
	            emoji: true,
	            atLink: false,
	            emailLink: false,
	            theme: localStorage.editorTheme || 'default',
	            editorTheme: localStorage.editorTheme === 'dark' ? 'pastel-on-dark' : 'default',
	            previewTheme: localStorage.editorTheme || 'default',
	            toolbarIcons: function () {
	                return ["bold", "del", "italic", "quote", "ucwords", "uppercase", "lowercase", "h1", "h2", "h3", "h4", "h5", "h6", "list-ul", "list-ol", "hr", "link", "image", "code", "preformatted-text", "code-block", "table", "datetime", "html-entities", "emoji", "watch", "preview", "fullscreen", "clear", "||", "save"]
	            },
	            toolbarIconsClass: {
	                save: "fa-check"
	            },
	            toolbarHandlers: {
	                save: function () {
	                    func._shoowBox();
	                }
	            },
	            onload: function () {
	                this.addKeyMap({
	                    "Ctrl-S": function () {
	                        func._shoowBox();
	                    }
	                });
	            }
	        });
	    });
	});
},
_shoowBox: function () {
    DotNet.invokeMethodAsync('Meowv.Blog.BlazorApp', 'showbox');
},
_loadScript: async function (url) {
    let response = await fetch(url);
    var js = await response.text();
    eval(js);
}

renderEditor主要實現了動態加載JavaScript代碼，將markdown編輯器渲染出來。這裏不多說，都是Editor.md示例裏面的代碼。

為了兼容暗黑色主題，這裏還加了一個切換編輯器主題的JavaScript方法，switchEditorTheme。

_shoowBox就厲害了，這個方法是調用的.NET組件中的方法，前面我們用過了在Blazor中調用JavaScript，這裏演示了JavaScript中調用Blazor中的組件方法。

現在將所需的幾個參數都添加到代碼中。

/// <summary>
/// 定義一個委託方法，用於組件實例方法調用
/// </summary>
private static Func<Task> action;

/// <summary>
/// 默認隱藏Box
/// </summary>
private bool Open { get; set; } = false;

/// <summary>
/// 修改時的文章Id
/// </summary>
[Parameter]
public int? Id { get; set; }

/// <summary>
/// 格式化的標籤
/// </summary>
private string tags { get; set; }

/// <summary>
/// 默認显示加載中
/// </summary>
private bool isLoading = true;

/// <summary>
/// 文章新增或者修改輸入參數
/// </summary>
private PostForAdminDto input;

/// <summary>
/// API返回的分類列表數據
/// </summary>
private ServiceResult<IEnumerable<QueryCategoryForAdminDto>> categories;

大家看看註釋就知道參數是做什麼的了。

現在我們在初始化函數中將所需的數據通過API獲取到。

/// <summary>
/// 初始化
/// </summary>
/// <returns></returns>
protected override async Task OnInitializedAsync()
{
    action = ChangeOpenStatus;

    var token = await Common.GetStorageAsync("token");
    Http.DefaultRequestHeaders.Add("Authorization", $"Bearer {token}");

    if (Id.HasValue)
    {
        var post = await Http.GetFromJsonAsync<ServiceResult<PostForAdminDto>>($"/blog/admin/post?id={Id}");

        if (post.Success)
        {
            var _post = post.Result;
            input = new PostForAdminDto
            {
                Title = _post.Title,
                Author = _post.Author,
                Url = _post.Url,
                Html = _post.Html,
                Markdown = _post.Markdown,
                CategoryId = _post.CategoryId,
                Tags = _post.Tags,
                CreationTime = _post.CreationTime
            };

            tags = string.Join(",", input.Tags);
        }
    }
    else
    {
        input = new PostForAdminDto()
        {
            Author = "阿星Plus",
            CreationTime = DateTime.Now
        };
    }

    categories = await Http.GetFromJsonAsync<ServiceResult<IEnumerable<QueryCategoryForAdminDto>>>("/blog/admin/categories");

    // 渲染編輯器
    await Common.InvokeAsync("window.func.renderEditor");

    // 關閉加載
    isLoading = !isLoading;
}

action是一個異步的委託，在初始化中執行了ChangeOpenStatus方法，這個方法等會說，然後獲取localStorage中token的值。

通過參數Id是否有值來判斷當前是新增文章還是更新文章，如果有值就是更新文章，這時候需要根據id去將文章的數據拿到賦值給PostForAdminDto對象展示在頁面上，如果沒有可以添加幾個默認值給PostForAdminDto對象。

因為文章需要分類和標籤的數據，同時這裏將分類的數據也查出來，標籤默認是List列表，將其轉換成字符串類型。

但完成上面操作后，調用JavaScript方法renderEditor渲染渲染編輯器，最後關閉加載，显示頁面。

現在來看看頁面。

<AdminLayout>
    @if (isLoading)
    {
        <Loading />
    }
    else
    {
        <div class="post-box">
            <div class="post-box-item">
                <input type="text" placeholder="標題" autocomplete="off" @bind="@input.Title" @bind:event="oninput" @onclick="@(() => { Open = false; })" />
                <input type="text" placeholder="作者" autocomplete="off" @bind="@input.Author" @bind:event="oninput" @onclick="@(() => { Open = false; })" />
            </div>
            <div class="post-box-item">
                <input type="text" placeholder="URL" autocomplete="off" @bind="@input.Url" @bind:event="oninput" @onclick="@(() => { Open = false; })" />
                <input type="text" placeholder="時間" autocomplete="off" @bind="@input.CreationTime" @bind:format="yyyy-MM-dd HH:mm:sss" @bind:event="oninput" @onclick="@(() => { Open = false; })" />
            </div>
            <div id="editor">
                <textarea style="display:none;">@input.Markdown</textarea>
            </div>

            <Box OnClickCallback="@SubmitAsync" Open="@Open" ButtonText="發布">
                <div class="box-item">
                    <b>分類：</b>
                    @if (categories.Success && categories.Result.Any())
                    {
                        @foreach (var item in categories.Result)
                        {
                            <label><input type="radio" name="category" value="@item.Id" @onchange="@(() => { input.CategoryId = item.Id; })" checked="@(item.Id == input.CategoryId)" />@item.CategoryName</label>
                        }
                    }
                </div>
                <div class="box-item"></div>
                <div class="box-item">
                    <b>標籤：</b>
                    <input type="text" @bind="@tags" @bind:event="oninput" />
                </div>
            </Box>
        </div>
    }
</AdminLayout>

添加了四個input框，分別用來綁定標題、作者、URL、時間，<div id="editor"></div>中為編輯器所需。

然後我這裏還是把之前的彈窗組件搞出來了，執行邏輯不介紹了，在彈窗組件中自定義显示分類和標籤的內容，將獲取到的分類和標籤綁定到具體位置。

每個分類都是一個radio標籤，並且對應一個點擊事件，點哪個就把當前分類的Id賦值給PostForAdminDto對象。

所有的input框都使用@bind和@bind:event綁定數據和獲取數據。

Box彈窗組件這裏自定義了按鈕文字，ButtonText="發布"。

/// <summary>
/// 改變Open狀態，通知組件渲染
/// </summary>
private async Task ChangeOpenStatus()
{
    Open = true;

    var markdown = await Common.InvokeAsync<string>("editor.getMarkdown");
    var html = await Common.InvokeAsync<string>("editor.getHTML");

    if (string.IsNullOrEmpty(input.Title) || string.IsNullOrEmpty(input.Url) ||
        string.IsNullOrEmpty(input.Author) || string.IsNullOrEmpty(markdown) ||
        string.IsNullOrEmpty(html))
    {
        await Alert();
    }

    input.Html = html;
    input.Markdown = markdown;

    StateHasChanged();
}

/// <summary>
/// 暴漏給JS執行，彈窗確認框
/// </summary>
[JSInvokable("showbox")]
public static void ShowBox()
{
    action.Invoke();
}

/// <summary>
/// alert提示
/// </summary>
/// <returns></returns>
private async Task Alert()
{
    Open = false;

    await Common.InvokeAsync("alert", "\n好像漏了點什麼吧");
    return;
}

現在可以來看看ChangeOpenStatus方法了，這個是改變當前彈窗狀態的一個方法。為什麼需要這個方法呢?

因為在Blazor中JavaScript想要調用組件內的方法，方法必須是靜態的，那麼只能通過這種方式去實現了，在靜態方法是不能夠直接改變彈窗的狀態值的。

其實也可以不用這麼麻煩，因為我在編輯器上自定義了一個按鈕，為了好看一些所以只能曲折一點，嫌麻煩的可以直接在頁面上搞個按鈕執行保存數據邏輯也是一樣的。

使用JSInvokableAttribute需要在_Imports.razor中添加命名空間@using Microsoft.JSInterop。

ChangeOpenStatus中獲取到文章內容：HTML和markdown，賦值給PostForAdminDto對象，要先進行判斷頁面上的幾個參數是否有值，沒值的話給出提示執行Alert()方法，最後使用StateHasChanged()通知組件其狀態已更改。

Alert方法就是調用原生的JavaScriptalert方法，給出一個提示。

ShowBox就是暴漏給JavaScript的方法，使用DotNet.invokeMethodAsync('Meowv.Blog.BlazorApp', 'showbox');進行調用。

那麼現在一切都正常進行的情況下，點擊編輯器上自定義的保存按鈕，頁面上值不為空的情況下就會彈出我們的彈窗組件Box。

最後在彈窗組件的回調方法中執行新增文章還是更新文章。

/// <summary>
/// 確認按鈕點擊事件
/// </summary>
/// <returns></returns>
private async Task SubmitAsync()
{
    if (string.IsNullOrEmpty(tags) || input.CategoryId == 0)
    {
        await Alert();
    }

    input.Tags = tags.Split(",");

    var responseMessage = new HttpResponseMessage();

    if (Id.HasValue)
        responseMessage = await Http.PutAsJsonAsync($"/blog/post?id={Id}", input);
    else
        responseMessage = await Http.PostAsJsonAsync("/blog/post", input);

    var result = await responseMessage.Content.ReadFromJsonAsync<ServiceResult>();
    if (result.Success)
    {
        await Common.NavigateTo("/admin/posts");
    }
}

打開彈窗后執行回調事件之前還是要判斷值是否為空，為空的情況下還是給出alert提示，此時將tags標籤還是轉換成List列表，根據Id是否有值去執行新增數據或者更新數據，最終成功后跳轉到文章列表頁。

本片到這裏就結束了，主要攻克了在Blazor中使用Markdown編輯器實現新增和更新文章，這個系列差不多就快結束了，預計還有2篇的樣子，感謝各位的支持。

開源地址：https://github.com/Meowv/Blog/tree/blog_tutorial

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

作者：小傅哥

博客：https://bugstack.cn

沉澱、分享、成長，讓自己和他人都能有所收穫！

一、前言

難以跨越的瓶頸期，把你拿捏滴死死的！

編程開發學習過程中遇到的瓶頸期，往往是由於看不到前進的方向。這個時候你特別希望能有人告訴你，你還欠缺些什麼朝着哪個方向努力。而導致這一問題的主要原因是由於日常的業務開發太過於複製過去，日復一日的重複。沒有太多的挑戰，也沒參与過較大體量的業務場景，除了這些開發場景因素外，還有缺少組內的技術氛圍和技術分享，沒有人做傳播和佈道者，也缺少自己對各項技術學習的熱情，從而導致一直遊盪在瓶頸之下，難以提升。

小公司與大公司，選擇哪個？

刨除掉薪資以外你會選擇什麼，是不有人建議小公司，因為可以接觸到各個環境，也有人建議大公司，因為正規體量大可以學習到更多。有些時候你的技術成長緩慢也是因為你的不同選擇而導致的，小公司確實要接觸各個環境，但往往如果你所做的業務體量不高，那麼你會用到的技術棧就會相對較少，同時也會技術棧研究的深度也會較淺。大公司中確實有時候你不需要去關心一個集群的部署和維護、一个中間件的開發、全套服務監控等等，但如果你願意了解這些技術在內部都是公開的，你會擁有無限的技術營養可以補充。而這最主要的是提升視野和事業。

除了業務中的CRUD開發，有些技術你真的很難接觸到！

可能很多小夥伴認為技術開發就是承接下產品需求，寫寫CRUD，不會的百度一下，就完事了，總覺得別人問的東西像再造火箭一樣。但在高體量、高併發的業務場景下，每一次的壓測優化，性能提升，都像在研究一道數學題一樣，反覆的錘鍊，壓榨性能。不斷的深究，找到最合適的設計。除了這些優化提升外，還有那麼廣闊的技術體系棧，都可能因為你只是注重CRUD而被忽略；字節碼編程、領域驅動設計架構、代理模式中間件開發、JVM虛擬機實現原理等等。

二、開發環境

1. JDK 1.8
2. Idea + Maven
3. Spring 4.3.24.RELEASE
4. 涉及工程三個，可以通過關注公眾號：bugstack蟲洞棧，回復源碼下載獲取(打開獲取的鏈接，找到序號18)

三、代理模式介紹

代理模式有點像老大和小弟，也有點像分銷商。主要解決的是問題是為某些資源的訪問、對象的類的易用操作上提供方便使用的代理服務。而這種設計思想的模式經常會出現在我們的系統中，或者你用到過的組件中，它們都提供給你一種非常簡單易用的方式控制原本你需要編寫很多代碼的進行使用的服務類。

類似這樣的場景可以想到；

1. 你的數據庫訪問層面經常會提供一個較為基礎的應用，以此來減少應用服務擴容時不至於數據庫連接數暴增。
2. 使用過的一些中間件例如；RPC框架，在拿到jar包對接口的描述后，中間件會在服務啟動的時候生成對應的代理類，當調用接口的時候，實際是通過代理類發出的socket信息進行通過。
3. 另外像我們常用的MyBatis，基本是定義接口但是不需要寫實現類，就可以對xml或者自定義註解里的sql語句進行增刪改查操作。

四、案例場景模擬

在本案例中我們模擬實現mybatis-spring中代理類生成部分

對於Mybatis的使用中只需要定義接口不需要寫實現類就可以完成增刪改查操作，有疑問的小夥伴，在本章節中就可以學習到這部分知識。解析下來我們會通過實現一個這樣的代理類交給spring管理的核心過程，來講述代理類模式。

這樣的案例場景在實際的業務開發中其實不多，因為這是將這種思想運用在中間件開發上，而很多小夥伴經常是做業務開發，所以對Spring的bean定義以及註冊和對代理以及反射調用的知識了解的相對較少。但可以通過本章節作為一個入門學習，逐步了解。

五、代理類模式實現過程

接下來會使用代理類模式來模擬實現一個Mybatis中對類的代理過程，也就是只需要定義接口，就可以關聯到方法註解中的sql語句完成對數據庫的操作。

這裏需要注意一些知識點；

1. BeanDefinitionRegistryPostProcessor，spring的接口類用於處理對bean的定義註冊。
2. GenericBeanDefinition，定義bean的信息，在mybatis-spring中使用到的是；ScannedGenericBeanDefinition 略有不同。
3. FactoryBean，用於處理bean工廠的類，這個類非常見。

1. 工程結構

itstack-demo-design-12-00
└── src
    ├── main
    │   ├── java
    │   │   └── org.itstack.demo.design
    │   │       ├── agent
    │   │       │	├── MapperFactoryBean.java
    │   │       │	├── RegisterBeanFactory.java
    │   │       │	└── Select.java
    │   │       └── IUserDao.java
    │   └── resources	
    │       └── spring-config.xml
    └── test
        └── java
            └── org.itstack.demo.test
                └── ApiTest.java

代理模式中間件模型結構

• 此模型中涉及的類並不多，但都是抽離出來的核心處理類。主要的事情就是對類的代理和註冊到spring中。
• 上圖中最上面是關於中間件的實現部分，下面對應的是功能的使用。

2. 代碼實現

2.1 自定義註解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Select {

    String value() default "";  // sql語句

}

• 這裏我們定義了一個模擬mybatis-spring中的自定義註解，用於使用在方法層面。

2.2 Dao層接口

public interface IUserDao {

    @Select("select userName from user where id = #{uId}")
    String queryUserInfo(String uId);

}

• 這裏定義一個Dao層接口，並把自定義註解添加上。這與你使用的mybatis組件是一樣的。
• 2.1和2.2是我們的準備工作，後面開始實現中間件功能部分。

2.3 代理類定義

public class MapperFactoryBean<T> implements FactoryBean<T> {

    private Logger logger = LoggerFactory.getLogger(MapperFactoryBean.class);

    private Class<T> mapperInterface;

    public MapperFactoryBean(Class<T> mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    @Override
    public T getObject() throws Exception {
        InvocationHandler handler = (proxy, method, args) -> {
            Select select = method.getAnnotation(Select.class);
            logger.info("SQL：{}", select.value().replace("#{uId}", args[0].toString()));
            return args[0] + ",小傅哥,bugstack.cn - 沉澱、分享、成長，讓自己和他人都能有所收穫！";
        };
        return (T) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{mapperInterface}, handler);
    }

    @Override
    public Class<?> getObjectType() {
        return mapperInterface;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

}

• 如果你有閱讀過mybatis源碼，是可以看到這樣的一個類；MapperFactoryBean，這裏我們也模擬一個這樣的類，在裏面實現我們對代理類的定義。
• 通過繼承FactoryBean，提供bean對象，也就是方法；T getObject()。
• 在方法getObject()中提供類的代理以及模擬對sql語句的處理，這裏包含了用戶調用dao層方法時候的處理邏輯。
• 還有最上面我們提供構造函數來透傳需要被代理類，Class<T> mapperInterface，在mybatis中也是使用這樣的方式進行透傳。
• 另外getObjectType()提供對象類型反饋，以及isSingleton()返回類是單例的。

2.4 將Bean定義註冊到Spring容器

public class RegisterBeanFactory implements BeanDefinitionRegistryPostProcessor {
    
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(MapperFactoryBean.class);
        beanDefinition.setScope("singleton");
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(IUserDao.class);

        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, "userDao");
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        // left intentionally blank
    }

}

• 這裏我們將代理的bean交給spring容器管理，也就可以非常方便讓我們可以獲取到代理的bean。這部分是spring中關於一個bean註冊過程的源碼。
• GenericBeanDefinition，用於定義一個bean的基本信息setBeanClass(MapperFactoryBean.class);，也包括可以透傳給構造函數信息addGenericArgumentValue(IUserDao.class);
• 最後使用 BeanDefinitionReaderUtils.registerBeanDefinition，進行bean的註冊，也就是註冊到DefaultListableBeanFactory中。

2.5 配置文件spring-config

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
       default-autowire="byName">

    <bean id="userDao" class="org.itstack.demo.design.agent.RegisterBeanFactory"/>

</beans>

• 接下來在配置文件中添加我們的bean配置，在mybatis的使用中一般會配置掃描的dao層包，這樣就可以減少這部分的配置。

3. 測試驗證

3.1 編寫測試類

@Test
public void test_IUserDao() {
    BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring-config.xml");
    IUserDao userDao = beanFactory.getBean("userDao", IUserDao.class);
    String res = userDao.queryUserInfo("100001");
    logger.info("測試結果：{}", res);
}

• 測試的過程比較簡單，通過加載Bean工廠獲取我們的代理類的實例對象，之後調用方法返回結果。
• 那麼這個過程你可以看到我們是沒有對接口先一個實現類的，而是使用代理的方式給接口生成一個實現類，並交給spring管理。

3.2 測試結果

23:21:57.551 [main] DEBUG o.s.core.env.StandardEnvironment - Adding PropertySource 'systemProperties' with lowest search precedence
...
23:21:57.858 [main] DEBUG o.s.c.s.ClassPathXmlApplicationContext - Unable to locate LifecycleProcessor with name 'lifecycleProcessor': using default [org.springframework.context.support.DefaultLifecycleProcessor@7bc1a03d]
23:21:57.859 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance of singleton bean 'lifecycleProcessor'
23:21:57.860 [main] DEBUG o.s.c.e.PropertySourcesPropertyResolver - Could not find key 'spring.liveBeansView.mbeanDomain' in any property source
23:21:57.861 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance of singleton bean 'userDao'
23:21:57.915 [main] INFO  o.i.d.design.agent.MapperFactoryBean - SQL：select userName from user where id = 100001
23:21:57.915 [main] INFO  org.itstack.demo.design.test.ApiTest - 測試結果：100001,小傅哥,bugstack.cn - 沉澱、分享、成長，讓自己和他人都能有所收穫！

Process finished with exit code 0

• 從測試結果可以看到，我們打印了SQL語句，這部分語句是從自定義註解中獲取的；select userName from user where id = 100001，我們做了簡單的適配。在mybatis框架中會交給SqlSession的實現類進行邏輯處理返回操作數據庫數據
• 而這裏我們的測試結果是一個固定的，如果你願意更加深入的研究可以嘗試與數據庫操作層進行關聯，讓這個框架可以更加完善。

六、總結

• 關於這部分代理模式的講解我們採用了開發一個關於mybatis-spring中間件中部分核心功能來體現代理模式的強大之處，所以涉及到了一些關於代理類的創建以及spring中bean的註冊這些知識點，可能在平常的業務開發中都是很少用到的，但是在中間件開發中確實非常常見的操作。
• 代理模式除了開發中間件外還可以是對服務的包裝，物聯網組件等等，讓複雜的各項服務變為輕量級調用、緩存使用。你可以理解為你家裡的電燈開關，我們不能操作220v電線的人肉連接，但是可以使用開關，避免觸電。
• 代理模式的設計方式可以讓代碼更加整潔、乾淨易於維護，雖然在這部分開發中額外增加了很多類也包括了自己處理bean的註冊等，但是這樣的中間件復用性極高也更加智能，可以非常方便的擴展到各個服務應用中。

七、推薦閱讀

• 1. 重學 Java 設計模式：實戰工廠方法模式(多種類型商品發獎場景)
• 2. 重學 Java 設計模式：實戰建造者模式(裝修物料組合套餐選配場景)
• 3. 重學 Java 設計模式：實戰原型模式(多套試每人題目和答案亂序場景)
• 4. 重學 Java 設計模式：實戰橋接模式(多支付渠道「微信支付寶」與多支付模式「刷臉、指紋」場景)
• 5. 重學 Java 設計模式：實戰組合模式(營銷差異化人群發券決策樹引擎搭建場景)
• 6. 重學 Java 設計模式：實戰外觀模式「基於SpringBoot開發門面模式中間件，統一控制接口白名單場景」

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※教你寫出一流的銷售文案?

ML.net已經進到了1.5版本。作為Microsoft官方的機器學習模型，你不打算用用？

一、前言

ML.net可以讓我們很容易地在各種應用場景中將機器學習加入到應用程序中。這是這個框架很重要的一點。

通過ML.net，我們可以使用手中的可用數據，進行預測、分析、檢測，而不需要進行過於複雜的編程。

ML.net的核心，同樣是機器學習模型。它採用同樣的步驟，通過指定算法來訓練模型，將輸入數據轉換為所需的預測數據。

更重要的是，ML.net基於.NET Core，這讓它可以非常簡單地跨平台，在Windows、Linux、MacOS上運行，並成為我們服務端的一部分內容。

回到今天的主題。

我們用實際的例子，完成一個通過歷史銷售數據進行單變量時序分析（單譜分析），以預測未來銷量的需求。

    為了防止不提供原網址的轉載，特在這裏加上原文鏈接：https://www.cnblogs.com/tiger-wang/p/13150021.html

二、開發環境&基礎工程

這個Demo的開發環境是：Mac + VS Code + Dotnet Core 3.1.2。

$ dotnet --info
.NET Core SDK (reflecting any global.json):
 Version:   3.1.201
 Commit:    b1768b4ae7

Runtime Environment:
 OS Name:     Mac OS X
 OS Version:  10.15
 OS Platform: Darwin
 RID:         osx.10.15-x64
 Base Path:   /usr/local/share/dotnet/sdk/3.1.201/

Host (useful for support):
  Version: 3.1.3
  Commit:  4a9f85e9f8

.NET Core SDKs installed:
  3.1.201 [/usr/local/share/dotnet/sdk]

.NET Core runtimes installed:
  Microsoft.AspNetCore.App 3.1.3 [/usr/local/share/dotnet/shared/Microsoft.AspNetCore.App]
  Microsoft.NETCore.App 3.1.3 [/usr/local/share/dotnet/shared/Microsoft.NETCore.App]

首先，在這個環境下建立工程：

1. 創建Solution

% dotnet new sln -o demo
The template "Solution File" was created successfully.

1. 這次，我們用Console創建工程

% cd demo
% dotnet new console -o demo
The template "Console Application" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on demo/demo.csproj...
  Determining projects to restore...
  Restored demo/demo.csproj (in 143 ms).

Restore succeeded.

1. 把工程加到Solution中

% dotnet sln add demo/demo.csproj

基礎工程搭建完成。

三、引入ML.net庫

為了使用ML.net，我們需要引入Microsoft.ML庫：

% cd demo
% dotnet add package Microsoft.ML

除此之外，本文是基於時序的預測，還需要引入時序庫Microsoft.ML.TimeSeries：

% dotnet add package Microsoft.ML.TimeSeries

我們今天用到的算法是單譜分析（SSA）。SSA會將時序分解為一組主要成分， 並將這些成分解釋為信號，對應於趨勢、噪音、季節性及許多其他的因素，然後重新構建這些成分，用來預測未來某個時間的值。

四、準備數據

為了這個DEMO，我準備了一個包含全年365天實際銷售金額的數據。

其中這個數據又分為了兩部分，第一部分是前11個月的數據，用來做訓練，第二部分是12月一個月的數據，用來評估模型。

兩部分數據的鏈接如下：訓練數據，評估數據

兩個數據文件均為CSV文件，數據結構完全相同，下面是一段內容範例：

2018-12-21,17959.0
2018-12-22,19537.03
2018-12-23,20068.0
2018-12-24,20013.0
2018-12-25,21005.0
2018-12-26,16876.0
2018-12-27,15150.0
2018-12-28,15669.0
2018-12-29,25048.0
2018-12-30,25236.0

五、代碼開發

1. 準備一個輸入模型ModelInput

public class ModelInput
{
    [LoadColumn(0)]
    public DateTime action_time { get; set; }
    [LoadColumn(1)]
    public float count { get; set; }
}

這個模型對應數據文件的結構，分兩個字段，第一個是日期，第二個是對應的銷售金額。

1. 準備另一個輸出模型ModelOutput

public class ModelOutput
{
    public float[] forecasted_count { get; set; }
    public float[] lower_count { get; set; }
    public float[] upper_count { get; set; }
}

這個模型跟隨預測結果的輸出，其中：

• forecasted_count – 預測時間段內的預測值
• lower_count – 預測時間段內預測值的下限
• upper_count – 預測時間段內預測值的上限

1. 初始化機器學習的實例

MLContext mlContext = new MLContext();

執行所有 ML.NET 操作都是從MLContext類開始，初始化 MLContext將創建一個新的 ML.net 環境，並在模型創建工作流對象之間共享該環境。

1. 加載數據

ML.net有多種數據的加載方式，可以通過文件、數據庫、JSON/XML、內存中加載數據，甚至可以用自定義的數據庫連接加載數據。

本文的DEMO中，數據在CSV文件中，所以，我們採用下面的方式加載：

static readonly string _data1Path = Path.Combine(Environment.CurrentDirectory, "data1.csv");
static readonly string _data2Path = Path.Combine(Environment.CurrentDirectory, "data2.csv");

static void Main(string[] args)
{
    MLContext mlContext = new MLContext();

    IDataView data1View = mlContext.Data.LoadFromTextFile<ModelInput>(_data1Path, separatorChar: ',', hasHeader: false);
    IDataView data2View = mlContext.Data.LoadFromTextFile<ModelInput>(_data2Path, separatorChar: ',', hasHeader: false);
}

IDataView是數據的承載空間。

1. 定義時序分析管道

var forecastingPipeline = mlContext.Forecasting.ForecastBySsa(
    outputColumnName: "forecasted_count",
    inputColumnName: "count",
    windowSize: 7,
    seriesLength: 30,
    trainSize: 334,
    horizon: 7,
    confidenceLevel: 0.95f,
    confidenceLowerBoundColumn: "lower_count",
    confidenceUpperBoundColumn: "upper_count");

前面有說過，我們採用單譜分析，所以代碼中我們選擇了mlContext.Forecasting.ForecastBySsa。

解釋一下這裏面的幾個參數：

• trainSize – 數據樣本的數量，也就是訓練數據的行數（在這個文件中，一行是一個數據樣本，共334行）
• seriesLength – 從數據樣本按時序採樣時的間隔，這裡是30天
• windowSize – 樣本周期的天數，這裡是7天
• horizon – 預測結果的天數
• confidenceLevel – 上下限的可信度。預測屬於合理猜測，不總是完全準確。
• 其它幾個參數，對應輸入輸出模型的字段名

1. 訓練模型

管道定義完成，數據加載完成，下面要進行數據訓練。

SsaForecastingTransformer forecaster = forecastingPipeline.Fit(data1View);

跟隨上一節，管道是單譜管道，所以訓練也是單譜訓練SsaForecastingTransformer。

程序執行到這裏，數據訓練完成。

1. 模型評估

模型評估不是必須環節。

模型評估的意義在於：通過評估模型的性能，來調整管道的參數，以達到最佳的預測效果。

模型評估也有多種方式。在這裏，我們採用平均絕對誤差和均方根誤差來做評估依據。

static void Evaluate(IDataView testData, ITransformer model, MLContext mlContext)
{
    IDataView predictions = model.Transform(testData);

    IEnumerable<float> actual =
        mlContext.Data.CreateEnumerable<ModelInput>(testData, true)
            .Select(p => p.count);

    IEnumerable<float> forecast =
        mlContext.Data.CreateEnumerable<ModelOutput>(predictions, true)
            .Select(p => p.forecasted_count[0]);

    var metrics = actual.Zip(forecast, (actualValue, forecastValue) => actualValue - forecastValue);

    var MAE = metrics.Average(error => Math.Abs(error));
    var RMSE = Math.Sqrt(metrics.Average(error => Math.Pow(error, 2)));

    Console.WriteLine("評估結果");
    Console.WriteLine("---------------------");
    Console.WriteLine($"平均絕對誤差: {MAE:F3}");
    Console.WriteLine($"均方根誤差: {RMSE:F3}\n");
}

在這個方法中，我們取評估數據的實際值actual和通過訓練數據生成的預測值forecast，計算兩個誤差並輸出。

在Main中調用此方法：

static void Main(string[] args)
{
        /* 這兒是前邊訓練的代碼，略過 */

        Evaluate(data2View, forecaster, mlContext);
}
static void Evaluate(IDataView testData, ITransformer model, MLContext mlContext)
{
      /* 這兒是評估模型的方法，上面有，略過 */
}

輸出結果類似於以下內容：

評估結果
---------------------
平均絕對誤差: 23.442
均方根誤差: 174.236

兩個指標：

• 平均絕對誤差 – 度量預測與實際值之間的接近程度。 此值介於 0 到無限大之間。 越接近 0，模型的質量越好。
• 均方根誤差 – 匯總模型中的錯誤。 此值介於 0 到無限大之間。 越接近 0，模型的質量越好。

1. 預測

訓練模型調整到滿意后，即可開始預測的工作：

var forecastEngine = forecaster.CreateTimeSeriesEngine<ModelInput, ModelOutput>(mlContext);
ModelOutput forecast = forecastEngine.Predict();

這兩行代碼，在內存中加載前邊訓練好的模型，並進行預測操作。預測數據的結果放在forecast中。

對應於分析管道定義中的horizon，預測數據包含7天的預測結果。

1. 預測結果輸出

放在forecast中的數據，對應模型ModelOutput，可以用在任何地方。

在本文中，我們直接显示到Console：

IEnumerable<string> forecastOutput =
    mlContext.Data.CreateEnumerable<ModelInput>(data2View, reuseRowObject: false)
        .Take(7)
        .Select((ModelInput data, int index) =>
        {
            string action_date = data.action_time.ToString("yyyy-MM-dd");
            float actual_count = data.count;
            float lowerEstimate = Math.Max(0, forecast.lower_count[index]);
            float estimate = forecast.forecasted_count[index];
            float upperEstimate = forecast.upper_count[index];
            return $"日期: {action_date}\n" +
            $"實際值: {actual_count}\n" +
            $"預測下限估值: {lowerEstimate}\n" +
            $"預測估值: {estimate}\n" +
            $"預測上限估值: {upperEstimate}\n";
        });

Console.WriteLine("預測結果");
Console.WriteLine("---------------------");
foreach (var prediction in forecastOutput)
{
    Console.WriteLine(prediction);
}

運行結果類似於以下內容：

預測結果
---------------------
日期: 2018-12-01
實際值: 24566.08
預測下限估值: 16791.379
預測估值: 20394.115
預測上限估值: 23996.852

完成！

六、延伸內容

ML.net包含了很多機器學習的內容。其中，我自己認為時序預測是用途很廣的一個部分，可以用在

• 銷售預測
• 庫存預警
• 活動策劃輔助

以及其它諸如天氣、股票、人口等諸多內容上，依靠過去和現在的數據，分析兩者之間的關係，然後利用得到的這個關係去預測未來的數據。

因此，在這個分類中，我的第一篇文章就寫了時序預測。

機器學習，核心是各種算法，而算法的基礎是一類數學。這是一個很高的坎。刷算法，線性的部分還好，一旦到了冪次或矩陣，沒有正統的學習，是很難有突破的。而即便刷通了，也只是皮毛性的理解，距離創造算法的大神，還有很長的距離。

所以，退而求其次，對很多人而言，與其花大功夫去研究算法，不如多研究下如何能把現有的算法或工具用好。

還有，在應用中，你能用機器學習來預測銷量、預測庫存，有沒有很自豪？是不是很高大上？

（全文完）

本文的對應代碼，在https://github.com/humornif/Demo-Code/tree/master/0013/demo

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※教你寫出一流的銷售文案?

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

※超省錢租車方案

※產品缺大量曝光嗎?你需要的是一流包裝設計!