基於 abp vNext 和 .NET Core 開發博客項目 - 使用Redis緩存數據

来源:https://www.cnblogs.com/meowv/archive/2020/05/26/12956696.html
-Advertisement-
Play Games

上一篇文章(https://www.cnblogs.com/meowv/p/12943699.html)完成了項目的全局異常處理和日誌記錄。 在日誌記錄中使用的靜態方法有人指出寫法不是很優雅，遂優化一下上一篇中日誌記錄的方法，具體操作如下： 在.ToolKits層中新建擴展方法Log4NetExte ...


上一篇文章(https://www.cnblogs.com/meowv/p/12943699.html)完成了項目的全局異常處理和日誌記錄。

在日誌記錄中使用的靜態方法有人指出寫法不是很優雅，遂優化一下上一篇中日誌記錄的方法，具體操作如下：

在.ToolKits層中新建擴展方法Log4NetExtensions.cs。

//Log4NetExtensions.cs
using log4net;
using log4net.Config;
using Microsoft.Extensions.Hosting;
using System.IO;
using System.Reflection;

namespace Meowv.Blog.ToolKits.Extensions
{
    public static class Log4NetExtensions
    {
        public static IHostBuilder UseLog4Net(this IHostBuilder hostBuilder)
        {
            var log4netRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
            XmlConfigurator.Configure(log4netRepository, new FileInfo("log4net.config"));

            return hostBuilder;
        }
    }
}

配置log4net，然後我們直接返回IHostBuilder對象，便於在Main方法中鏈式調用。

//Program.cs
using Meowv.Blog.ToolKits.Extensions;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
using System.Threading.Tasks;

namespace Meowv.Blog.HttpApi.Hosting
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            await Host.CreateDefaultBuilder(args)
                      .UseLog4Net()
                      .ConfigureWebHostDefaults(builder =>
                      {
                          builder.UseIISIntegration()
                                 .UseStartup<Startup>();
                      }).UseAutofac().Build().RunAsync();
        }
    }
}

然後修改MeowvBlogExceptionFilter過濾器，代碼如下：

//MeowvBlogExceptionFilter.cs
using log4net;
using Microsoft.AspNetCore.Mvc.Filters;

namespace Meowv.Blog.HttpApi.Hosting.Filters
{
    public class MeowvBlogExceptionFilter : IExceptionFilter
    {
        private readonly ILog _log;

        public MeowvBlogExceptionFilter()
        {
            _log = LogManager.GetLogger(typeof(MeowvBlogExceptionFilter));
        }

        /// <summary>
        /// 異常處理
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public void OnException(ExceptionContext context)
        {
            // 錯誤日誌記錄
            _log.Error($"{context.HttpContext.Request.Path}|{context.Exception.Message}", context.Exception);
        }
    }
}

可以刪掉之前添加的LoggerHelper.cs類，運行一下，同樣可以達到預期效果。

本篇將集成Redis，使用Redis來緩存數據，使用方法參考的微軟官方文檔：https://docs.microsoft.com/zh-cn/aspnet/core/performance/caching/distributed

關於Redis的介紹這裡就不多說了，這裡有一篇快速入門的文章：Redis快速入門及使用，對於不瞭解的同學可以看看。

直入主題，先在appsettings.json配置Redis的連接字元串。

//appsettings.json
...
  "Caching": {
    "RedisConnectionString": "127.0.0.1:6379,password=123456,ConnectTimeout=15000,SyncTimeout=5000"
  }
...

對應的，在AppSettings.cs中讀取。

//AppSettings.cs
...
        /// <summary>
        /// Caching
        /// </summary>
        public static class Caching
        {
            /// <summary>
            /// RedisConnectionString
            /// </summary>
            public static string RedisConnectionString => _config["Caching:RedisConnectionString"];
        }
...

在.Application.Caching層添加包Microsoft.Extensions.Caching.StackExchangeRedis，然後在模塊類MeowvBlogApplicationCachingModule中添加配置緩存實現。

//MeowvBlogApplicationCachingModule.cs
using Meowv.Blog.Domain;
using Meowv.Blog.Domain.Configurations;
using Microsoft.Extensions.DependencyInjection;
using Volo.Abp.Caching;
using Volo.Abp.Modularity;

namespace Meowv.Blog.Application.Caching
{
    [DependsOn(
        typeof(AbpCachingModule),
        typeof(MeowvBlogDomainModule)
    )]
    public class MeowvBlogApplicationCachingModule : AbpModule
    {
        public override void ConfigureServices(ServiceConfigurationContext context)
        {
            context.Services.AddStackExchangeRedisCache(options =>
            {
                options.Configuration = AppSettings.Caching.RedisConnectionString;
                //options.InstanceName
                //options.ConfigurationOptions
            });
        }
    }
}

options.Configuration是 Redis 的連接字元串。

options.InstanceNam是 Redis 實例名稱，這裡沒填。

options.ConfigurationOptions是 Redis 的配置屬性，如果配置了這個字，將優先於 Configuration 中的配置，同時它支持更多的選項。我這裡也沒填。

緊接著我們就可以直接使用了，直接將IDistributedCache介面依賴關係註入即可。

0

可以看到預設已經實現了這麼多常用的介面，已經夠我這個小項目用的了，同時在Microsoft.Extensions.Caching.Distributed.DistributedCacheExtensions中微軟還給我們提供了很多擴展方法。

於是，我們我就想到寫一個新的擴展方法，可以同時處理獲取和添加緩存的操作，當緩存存在時，直接返回，不存在時，添加緩存。

新建MeowvBlogApplicationCachingExtensions.cs擴展方法，如下：

//MeowvBlogApplicationCachingExtensions.cs
using Meowv.Blog.ToolKits.Extensions;
using Microsoft.Extensions.Caching.Distributed;
using System;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Caching
{
    public static class MeowvBlogApplicationCachingExtensions
    {
        /// <summary>
        /// 獲取或添加緩存
        /// </summary>
        /// <typeparam name="TCacheItem"></typeparam>
        /// <param name="cache"></param>
        /// <param name="key"></param>
        /// <param name="factory"></param>
        /// <param name="minutes"></param>
        /// <returns></returns>
        public static async Task<TCacheItem> GetOrAddAsync<TCacheItem>(this IDistributedCache cache, string key, Func<Task<TCacheItem>> factory, int minutes)
        {
            TCacheItem cacheItem;

            var result = await cache.GetStringAsync(key);
            if (string.IsNullOrEmpty(result))
            {
                cacheItem = await factory.Invoke();

                var options = new DistributedCacheEntryOptions();
                if (minutes != CacheStrategy.NEVER)
                {
                    options.AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(minutes);
                }

                await cache.SetStringAsync(key, cacheItem.ToJson(), options);
            }
            else
            {
                cacheItem = result.FromJson<TCacheItem>();
            }

            return cacheItem;
        }
    }
}

我們可以在DistributedCacheEntryOptions中可以配置我們的緩存過期時間，其中有一個判斷條件，就是當minutes = -1的時候，不指定過期時間，那麼我們的緩存就不會過期了。

GetStringAsync()、SetStringAsync()是DistributedCacheExtensions的擴展方法，最終會將緩存項cacheItem轉換成JSON格式進行存儲。

CacheStrategy是在.Domain.Shared層定義的緩存過期時間策略常量。

//MeowvBlogConsts.cs
...
        /// <summary>
        /// 緩存過期時間策略
        /// </summary>
        public static class CacheStrategy
        {
            /// <summary>
            /// 一天過期24小時
            /// </summary>

            public const int ONE_DAY = 1440;

            /// <summary>
            /// 12小時過期
            /// </summary>

            public const int HALF_DAY = 720;

            /// <summary>
            /// 8小時過期
            /// </summary>

            public const int EIGHT_HOURS = 480;

            /// <summary>
            /// 5小時過期
            /// </summary>

            public const int FIVE_HOURS = 300;

            /// <summary>
            /// 3小時過期
            /// </summary>

            public const int THREE_HOURS = 180;

            /// <summary>
            /// 2小時過期
            /// </summary>

            public const int TWO_HOURS = 120;

            /// <summary>
            /// 1小時過期
            /// </summary>

            public const int ONE_HOURS = 60;

            /// <summary>
            /// 半小時過期
            /// </summary>

            public const int HALF_HOURS = 30;

            /// <summary>
            /// 5分鐘過期
            /// </summary>
            public const int FIVE_MINUTES = 5;

            /// <summary>
            /// 1分鐘過期
            /// </summary>
            public const int ONE_MINUTE = 1;

            /// <summary>
            /// 永不過期
            /// </summary>

            public const int NEVER = -1;
        }
...

接下來去創建緩存介面類和實現類，然後再我們的引用服務層.Application中進行調用，拿上一篇中接入GitHub的幾個介面來做新增緩存操作。

和.Application層格式一樣，在.Application.Caching中新建Authorize文件夾，添加緩存介面IAuthorizeCacheService和實現類AuthorizeCacheService。

註意命名規範，實現類肯定要繼承一個公共的CachingServiceBase基類。在.Application.Caching層根目錄添加MeowvBlogApplicationCachingServiceBase.cs，繼承ITransientDependency。

//MeowvBlogApplicationCachingServiceBase.cs
using Microsoft.Extensions.Caching.Distributed;
using Volo.Abp.DependencyInjection;

namespace Meowv.Blog.Application.Caching
{
    public class CachingServiceBase : ITransientDependency
    {
        public IDistributedCache Cache { get; set; }
    }
}

然後使用屬性註入的方式，註入IDistributedCache。這樣我們只要繼承了基類：CachingServiceBase，就可以愉快的使用緩存了。

添加要緩存的介面到IAuthorizeCacheService，在這裡我們使用Func()方法，我們的介面返回什麼類型由Func()來決定，於是添加三個介面如下：

//IAuthorizeCacheService.cs
using Meowv.Blog.ToolKits.Base;
using System;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Caching.Authorize
{
    public interface IAuthorizeCacheService
    {
        /// <summary>
        /// 獲取登錄地址(GitHub)
        /// </summary>
        /// <returns></returns>
        Task<ServiceResult<string>> GetLoginAddressAsync(Func<Task<ServiceResult<string>>> factory);

        /// <summary>
        /// 獲取AccessToken
        /// </summary>
        /// <param name="code"></param>
        /// <param name="factory"></param>
        /// <returns></returns>
        Task<ServiceResult<string>> GetAccessTokenAsync(string code, Func<Task<ServiceResult<string>>> factory);

        /// <summary>
        /// 登錄成功，生成Token
        /// </summary>
        /// <param name="access_token"></param>
        /// <param name="factory"></param>
        /// <returns></returns>
        Task<ServiceResult<string>> GenerateTokenAsync(string access_token, Func<Task<ServiceResult<string>>> factory);
    }
}

是不是和IAuthorizeService代碼很像，的確，我就是直接複製過來改的。

在AuthorizeCacheService中實現介面。

//AuthorizeCacheService.cs
using Meowv.Blog.ToolKits.Base;
using Meowv.Blog.ToolKits.Extensions;
using System;
using System.Threading.Tasks;
using static Meowv.Blog.Domain.Shared.MeowvBlogConsts;

namespace Meowv.Blog.Application.Caching.Authorize.Impl
{
    public class AuthorizeCacheService : CachingServiceBase, IAuthorizeCacheService
    {
        private const string KEY_GetLoginAddress = "Authorize:GetLoginAddress";

        private const string KEY_GetAccessToken = "Authorize:GetAccessToken-{0}";

        private const string KEY_GenerateToken = "Authorize:GenerateToken-{0}";

        /// <summary>
        /// 獲取登錄地址(GitHub)
        /// </summary>
        /// <param name="factory"></param>
        /// <returns></returns>
        public async Task<ServiceResult<string>> GetLoginAddressAsync(Func<Task<ServiceResult<string>>> factory)
        {
            return await Cache.GetOrAddAsync(KEY_GetLoginAddress, factory, CacheStrategy.NEVER);
        }

        /// <summary>
        /// 獲取AccessToken
        /// </summary>
        /// <param name="code"></param>
        /// <param name="factory"></param>
        /// <returns></returns>
        public async Task<ServiceResult<string>> GetAccessTokenAsync(string code, Func<Task<ServiceResult<string>>> factory)
        {
            return await Cache.GetOrAddAsync(KEY_GetAccessToken.FormatWith(code), factory, CacheStrategy.FIVE_MINUTES);
        }

        /// <summary>
        /// 登錄成功，生成Token
        /// </summary>
        /// <param name="access_token"></param>
        /// <param name="factory"></param>
        /// <returns></returns>
        public async Task<ServiceResult<string>> GenerateTokenAsync(string access_token, Func<Task<ServiceResult<string>>> factory)
        {
            return await Cache.GetOrAddAsync(KEY_GenerateToken.FormatWith(access_token), factory, CacheStrategy.ONE_HOURS);
        }
    }
}

代碼很簡單，每個緩存都有固定KEY值，根據參數生成KEY，然後調用前面寫的擴展方法，再給一個過期時間即可，可以看到KEY裡面包含了冒號 :，這個冒號 : 可以起到類似於文件夾的操作，在界面化管理工具中可以很友好的查看。

這樣我們的緩存就搞定了，然後在.Application層對應的Service中進行調用。代碼如下：

//AuthorizeService.cs
using Meowv.Blog.Application.Caching.Authorize;
using Meowv.Blog.Domain.Configurations;
using Meowv.Blog.ToolKits.Base;
using Meowv.Blog.ToolKits.Extensions;
using Meowv.Blog.ToolKits.GitHub;
using Microsoft.IdentityModel.Tokens;
using System;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Claims;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Authorize.Impl
{
    public class AuthorizeService : ServiceBase, IAuthorizeService
    {
        private readonly IAuthorizeCacheService _authorizeCacheService;
        private readonly IHttpClientFactory _httpClient;

        public AuthorizeService(IAuthorizeCacheService authorizeCacheService,
                                IHttpClientFactory httpClient)
        {
            _authorizeCacheService = authorizeCacheService;
            _httpClient = httpClient;
        }

        /// <summary>
        /// 獲取登錄地址(GitHub)
        /// </summary>
        /// <returns></returns>
        public async Task<ServiceResult<string>> GetLoginAddressAsync()
        {
            return await _authorizeCacheService.GetLoginAddressAsync(async () =>
            {
                var result = new ServiceResult<string>();

                var request = new AuthorizeRequest();
                var address = string.Concat(new string[]
                {
                    GitHubConfig.API_Authorize,
                    "?client_id=", request.Client_ID,
                    "&scope=", request.Scope,
                    "&state=", request.State,
                    "&redirect_uri=", request.Redirect_Uri
                });

                result.IsSuccess(address);
                return await Task.FromResult(result);
            });
        }

        /// <summary>
        /// 獲取AccessToken
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public async Task<ServiceResult<string>> GetAccessTokenAsync(string code)
        {
            var result = new ServiceResult<string>();

            if (string.IsNullOrEmpty(code))
            {
                result.IsFailed("code為空");
                return result;
            }

            return await _authorizeCacheService.GetAccessTokenAsync(code, async () =>
            {
                var request = new AccessTokenRequest();

                var content = new StringContent($"code={code}&client_id={request.Client_ID}&redirect_uri={request.Redirect_Uri}&client_secret={request.Client_Secret}");
                content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");

                using var client = _httpClient.CreateClient();
                var httpResponse = await client.PostAsync(GitHubConfig.API_AccessToken, content);

                var response = await httpResponse.Content.ReadAsStringAsync();

                if (response.StartsWith("access_token"))
                    result.IsSuccess(response.Split("=")[1].Split("&").First());
                else
                    result.IsFailed("code不正確");

                return result;
            });
        }

        /// <summary>
        /// 登錄成功，生成Token
        /// </summary>
        /// <param name="access_token"></param>
        /// <returns></returns>
        public async Task<ServiceResult<string>> GenerateTokenAsync(string access_token)
        {
            var result = new ServiceResult<string>();

            if (string.IsNullOrEmpty(access_token))
            {
                result.IsFailed("access_token為空");
                return result;
            }

            return await _authorizeCacheService.GenerateTokenAsync(access_token, async () =>
            {
                var url = $"{GitHubConfig.API_User}?access_token={access_token}";
                using var client = _httpClient.CreateClient();
                client.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.14 Safari/537.36 Edg/83.0.478.13");
                var httpResponse = await client.GetAsync(url);
                if (httpResponse.StatusCode != HttpStatusCode.OK)
                {
                    result.IsFailed("access_token不正確");
                    return result;
                }

                var content = await httpResponse.Content.ReadAsStringAsync();

                var user = content.FromJson<UserResponse>();
                if (user.IsNull())
                {
                    result.IsFailed("未獲取到用戶數據");
                    return result;
                }

                if (user.Id != GitHubConfig.UserId)
                {
                    result.IsFailed("當前賬號未授權");
                    return result;
                }

                var claims = new[] {
                    new Claim(ClaimTypes.Name, user.Name),
                    new Claim(ClaimTypes.Email, user.Email),
                    new Claim(JwtRegisteredClaimNames.Exp, $"{new DateTimeOffset(DateTime.Now.AddMinutes(AppSettings.JWT.Expires)).ToUnixTimeSeconds()}"),
                    new Claim(JwtRegisteredClaimNames.Nbf, $"{new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds()}")
                };

                var key = new SymmetricSecurityKey(AppSettings.JWT.SecurityKey.SerializeUtf8());
                var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

                var securityToken = new JwtSecurityToken(
                    issuer: AppSettings.JWT.Domain,
                    audience: AppSettings.JWT.Domain,
                    claims: claims,
                    expires: DateTime.Now.AddMinutes(AppSettings.JWT.Expires),
                    signingCredentials: creds);

                var token = new JwtSecurityTokenHandler().WriteToken(securityToken);

                result.IsSuccess(token);
                return await Task.FromResult(result);
            });
        }
    }
}

直接return我們的緩存介面，當查詢到Redis中存在KEY值的緩存就不會再走我們的具體的實現方法了。

註意註意，千萬不要忘了在.Application層的模塊類中添加依賴緩存模塊MeowvBlogApplicationCachingModule，不然就會報錯報錯報錯(我就是忘了添加...)

//MeowvBlogApplicationCachingModule.cs
using Meowv.Blog.Domain;
using Meowv.Blog.Domain.Configurations;
using Microsoft.Extensions.DependencyInjection;
using Volo.Abp.Caching;
using Volo.Abp.Modularity;

namespace Meowv.Blog.Application.Caching
{
    [DependsOn(
        typeof(AbpCachingModule),
        typeof(MeowvBlogDomainModule)
    )]
    public class MeowvBlogApplicationCachingModule : AbpModule
    {
        public override void ConfigureServices(ServiceConfigurationContext context)
        {
            context.Services.AddStackExchangeRedisCache(options =>
            {
                options.Configuration = AppSettings.Caching.RedisConnectionString;
            });
        }
    }
}

此時項目的層級目錄結構。

2

好的，編譯運行項目，現在去調用介面看看效果，為了真實，這裡我先將我redis緩存數據全部幹掉。

3

訪問介面，.../auth/url，成功返回數據，現在再去看看我們的redis。

4

成功將KEY為：Authorize:GetLoginAddress 添加進去了，這裡直接使用RedisDesktopManager進行查看。

5

那麼再次調用這個介面，只要沒有過期，就會直接返回數據了，調試圖如下：

6

可以看到，是可以直接取到緩存數據的，其他介面大家自己試試吧，一樣的效果。

是不是很簡單，用最少的代碼集成Redis進行數據緩存，你學會了嗎？

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • ASP.NET Core中處理中止的請求
    當用戶嚮應用程式發出請求時，伺服器將解析該請求，生成響應，然後將結果發送給客戶端。用戶可能會在伺服器處理請求的時候中止請求。就比如說用戶跳轉到另一個頁面中獲取說關閉頁面。在這種情況下，我們希望停止所有正在進行的工作，以浪費不必要的資源。例如我們可能要取消SQL請求、http調用請求、CPU密集型操作 ...
  • Dockerfile+Jenkinsfile+GitLab輕鬆實現.NetCore程式的CI&CD
    一.相關介紹 Dockerfile：關於Dockerfile的使用說明，我在文章《讓.NetCore程式跑在任何有docker的地方》中有說到，這裡不在贅述，需要的可以先看下，本文主要介紹Jenkinsfile結合dockerfile配合使用，自動構建.NetCore應用程式。 Jenkinsfil ...
  • 阿裡簡訊回執.net sdk的bug導致生產服務cpu 100%排查
    一：背景 1. 講故事 去年阿裡聚石塔上的所有isv簡訊通道全部對接阿裡通信，我們就做了對接改造，使用阿裡提供的.net sdk。 網址：https://help.aliyun.com/document_detail/114480.html 同事當時使用的是ons-.net v1.1.3版本，程式上 ...
  • C# 打開藍牙設置界面
    藍牙設置相關界面，以下是通過C#方式打開的幾個方式，記錄一下 藍牙設置界面 1.控制面板命令bthprops.cpl 可以用控制面板 control+bthprops.cpl，也可以直接bthprops.cpl。更多的命令見：所有運行命令指令大全、CMD & CPL：快捷系統命令和控制面板命令 bt ...
  • Blazor WebAssembly 候選版遷移手記
    前言 之前我寫過一篇關於 Blazor WebAssembly 的文章瀏覽器中的 .Net Core —— Blazor WebAssembly 初體驗，如今已經更新到 RC-1，與預覽版有著較大的差異，為此補充這篇文章。 正文 與預覽版的主要差異 1、這次的候選版修改了大部分包名和命名空間，因此無 ...
  • ahjesus-最新netcore圖片合併生成二維碼合成圖片圖片添加文字
    最新.net core 圖片合併生成二維碼合成圖片 圖片添加文字 先安裝幾個包 獲取地址如下 https://www.nuget.org/packages/QRCoder/ https://www.nuget.org/packages/SixLabors.Fonts/ https://www.nug ...
  • C# 數據操作系列 - 16 SqlSugar 完結篇
    0. 前言 前一篇我們詳細的介紹了SqlSugar的增刪改查，那些已經滿足我們在日常工程開發中的使用了。但是還有一點點在開發中並不常用，但是卻非常有用的方法。接下來讓我們一起來看看還有哪些有意思的內容。 1. 不同尋常的查詢 之前介紹了針對單個表的查詢，同樣也是相對簡單的查詢模式。雖然開發完全夠用， ...
  • ahjesus-最新 .net core 生成二維碼 可調整尺寸
    先安裝幾個包 獲取地址如下https://www.nuget.org/packages/QRCoder/https://www.nuget.org/packages/SixLabors.Fonts/https://www.nuget.org/packages/SixLabors.ImageSharp ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類