開始你的api：NetApiStarter

来源:https://www.cnblogs.com/loogn/archive/2019/11/30/11962767.html
-Advertisement-
Play Games

一個簡單的api模板項目，基於.netcore 3.0，其中包含swagger文檔，jwt許可權驗證，模型驗證，ioc，appEvent，分塊上傳等等現成的功能，幫你快速開始api的構建 ...


在此之前，寫過一篇 給新手的WebAPI實踐 ，獲得了很多新人的認可，那時還是基於.net mvc，文檔生成還是自己鬧洞大開寫出來的，經過這兩年的時間，netcore的發展已經勢不可擋，自己也在不斷的學習，公司的項目也轉向了netcore。大部分也都是前後分離的架構，後端api開發居多，從中整理了一些東西在這裡分享給大家。

源碼地址：https://gitee.com/loogn/NetApiStarter，這是一個基於netcore mvc 3.0的模板項目，如果你使用的netcore 2.x，除了引用不通用外，代碼基本是可以復用的。下麵介紹一下其中的功能。

登錄驗證

這裡我預設使用了jwt登錄驗證，因為它足夠簡單和輕量，在netcore mvc中使用jwt驗證非常簡單，首先在startup.cs文件中配置服務並啟用：
ConfigureServices方法中：

            var jwtSection = Configuration.GetSection("Jwt");
            services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
                .AddJwtBearer(options =>
                {
                    options.TokenValidationParameters = new TokenValidationParameters
                    {
                        ValidateIssuer = true,
                        ValidateAudience = true,
                        ValidateLifetime = true,
                        ValidateIssuerSigningKey = true,
                        ValidAudience = jwtSection["Audience"],
                        ValidIssuer = jwtSection["Issuer"],
                        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtSection["SigningKey"]))
                    };
                });

Configure方法中，在UseRouting和UseEndpoints方法之前：

app.UseAuthorization();

上面我們使用到了jwt配置塊，對應appsettings.json文件中有這樣的配置：

{
  "Jwt": {
    "SigningKey": "1234567812345678",
    "Issuer": "NetApiStarter",
    "Audience": "NetApiStarter"
  }
}

我們再操作兩步來實現登錄驗證，
一、提供一個介面生成jwt，
二、在客戶端請求頭部加上Authorization: Bearer {jwt}
我先封裝了一個生成jwt的方法

    public static class JwtHelper
    {
        public static string WriteToken(Dictionary<string, string> claimDict, DateTime exp)
        {
            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(AppSettings.Instance.Jwt.SigningKey));
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
            var token = new JwtSecurityToken(
                issuer: AppSettings.Instance.Jwt.Issuer,
                audience: AppSettings.Instance.Jwt.Audience,
                claims: claimDict.Select(x => new Claim(x.Key, x.Value)),
                expires: exp,
                signingCredentials: creds);
            var jwt = new JwtSecurityTokenHandler().WriteToken(token);
            return jwt;
        }
}

然後在登錄服務中調用

        /// <summary>
        /// 登錄，獲取jwt
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public ResultObject<LoginResponse> Login(LoginRequest request)
        {
            var user = userDao.GetUser(request.Account, request.Password);
            if (user == null)
            {
                return new ResultObject<LoginResponse>("用戶名或密碼錯誤");
            }
            var dict = new Dictionary<string, string>();
            dict.Add("userid", user.Id.ToString());
            var jwt = JwtHelper.WriteToken(dict, DateTime.Now.AddDays(7));
            var response = new LoginResponse { Jwt = jwt };
            return new ResultObject<LoginResponse>(response);
        }

在Controller和Action上添加[Authorize]和[AllowAnonymous]兩個特性就可以實現登錄驗證了。

請求響應

這裡請求響應的設計依然沒有使用restful風格，一是感覺太麻煩，二是真的不太懂(實事求是)，所以請求還是以POST方式投遞JSON數據，響應當然也是JSON數據這個沒啥異議的。
為啥使用POST+JSON呢，主要是簡單，大家都懂，而且規則統一、繁簡皆宜，比如什麼參數都不需要，就傳{}，根據ID查詢文章{articleId:23}，或者複雜的查詢條件和表單提交{ name:'abc', addr:{provice:'HeNan', city:'ZhengZhou'},tags:['騎馬','射箭'] } 等等都可以優雅的傳遞。
這隻是我個人的風格，netcore mvc是支持其他的方式的，選自己喜歡的就行了。
下麵的內容還是按照POST+JSON來說。

首先提供請求基類：

    /// <summary>
    /// 登錄用戶請求的基類
    /// </summary>
    public class LoginedRequest
    {
        #region jwt相關用戶
        private ClaimsPrincipal _claimsPrincipal { get; set; }

        public ClaimsPrincipal GetPrincipal()
        {
            return _claimsPrincipal;
        }
        public void SetPrincipal(ClaimsPrincipal user)
        {
            _claimsPrincipal = user;
        }

        public string GetClaimValue(string name)
        {
            return _claimsPrincipal?.FindFirst(name)?.Value;
        }
        #endregion

        #region 資料庫相關用戶 （如果有必要的話）
        //不用屬性是因為swagger中會顯示出來
        private User _user;
        public User GetUser()
        {
            return _user;
        }
        public void SetUser(User user)
        {
            _user = user;
        }
        #endregion
    }

這個類中說白了就是兩個手寫屬性，一個ClaimsPrincipal用來保存從jwt解析出來的用戶，一個User用來保存資料庫中完整的用戶信息，為啥不直接使用屬性呢，上面註釋也提到了，不想在api文檔中顯示出來。這個用戶信息是在服務層使用的，而且User不是必須的，比如jwt中的信息夠服務層使用，不定義User也是可以的，總之這裡的信息是為服務層邏輯服務的。
我們還可以定義其他的基類，比如經常用的分頁基類：

    public class PagedRequest : LoginedRequest
    {
        public int PageIndex { get; set; }
        public int PageSize { get; set; }
    }

根據項目的實際情況還可以定義更多的基類來方便開發。

響應類使用統一的格式，這裡直接提供json方便查看：

{
  "result": {
    "jwt": "string"
  },
  "success": true,
  "code": 0,
  "msg": "錯誤信息"
}

result是具體的響應對象，如果success為false的話，result一般是null。

ActionFilter

mvc本身是一個擴展性極強的框架，層層有攔截，ActionFilter就是其中之一，IActionFilter介面有兩個方法，一個是OnActionExecuted，一個是OnActionExecuting，從命名也能看出，就是在Action的前後分別執行的方法。我們這裡主要重寫OnActionExecuting方法來做兩件事：
一、將登陸信息賦值給請求對象
二、驗證請求對象
這裡說的請求對象，其類型就是LoginedRequest或者LoginedRequest的子類，看代碼：

    [AppService]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public class MyActionFilterAttribute : ActionFilterAttribute
    {
        /// <summary>
        /// 是否驗證參數有效性
        /// </summary>
        public bool ValidParams { get; set; } = true;

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            //由於Filters是套娃模式，使用以下邏輯保證作用域的覆蓋 Action > Controller > Global
            if (context.Filters.OfType<MyActionFilterAttribute>().Last() != this)
            {
                return;
            }

            //預設只有一個參數
            var firstParam = context.ActionArguments.FirstOrDefault().Value;
            if (firstParam != null && firstParam.GetType().IsClass)
            {
                //驗證參數合法性
                if (ValidParams)
                {
                    var validationResults = new List<ValidationResult>();
                    var validationFlag = Validator.TryValidateObject(firstParam, new ValidationContext(firstParam), validationResults, false);
                    if (!validationFlag)
                    {
                        var ro = new ResultObject(validationResults.First().ErrorMessage);
                        context.Result = new JsonResult(ro);
                        return;
                    }
                }
            }

            var requestParams = firstParam as LoginedRequest;
            if (requestParams != null)
            {
                //設置jwt用戶
                requestParams.SetPrincipal(context.HttpContext.User);
                var userid = requestParams.GetClaimValue("userid");
                //如果有必要，可以每次都獲取資料庫中的用戶
                if (!string.IsNullOrEmpty(userid))
                {
                    var user = ((UserService)context.HttpContext.RequestServices.GetService(typeof(UserService))).SingleById(long.Parse(userid));
                    requestParams.SetUser(user);
                }
            }

            base.OnActionExecuting(context);
        }
    }

模型驗證這塊使用的是系統自帶的，從上面代碼也可以看出，如果請求對象定義為LoginedRequest及其子類，每次請求會填充ClaimsPrincipal，如果有必要，可以從資料庫中讀取User信息填充。
請求經過ActionFilter時，模型驗證不通過的，直接返回了驗證錯誤信息，通過之後到達Action和Service時，用戶信息已經可以直接使用了。

api文檔和日誌

api文檔首選swagger了，aspnetcore 官方文檔也是使用的這個，我這裡用的是Swashbuckle，首先安裝引用

Install-Package Swashbuckle.AspNetCore -Version 5.0.0-rc4
定義一個擴展類，方便把swagger註入容器中：

public static class SwaggerServiceExtensions
    {
        public static IServiceCollection AddSwagger(this IServiceCollection services)
        {
            //https://github.com/domaindrivendev/Swashbuckle.AspNetCore
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo
                {
                    Title = "My Api",
                    Version = "v1"
                });
                c.IgnoreObsoleteActions();
                c.IgnoreObsoleteProperties();
                c.DocumentFilter<SwaggerDocumentFilter>();
                //自定義類型映射
                c.MapType<byte>(() => new OpenApiSchema { Type = "byte", Example = new OpenApiByte(0) });
                c.MapType<long>(() => new OpenApiSchema { Type = "long", Example = new OpenApiLong(0L) });
                c.MapType<int>(() => new OpenApiSchema { Type = "integer", Example = new OpenApiInteger(0) });
                c.MapType<DateTime>(() => new OpenApiSchema { Type = "DateTime", Example = new OpenApiDateTime(DateTimeOffset.Now) });

                //xml註釋
                foreach (var file in Directory.GetFiles(AppContext.BaseDirectory, "*.xml"))
                {
                    c.IncludeXmlComments(file);
                }

                //Authorization的設置
                c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
                {
                    In = ParameterLocation.Header,
                    Description = "請輸入驗證的jwt。示例：Bearer {jwt}",
                    Name = "Authorization",

                    Type = SecuritySchemeType.ApiKey,
                });
            });
            return services;
        }

        /// <summary>
        /// Swagger控制器描述文字
        /// </summary>
        class SwaggerDocumentFilter : IDocumentFilter
        {
            public void Apply(OpenApiDocument swaggerDoc, DocumentFilterContext context)
            {
                swaggerDoc.Tags = new List<OpenApiTag>
                {
                    new OpenApiTag{ Name="User", Description="用戶相關"},
                    new OpenApiTag{ Name="Common", Description="公共功能"},
                };
            }
        }
    }

主要是驗證部分，加上去之後就可以在文檔中使用jwt測試了
然後在startup.cs的ConfigureServices方法中
services.AddSwagger();
Configure方法中：

            if (env.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI(options =>
                {
                    options.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
                    options.DocExpansion(DocExpansion.None);
                });
            }

這裡限制了只有在開發環境才顯示api文檔，如果是需要外部調用的話，可以不做這個限制。

日誌組件使用Serilog。
首先也是安裝引用
Install-Package Serilog
Install-Package Serilog.AspNetCore
Install-Package Serilog.Settings.Configuration
Install-Package Serilog.Sinks.RollingFile

然後在appsettings.json中添加配置

{
  "Serilog": {
    "WriteTo": [
      { "Name": "Console" },
      {
        "Name": "RollingFile",
        "Args": { "pathFormat": "logs/{Date}.log" }
      }
    ],
    "Enrich": [ "FromLogContext" ],
    "MinimumLevel": {
      "Default": "Debug",
      "Override": {
        "Microsoft": "Warning",
        "System": "Warning"
      }
    }
  },
}

更多配置請查看https://github.com/serilog/serilog-settings-configuration

上述配置會在應用程式根目錄的logs文件夾下，每天生成一個命名類似20191129.log的日誌文件

最後要修改一下Program.cs，代替預設的日誌組件

public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseConfiguration(new ConfigurationBuilder().SetBasePath(Environment.CurrentDirectory).AddJsonFile("appsettings.json").Build());

                    webBuilder.UseStartup<Startup>();

                    webBuilder.UseSerilog((whbContext, configureLogger) =>
                    {
configureLogger.ReadFrom.Configuration(whbContext.Configuration);
                    });
                });

文件分塊上傳

文件上傳就像登錄驗證一樣常用，哪個應用還不上傳個頭像啥的，所以我也打算整合到模板項目中，如果是單純的上傳也就沒必要說了，這裡主要說的是一種大文件上傳的解決方法： 分塊上傳。

分塊上傳是需要客戶端配合的，客戶端把一個大文件分好塊，一小塊一小塊的上傳，上傳完成之後服務端按照順序合併到一起就是整個文件了。

所以我們先定義分塊上傳的參數：

string identifier : 文件標識，一個文件的唯一標識，
int chunkNumber ：當前塊所以，我是從1開始的
int chunkSize ：每塊大小，客戶端設置的固定值，單位為byte，一般2M左右就可以了
long totalSize：文件總大小，單位為byte
int totalChunks：總塊數

這些參數都好理解，在服務端驗證和合併文件時需要。

開始的時候我是這樣處理的，客戶端每上傳一塊，我會把這塊的內容寫到一個臨時文件中，使用identifier和chunkNumber來命名，這樣就知道是哪個文件的哪一塊了，當上傳完最後一塊之後，也就是chunkNumber==totalChunks的時候，我將所有的分塊小文件合併到目標文件，然後返回url。

這個邏輯是沒什麼問題，只需要一個機制保證合併文件的時候所有塊都已上傳就可以了，為什麼要這樣一個機制呢，主要是因為客戶端的上傳可能是多線程的，而且也不能完全保證http的響應順序和請求順序是一樣的，所以雖然上傳完最後一塊才會合併，但是還是需要一個機制判斷一下是否所有塊都上傳完畢，沒有上傳完還要等待一下（想一想怎麼實現！）。

後來在實際上傳過程中發現最後一塊響應會比較慢，特別是文件很大的時候，這個也好理解，因為最後一塊上傳會合併文件，所以需要優化一下。

這裡就使用到了隊列的概念了，我們可以把每次上傳的內容都放在隊列中，然後使用另一個線程從隊列中讀取並寫入目標文件。在這個場景中BlockingCollection是最合適不過的了。
我們定義一個實體類，用於保存入列的數據：

    public class UploadChunkItem
    {
        public byte[] Data { get; set; }
        public int ChunkNumber { get; set; }
        public int ChunkSize { get; set; }
        public string FilePath { get; set; }
    }

然後定義一個隊列寫入器

public class UploadChunkWriter
    {
        public static UploadChunkWriter Instance = new UploadChunkWriter();
        private BlockingCollection<UploadChunkItem> _queue;
        private int _writeWorkerCount = 3;
        private Thread _writeThread;
        public UploadChunkWriter()
        {
            _queue = new BlockingCollection<UploadChunkItem>(500);
            _writeThread = new Thread(this.Write);
        }

        public void Write()
        {
            while (true)
            {
                //單線程寫入
                //var item = _queue.Take();
                //using (var fileStream = File.Open(item.FilePath, FileMode.Open, FileAccess.Write, FileShare.ReadWrite))
                //{
                //    fileStream.Position = (item.ChunkNumber - 1) * item.ChunkSize;
                //    fileStream.Write(item.Data, 0, item.Data.Length);
                //    item.Data = null;
                //}

                //多線程寫入
                Task[] tasks = new Task[_writeWorkerCount];
                for (int i = 0; i < _writeWorkerCount; i++)
                {
                    var item = _queue.Take();
                    tasks[i] = Task.Run(() =>
                     {
                         using (var fileStream = File.Open(item.FilePath, FileMode.Open, FileAccess.Write, FileShare.ReadWrite))
                         {
                             fileStream.Position = (item.ChunkNumber - 1) * item.ChunkSize;
                             fileStream.Write(item.Data, 0, item.Data.Length);
                             item.Data = null;
                         }
                     });
                }
                Task.WaitAll(tasks);
            }
        }

        public void Add(UploadChunkItem item)
        {
            _queue.Add(item);
        }

        public void Start()
        {
            _writeThread.Start();
        }
    }

主要是Write方法的邏輯，調用_queue.Take()方法從隊列中獲取一項，如果隊列中沒有數據，這個方法會堵塞當前線程，這也是我們所期望的，獲取到數據之後，打開目標文件（在上傳第一塊的時候會創建），根據ChunkNumber 和ChunkSize找到開始寫入的位置，然後把本塊數據寫入。
打開目標文件的時候使用了FileShare.ReadWrite，表示這個文件可以同時被多個線程讀取和寫入。

文件上傳方法也簡單：

        /// <summary>
        /// 分片上傳
        /// </summary>
        /// <param name="formFile"></param>
        /// <param name="chunkNumber"></param>
        /// <param name="chunkSize"></param>
        /// <param name="totalSize"></param>
        /// <param name="identifier"></param>
        /// <param name="totalChunks"></param>
        /// <returns></returns>
        public ResultObject<UploadFileResponse> ChunkUploadfile(IFormFile formFile, int chunkNumber, int chunkSize, long totalSize,
            string identifier, int totalChunks)
        {
            var appSetting = AppSettings.Instance;
            #region 驗證
            if (formFile == null && formFile.Length == 0)
            {
                return new ResultObject<UploadFileResponse>("文件不能為空");
            }
            if (formFile.Length > appSetting.Upload.LimitSize)
            {
                return new ResultObject<UploadFileResponse>("文件超過了最大限制");
            }
            var ext = Path.GetExtension(formFile.FileName).ToLower();
            if (!appSetting.Upload.AllowExts.Contains(ext))
            {
                return new ResultObject<UploadFileResponse>("文件類型不允許");
            }
            if (chunkNumber == 0 || chunkSize == 0 || totalSize == 0 || identifier.Length == 0 || totalChunks == 0)
            {
                return new ResultObject<UploadFileResponse>("參數錯誤0");
            }
            if (chunkNumber > totalChunks)
            {
                return new ResultObject<UploadFileResponse>("參數錯誤1");
            }
            if (totalSize > appSetting.Upload.TotalLimitSize)
            {
                return new ResultObject<UploadFileResponse>("參數錯誤2");
            }
            if (chunkNumber < totalChunks && formFile.Length != chunkSize)
            {
                return new ResultObject<UploadFileResponse>("參數錯誤3");
            }
            if (totalChunks == 1 && formFile.Length != totalSize)
            {
                return new ResultObject<UploadFileResponse>("參數錯誤4");
            }
            #endregion

            //寫入邏輯
            var now = DateTime.Now;
            var yy = now.ToString("yyyy");
            var mm = now.ToString("MM");
            var dd = now.ToString("dd");

            var fileName = EncryptHelper.MD5Encrypt(identifier) + ext;
            var folder = Path.Combine(appSetting.Upload.UploadPath, yy, mm, dd);
            var filePath = Path.Combine(folder, fileName);

            //線程安全的創建文件
            if (!File.Exists(filePath))
            {
                lock (lockObj)
                {
                    if (!File.Exists(filePath))
                    {
                        if (!Directory.Exists(folder))
                        {
                            Directory.CreateDirectory(folder);
                        }
                        File.Create(filePath).Dispose();
                    }
                }
            }

            var data = new byte[formFile.Length];
            formFile.OpenReadStream().Read(data, 0, data.Length);

            UploadChunkWriter.Instance.Add(new UploadChunkItem
            {
                ChunkNumber = chunkNumber,
                ChunkSize = chunkSize,
                Data = data,
                FilePath = filePath
            });
            if (chunkNumber == totalChunks)
            {
                //等等寫入完成
                int i = 0;
                while (true)
                {
                    if (i >= 20)
                    {
                        return new ResultObject<UploadFileResponse>
                        {
                            Success = false,
                            Msg = $"上傳失敗，總大小：{totalSize},實際大小：{new FileInfo(filePath).Length}",
                            Result = new UploadFileResponse { Url = "" }
                        };
                    }
                    if (new FileInfo(filePath).Length != totalSize)
                    {
                        Thread.Sleep(TimeSpan.FromMilliseconds(1000));
                        i++;
                    }
                    else
                    {
                        break;
                    }
                }
                var fileUrl = $"{appSetting.RootUrl}{appSetting.Upload.RequestPath}/{yy}/{mm}/{dd}/{fileName}";
                var response = new UploadFileResponse { Url = fileUrl };
                return new ResultObject<UploadFileResponse>(response);
            }
            else
            {
                return new ResultObject<UploadFileResponse>
                {
                    Success = true,
                    Msg = "uploading...",
                    Result = new UploadFileResponse { Url = "" }
                };
            }
        }

撇開上面的參數驗證，主要邏輯也就是三個，一是創建目標文件，二是分塊數據加入隊列，三是最後一塊的時候要驗證文件的完整性（也就是所有的塊都上傳了，並都寫入到了目標文件）

創建目標文件需要保證線程安全，這裡使用了雙重檢查加鎖機制，雙重檢查的優點是避免了不必要的加鎖情況。

完整性我只是驗證了文件的大小，這隻是一種簡單的機制，一般是夠用了，別忘了我們的介面都是受jwt保護的，包括這裡的上傳文件。如果要求更高的話，可以讓客戶端傳參整個文件的md5值，然後服務端驗證合併之後文件的md5是否和客戶端給的一致。

最後要開啟寫入線程，可以在Startup.cs的Configure方法中開啟：

UploadChunkWriter.Instance.Start();

經過這樣的整改，上傳速度溜溜的，最後一塊也不用長時間等待啦！

（項目中當然也包含了不分塊上傳）

其他功能

自從netcore提供了依賴註入，我也習慣了這種寫法，不過在構造函數中寫一堆註入實在是難看，而且既要聲明欄位接收，又要寫參數賦值，挺麻煩的，於是乎自己寫了個小組件，已經用於手頭所有的項目，當然也包含在了NetApiStarter中，不僅解決了屬性和欄位註入，同時也解決了實現多介面註入的問題，以及一個介面多個實現精準註入的問題，詳細說明可查看項目文檔Autowired.Core。

如果你聽過MediatR，那麼這個功能不需要介紹了，項目中包含一個應用程式級別的事件發佈和訂閱的功能，具體使用可查看文檔AppEventService。

如果你聽過AutoMapper，那麼這個功能也不需要介紹了，項目中包含一個SimpleMapper，代碼不多功能還行，支持嵌套類、數組、IList<>、IDictionary<,>實體映射在多層數據傳輸的時候可謂是必不可少的功能，用法嘛就不說了，只有一個Map方法太簡單了

重中之重

如果你感覺這個項目對你、或者其他人（You or others，沒毛病）有稍許幫助，請給個Star好嗎！

NetApiStarter倉庫地址：https://gitee.com/loogn/NetApiStarter


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

-Advertisement-
Play Games
更多相關文章
  • ArrayList實現原理（JDK1.8）
    ArrayList實現原理（JDK1.8） ArrayList 繼承於AbstractList，實現了List介面，其實AbstractList 已經實現過List介面，這裡重覆實現使得介面功能更加清晰，JDK中很多類都是如此。 其中Cloneable介面是克隆標記介面，Serializable序列 ...
  • Python—常見的幾種鑒權方式
    https://blog.csdn.net/wang839305939/article/details/78713124/ ...
  • Python常用操作
    1.當前日期格式化： time.strftime('%Y-%m-%d',time.localtime(time.time())) 例子：輸出當前日期： import timeprint(time.strftime('%Y-%m-%d',time.localtime(time.time()))) 2. ...
  • C# WinForm界面美化--使用IrisSkin實現換膚功能
    WinForm界面使用IrisSkin，可以說做到了一鍵美化，當然美化的效果仁者見仁智者見智，可以挑選自己喜歡的。 1、IrisSkin下載地址：http://www.pc6.com/softview/SoftView_70918.html#download 2、將下載的文件放到Debug下麵。 3 ...
  • MFC程式出現uafxcwd.lib(afxmem.obj) : error LNK2005: "void * __cdecl operator new(unsigned int)解決辦法
    在同一個地方摔倒兩次之後，決定記錄下來這個東西。 問題 在同一個地方摔倒兩次之後，決定記錄下來這個東西。 問題 1>uafxcwd.lib(afxmem.obj) : error LNK2005: "void * __cdecl operator new(unsigned int)" (??2@YA ...
  • 使用牛頓迭代法求方程的根
    第二篇隨筆 9102年11月底,工科男曹**要算一個方程f(x)=0的根,其中f(x)表達式為: 因為實數範圍內f(x)=0的根太多,所以本文只研究-2<x<2的情況.這個式子長的太醜了,曹**看著覺得不爽,導之,得一f'(x) 這個式子更醜,但是,我們有牛頓迭代法,可以構造迭代序列{xn}滿足: ...
  • Aso.Net Core 的配置系統Configuration
    [TOC] Aso.Net Core 的配置系統Configuration ​ 1.以前的配置文件格式為XML ​ 2.新版的配置文件格式支持 { json ,xml, ini, memory, command, env..... } 01.Json文件的弱類型方式讀取 1. Json文件 【Mic ...
  • C#面向對象--命名空間
    一、在C#中，使用命名空間（Namespace）可以幫助控制自定義類型的作用範圍，同時對大量的類型進行組織；使用namespace關鍵字聲明命名空間，命名空間可以嵌套使用： namespace MyNameSpace { namespace MyNestedNameSpace { class MyC ...
一周排行
    -Advertisement-
    Play Games
  • C#TMS系統學習（BaseCity頁面）
    C#TMS系統代碼-基礎頁面BaseCity學習 本人純新手，剛進公司跟領導報道，我說我是java全棧，他問我會不會C#，我說大學學過，他說這個TMS系統就給你來管了。外包已經把代碼給我了，這幾天先把增刪改查的代碼背一下，說不定後面就要趕鴨子上架了 Service頁面 //using => impo ...
  • C# - 委托與事件
    委托與事件 委托 委托的定義 委托是C#中的一種類型，用於存儲對方法的引用。它允許將方法作為參數傳遞給其他方法，實現回調、事件處理和動態調用等功能。通俗來講，就是委托包含方法的記憶體地址，方法匹配與委托相同的簽名，因此通過使用正確的參數類型來調用方法。 委托的特性 引用方法：委托允許存儲對方法的引用， ...
  • 解析 ABP vNext 依賴註入實現【屬性註入】的原理
    前言 這幾天閑來沒事看看ABP vNext的文檔和源碼，關於關於依賴註入(屬性註入)這塊兒產生了興趣。 我們都知道。Volo.ABP 依賴註入容器使用了第三方組件Autofac實現的。有三種註入方式，構造函數註入和方法註入和屬性註入。 ABP的屬性註入原則參考如下： 這時候我就開始疑惑了，因為我知道 ...
  • C#TMS系統學習（ShippingNotice頁面）
    C#TMS系統代碼-業務頁面ShippingNotice學習 學一個業務頁面，ok，領導開完會就被裁掉了，很突然啊，他收拾東西的時候我還以為他要旅游提前請假了，還在尋思為什麼回家連自己買的幾箱飲料都要叫跑腿帶走，怕被偷嗎？還好我在他開會之前拿了兩瓶芬達 感覺感覺前面的BaseCity差不太多，這邊的 ...
  • C#動態查詢：巧用Expression組合多條件表達式
    概述：在C#中，通過`Expression`類、`AndAlso`和`OrElse`方法可組合兩個`Expression<Func<T, bool>>`，實現多條件動態查詢。通過創建表達式樹，可輕鬆構建複雜的查詢條件。 在C#中，可以使用AndAlso和OrElse方法組合兩個Expression< ...
  • 在Biwen.QuickApi中整合一個極簡的發佈訂閱(事件匯流排)
    閑來無聊在我的Biwen.QuickApi中實現一下極簡的事件匯流排,其實代碼還是蠻簡單的,對於初學者可能有些幫助 就貼出來,有什麼不足的地方也歡迎板磚交流~ 首先定義一個事件約定的空介面 public interface IEvent{} 然後定義事件訂閱者介面 public interface I ...
  • WPF 穩定的全屏化視窗方法
    1. 案例 成某三甲醫預約系統， 該項目在2024年初進行上線測試，在正常運行了兩天後，業務系統報錯：The connection pool has been exhausted, either raise MaxPoolSize (currently 800) or Timeout (curren ...
  • 在 WPF 中集成 ASP.NET Core 和 WebView2 用於集成 SPA 應用
    背景 我們有些工具在 Web 版中已經有了很好的實踐，而在 WPF 中重新開發也是一種費時費力的操作，那麼直接集成則是最省事省力的方法了。 思路解釋 為什麼要使用 WPF？莫問為什麼，老 C# 開發的堅持，另外因為 Windows 上已經裝了 Webview2/edge 整體打包比 electron ...
  • C#事件
    EDP是一套集組織架構，許可權框架【功能許可權，操作許可權，數據訪問許可權，WebApi許可權】，自動化日誌，動態Interface，WebApi管理等基礎功能於一體的，基於.net的企業應用開發框架。通過友好的編碼方式實現數據行、列許可權的管控。 ...
  • .Net8.0 Blazor Hybird 桌面端 (WPF/Winform) 發佈到 Win7+
    .Net8.0 Blazor Hybird 桌面端 (WPF/Winform) 實測可以完整運行在 win7sp1/win10/win11. 如果用其他工具打包,還可以運行在mac/linux下, 傳送門BlazorHybrid 發佈為無依賴包方式 安裝 WebView2Runtime 1.57 M ...
所有分類