CRUD operations in asp.net core 6.0

Asp dot Net Core Mvc Crud Using Entity Framework DB First approach | Visual Studio 2022 with dot Net 6.0

 #aspdotnet #crud #asp #sql  #dotnetcore 

Hire .Net Core Developer To get below .Net Core Development Services!

#aspdotnet #dotnetcore #programmer #dev 

Every product owner wants to take their web applications to the next level with the smoothest User experience and high-yielding results. However, in order to achieve that one needs to hire software developers from web development companies that can give ultimate justice to your web development requirements.

In the case of .Net Core Development Technology, there are numerous .net core Development Companies that offer profound .net core development services which give excellent .Net Core apps features and quality with less amount of effort from the .Net Core developers.

So let's see what kind of benefits you are going to get while hiring a professional .Net Core Developer for your project.

1. End-to-end ASP.NET Assessment
2. .NET core migration and upgradation
3. Customized .Net Core consulting

In order to provide such services, it is advisable to double-check that your .NET Core Developer possesses certain qualities and tech excellence that will give justice to the top quality of your application.

Such qualities are as below,

1. Integration of SSR
2. Analyzing and Visualizing Data with Power BI
3. Cross-platform app implementation
4. Excellent in Version Control
5. Legacy system modernization

So these qualities for tech excellence are just the starters while there could be many others that very well serve your project with a custom-made tailored approach.

Hire .Net Core Developer that really gets your aim and requirement and serves you and your project accordingly.

10 Thư Viện NuGet Cần Thiết Cho ASP.NET Core

Trong bài viết này, chúng tôi sẽ thảo luận về 10 thư viện NuGet thiết yếu hàng đầu cho ASP.NET Core mà mọi nhà phát triển nên biết để phát triển các ứng dụng ASP.NET Core tốt hơn và cũng giảm thời gian cần thiết để phát triển các ứng dụng này.

Tổng quan

Khuôn khổ .NET Core đã phát triển rất nhanh từ .NET Core 1.0 đến .NET 6 và nhiều thư viện cũng được phát triển để giúp các nhà phát triển triển khai các chức năng phổ biến được yêu cầu trong ứng dụng. Vì vậy, điều rất quan trọng là các nhà phát triển phải hiểu những thư viện này là gì và những vấn đề được giải quyết bằng cách sử dụng các thư viện này.

10 thư viện NuGet thiết yếu này cho ASP.NET Core là mã nguồn mở và miễn phí có thể sử dụng lại được viết bởi người khác. Mục đích của các thư viện NuGet này là giúp giải quyết các vấn đề chung theo những cách dễ dàng hơn và cũng cho phép bạn cải thiện năng suất phát triển ứng dụng.

Việc sử dụng các thư viện này sẽ cho phép các nhà phát triển sử dụng mã đã được thử và kiểm tra cho hầu hết các tính năng phổ biến được yêu cầu trong ứng dụng của bạn. Điều này không chỉ hỗ trợ phát triển ứng dụng nhanh chóng mà còn cho phép các nhà phát triển chỉ tập trung vào các yêu cầu chức năng của ứng dụng.

Ưu và nhược điểm của việc sử dụng Thư viện bên thứ ba

Điều quan trọng là phải biết ưu và nhược điểm của việc sử dụng bất kỳ thư viện bên thứ ba nào trong ứng dụng của bạn để bạn có thể đưa ra quyết định sáng suốt. Dưới đây là những ưu điểm và nhược điểm của việc sử dụng thư viện của bên thứ ba trong ứng dụng của bạn

Ưu điểm

• Tiết kiệm thời gian phát triển và thử nghiệm
• Các nhà phát triển có thể tập trung vào các yêu cầu chức năng
• Mã đã thử và đã kiểm tra

Nhược điểm

• Sự phụ thuộc vào mã của bên thứ ba
• Đôi khi không có đủ hỗ trợ cho các thư viện phần thứ ba
• Có thể có vấn đề bảo mật với thư viện.

10 thư viện NuGet cần thiết cho ASP.NET Core

Dưới đây là 10 Thư viện NuGet cần thiết hàng đầu cho ASP.NET Core để cải thiện năng suất của nhà phát triển và phát triển các ứng dụng tốt hơn bằng cách sử dụng các thư viện này.

Serilog

Việc ghi nhật ký ứng dụng là rất quan trọng đối với bất kỳ ứng dụng nào vì nó cho phép bạn phân tích hành vi của ứng dụng trong môi trường sản xuất và giúp bạn xác định nguyên nhân gốc rễ trong trường hợp ngoại lệ xảy ra trong ứng dụng. Ghi nhật ký cũng có thể được sử dụng để ghi các thông số hiệu suất nhằm xác định các đoạn mã chạy chậm. Serilog có thể được sử dụng để thực hiện đăng nhập vào các ứng dụng ASP.NET Core.

Serilog là thư viện của bên thứ ba cung cấp chức năng ghi nhật ký các sự kiện ứng dụng, thông tin và ngoại lệ cho đích mong muốn như bảng điều khiển, tệp, cơ sở dữ liệu, đám mây, v.v. Serilog cũng cho phép các mục nhật ký được định dạng thành nhật ký có cấu trúc để các mục nhập đó có thể được đọc và xử lý bởi một chương trình máy tính.

Liên kết Thư viện - https://github.com/serilog/serilog

Đoan trang

Ánh xạ quan hệ đối tượng (ORM) là kỹ thuật lập trình trong đó bạn viết các truy vấn cơ sở dữ liệu (SQL) bằng ngôn ngữ ưa thích của mình và lấy đầu ra từ cơ sở dữ liệu dưới dạng các đối tượng ngôn ngữ lập trình. ORM ẩn tất cả sự phức tạp và đóng gói các truy vấn SQL thành các đối tượng. Dapper là một trong những ORM tốt nhất có thể được sử dụng trong ASP.NET Core để tương tác với cơ sở dữ liệu.

Dapper là một trình ánh xạ quan hệ đối tượng đơn giản hoặc một ORM vi mô có thể được sử dụng để ánh xạ các kết quả cơ sở dữ liệu tới các Đối tượng .NET C #. Bằng cách sử dụng Dapper trong ASP.NET Core, chúng ta có thể viết các câu lệnh SQL như thể chúng ta đang viết chúng trong studio quản lý SQL Server nhưng kết quả được ánh xạ tới đối tượng lớp .NET C # 0domain. Dapper cung cấp giao diện này với cơ sở dữ liệu với kết quả hiệu suất tốt và gần như nhanh như RAW ADO.NET. Dapper cũng hỗ trợ các truy vấn được tham số hóa có thể được sử dụng để tránh các cuộc tấn công chèn SQL vào ứng dụng ASP.NET Core.

Liên kết thư viện - https://github.com/DapperLib/Dapper

xUnit

Điều quan trọng luôn là kiểm tra ứng dụng trước khi chúng tôi triển khai sản xuất hoặc giao nó cho khách hàng để kiểm tra vì kiểm tra tốt ở phần cuối của nhà phát triển sẽ đảm bảo chất lượng tốt của ứng dụng được phân phối. Khi kích thước của mã tăng lên, nó làm tăng thêm độ phức tạp cho ứng dụng, do đó thời gian cần thiết để kiểm tra sẽ tăng lên. Vì vậy, với mục đích này, tốt hơn hết là bạn nên tự động hóa quá trình kiểm tra trong ứng dụng vì điều này sẽ giảm thời gian và công sức cần thiết để kiểm tra ứng dụng.

Có những ứng dụng trong một số tổ chức cần triển khai các thay đổi đối với quá trình sản xuất hàng giờ, vì vậy các bài kiểm tra đơn vị tự động trong các dự án này trở thành điều cần thiết để đảm bảo chất lượng tốt của mã được phân phối. XUnit.NET có thể được sử dụng để tự động kiểm tra đơn vị của ứng dụng trong ASP.NET Core

xUnit.net là một công cụ kiểm tra đơn vị miễn phí, mã nguồn mở, tập trung vào cộng đồng cho .NET Core & .NET. xUnit.Net là khung kiểm thử đơn vị mới nhất cho các dự án ASP.NET Core và trở nên phổ biến khi Microsoft bắt đầu sử dụng nó để xây dựng mã cho ASP.NET Core Framework. xUnit.net cũng có thể được sử dụng để triển khai kiểm thử đơn vị trong cả .NET Core & .NET Full framework. XUnit.net là khung thử nghiệm mới nhất triển khai một tập hợp các thuộc tính hoặc trình trang trí có thể được sử dụng trong các phương pháp thử nghiệm và sử dụng mà chúng ta có thể viết mã thử nghiệm đơn vị để tự động kiểm tra các thành phần phần mềm hoặc đơn vị của một ứng dụng trong ASP.NET Core.

Để biết thêm chi tiết về cách triển khai Unit Testing trong ASP.NET Core, bạn có thể đọc bài viết của tôi Thực hiện Unit Testing trong Ứng dụng ASP.NET Core 5 - Bắt đầu

Liên kết Thư viện - https://github.com/xunit/xunit

Moq

Như đã thảo luận ở trên các bài kiểm tra đơn vị tự động là rất quan trọng để cung cấp một sản phẩm chất lượng nhưng đôi khi việc viết các bài kiểm tra đơn vị này là một nhiệm vụ khó khăn vì các thành phần đang được kiểm tra có thể phụ thuộc vào các bộ phận khác và các bộ phận khác này có thể chưa sẵn sàng hoặc có thể khó sử dụng các bộ phận khác này phần để viết các bài kiểm tra đơn vị. Đây là nơi các đối tượng mô phỏng đến để trợ giúp, phiên bản mô phỏng của một đối tượng là thứ thực hiện giao diện giống với đối tượng thực để nó có thể hoạt động giống như một đối tượng thực nhưng hành vi của đối tượng giả trong mã kiểm tra đơn vị có thể được kiểm soát bằng cách sử dụng cấu hình hoặc thông qua mã.

Các đối tượng giả không là gì ngoài các lớp giả mạo trả về một giá trị đã biết và được cấu hình cho đầu vào được cung cấp. Moq có thể được sử dụng để triển khai các đối tượng giả này cho mục đích kiểm thử đơn vị.

Moq là khuôn khổ mô phỏng phổ biến và thân thiện nhất hiện có trên GitHub để tạo các đối tượng mô phỏng trong .NET & .NET Core. Moq hỗ trợ cấu hình các đối tượng giả như bạn có thể thiết lập các thuộc tính đối tượng, thêm các phương thức với đầu vào là các đối số cụ thể và trả về các giá trị cụ thể, v.v. Những đối tượng giả này có thể được sử dụng trong mã thử nghiệm cho các cuộc gọi đến các đối tượng giả.

Liên kết Thư viện - https://github.com/moq/moq

AutoMapper

Trong các ứng dụng của bạn, nơi bạn đang giao tiếp với cơ sở dữ liệu để lưu dữ liệu, bạn sẽ có các đối tượng khác nhau cho các mô hình chế độ xem và các thực thể cơ sở dữ liệu. Đối tượng mô hình khung nhìn được sử dụng để lấy dữ liệu từ người dùng và các thực thể cơ sở dữ liệu là một đối sánh chính xác với các bảng cơ sở dữ liệu được thiết kế để tương tác với cơ sở dữ liệu. Trong trường hợp này, bạn sẽ phải sao chép dữ liệu từ thể hiện của mô hình sang thể hiện của thực thể cơ sở dữ liệu.

Vì các đối tượng thuộc các lớp khác nhau nên bạn không thể đặt một thể hiện của một đối tượng này sang một đối tượng khác, bạn sẽ phải sử dụng cách tiếp cận truyền thống là sao chép dữ liệu từ đối tượng này sang đối tượng khác theo từng trường. Để đơn giản hóa công việc ánh xạ dữ liệu từ đối tượng này sang đối tượng khác, có thể sử dụng AutoMapper.

Automapper trong ASP.NET Core là một thư viện nhỏ và phổ biến để ánh xạ một đối tượng với đối tượng được sử dụng để ánh xạ các đối tượng thuộc các lớp khác nhau. Automapper trong ASP.NET Core là một thư viện mã nguồn mở và nó ánh xạ các thuộc tính của hai đối tượng khác nhau. Automapper có thể được sử dụng để ánh xạ các đối tượng của bất kỳ lớp nào nhưng tên của các thuộc tính trong cả hai lớp phải giống nhau. Nếu tên của các thuộc tính không giống nhau thì trong trường hợp đó, Automapper cung cấp một tùy chọn để chỉ định thủ công tập hợp tên thuộc tính nguồn và đích.

Để biết thêm chi tiết về cách triển khai Automapper trong ASP.NET Core, bạn có thể đọc bài viết của tôi Triển khai Automapper trong ASP.NET Core 3.1 - Hướng dẫn nhanh và dễ dàng

Liên kết thư viện - https://github.com/AutoMapper/AutoMapper

Newtonsoft Json.NET

Ngày nay, các ứng dụng thực hiện lệnh gọi đến Web API rất phổ biến vì nhiều lý do khác nhau như truy xuất dữ liệu, dịch vụ email, dịch vụ SMS, dịch vụ đám mây, v.v. Khi nói đến việc trao đổi dữ liệu giữa các API khác nhau, JSON là định dạng phổ biến và được ưa thích nhất. Khi bạn đang làm việc trên các ứng dụng ASP.NET Core & tương tác với API Web thì việc chuyển đổi chuỗi dữ liệu JSON sang đối tượng .NET C # và ngược lại sẽ được yêu cầu để truy cập API dựa trên JSON.

Quá trình chuyển đổi các đối tượng .NET C # thành các chuỗi định dạng JSON được gọi là tuần tự hóa và quá trình chuyển đổi các chuỗi định dạng JSON thành các đối tượng .NET C # được gọi là quá trình giải mã hóa. Newtonsoft Json.NET là một thư viện có thể được sử dụng để tuần tự hóa và giải mã hóa.

Json.NET là một khuôn khổ JSON cho .NET của Newtonsoft. Json.NET là một framework hiệu suất cao và rất phổ biến cho JSON. Json.NET hỗ trợ các tính năng như Serialization và deserialization của bất kỳ đối tượng .NET C # nào, LINQ to Json, Hỗ trợ XML, v.v. Newtonsoft Json.NET là thư viện của bên thứ ba có hiệu suất cao và dễ sử dụng. Json.NET hỗ trợ đa nền tảng như Windows, macOS, Linux, Mono & Xamarin.

Liên kết thư viện - https://github.com/JamesNK/Newtonsoft.Json

FluentValidation

Hôm nay chúng tôi đang viết các API công khai có thể được truy cập bởi bất kỳ ai trên internet và những người dùng khác nhau có thể cung cấp tất cả các loại đầu vào. Ngày nay, ai đó có ý định sai có thể hủy bỏ ứng dụng của chúng tôi nếu chúng tôi không xác thực đầu vào đúng cách. Vì vậy, xác thực dữ liệu đầu vào là rất quan trọng để bất kỳ ứng dụng nào hoạt động mà không gặp bất kỳ vấn đề nào do đầu vào khác nhau được cung cấp bởi người dùng.

Khi nói đến xác thực đầu vào trong ASP.NET Core C #, cách tiếp cận được ưu tiên nhất là Chú thích dữ liệu trong đó bạn chỉ định các thuộc tính cho từng thuộc tính trong mô hình. Các thuộc tính này là các xác nhận được thực hiện khi mô hình được xác nhận để xử lý. Cách tiếp cận này không thể mở rộng và mô hình cũng có thể bị cồng kềnh. Ngoài ra, các chú thích dữ liệu này trong mô hình không phù hợp với kiến ​​trúc mã sạch và các nguyên tắc SOLID . Thư viện FluentValidation có thể được sử dụng để thực hiện xác thực trong ASP.NET Core nhằm giải quyết một số mối quan tâm.

FluentValidation là một thư viện xác thực .NET miễn phí và phổ biến hơn có thể được sử dụng để xây dựng các quy tắc xác thực kiểu mạnh. Các quy tắc xác thực trong FluentVlidations rất dễ tạo, làm sạch và duy trì. Nó không làm cồng kềnh mô hình của bạn như chú thích dữ liệu. Bằng cách sử dụng FluentValidations để xác thực trong ASP.NET Core, bạn có quyền kiểm soát tốt hơn các xác nhận trong ứng dụng của mình.

Liên kết Thư viện - https://github.com/FluentValidation/FluentValidation

Polly

Chúng tôi sẽ không hoàn toàn chính xác nếu chúng tôi cho rằng chúng tôi đã kiểm tra kỹ lưỡng ứng dụng của mình và do đó sẽ không có bất kỳ sự cố ngừng hoạt động nào trong môi trường sản xuất. Lỗi ứng dụng chắc chắn xảy ra trong môi trường sản xuất. Những lỗi ứng dụng này có thể do những lý do không lường trước được như tải cao, lỗi phần cứng, sự cố mạng, lỗi API của bên thứ ba, v.v.

Cũng trong thế giới Microservices ngày nay, yêu cầu tạo ra các ứng dụng có khả năng chịu lỗi hoặc có khả năng phục hồi tức là các ứng dụng luôn có sẵn dịch vụ với chức năng và hiệu suất có thể chấp nhận được ngay cả trong các điều kiện như tải cao, lỗi dịch vụ của bên thứ ba, lỗi mạng, v.v. Có thể sử dụng Polly để xây dựng các dịch vụ web hoặc dịch vụ vi mô có khả năng phục hồi trong ASP.NET Core.

Polly là một thư viện xử lý lỗi tạm thời và khả năng phục hồi .NET cho phép các nhà phát triển thể hiện các chính sách như Thử lại, ngắt mạch, hết thời gian, cách ly vách ngăn và dự phòng một cách trôi chảy và an toàn cho chuỗi.

Bằng cách triển khai Polly trong ASP.NET Core, chúng tôi có thể xây dựng các ứng dụng có khả năng phục hồi có thể được thiết kế để hoạt động trơn tru bất chấp lỗi một phần xảy ra trong ứng dụng. Với Polly, chỉ cần một vài dòng mã để triển khai Khả năng chịu lỗi trong Microservices. Polly hỗ trợ các chính sách như Thử lại, Ngắt mạch, Hết thời gian chờ, Cách ly vách ngăn, Cache, Dự phòng & Gói chính sách.

Để biết thêm chi tiết về cách xây dựng các ứng dụng có khả năng phục hồi với Polly trong ASP.NET Core, bạn có thể đọc bài viết của tôi Xây dựng các Microservices (API Web) có khả năng phục hồi bằng Polly trong ASP.NET Core

Liên kết Thư viện - https://github.com/App-vNext/Polly

Swashbuckle

Khi bạn đã phát triển một API Web sẽ được các ứng dụng khác sử dụng trong trường hợp đó, việc cung cấp tài liệu chi tiết đầy đủ cho API là rất quan trọng. Ngoài ra, các nhà phát triển sử dụng API web này đang cố gắng giải quyết các vấn đề kinh doanh nên việc hiểu các phương pháp khác nhau của nó là rất quan trọng. Tài liệu API cung cấp hướng dẫn về cách sử dụng và tích hợp API vào ứng dụng của bạn. Vấn đề này trong việc tạo nhanh chóng và chính xác tài liệu hữu ích chi tiết đầy đủ cho API web có thể được giải quyết bằng Swagger, còn được gọi là OpenAPI.

Swashbuckle là một thư viện mã nguồn mở để tạo các tài liệu swagger cho ASP.NET Core Web API. Bạn có thể tạo tài liệu API đẹp mắt, bao gồm giao diện người dùng để khám phá và thử nghiệm các phương pháp hành động API. Nó cung cấp các tính năng như tạo SDK ứng dụng khách, tài liệu tương tác và khả năng phát hiện API. Swashbuckle cũng cung cấp swagger-ui tuyệt vời được hỗ trợ bởi JSON swagger được tạo.

Swashbuckle chủ yếu cung cấp 3 tính năng chính Mô hình đối tượng Swagger & phần mềm trung gian để hiển thị các tài liệu swagger làm điểm cuối, chức năng tạo các tài liệu JSON swagger và một phiên bản nhúng của các công cụ swagger-ui.

Liên kết thư viện - https://github.com/domaindrivendev/Swashbuckle.AspNetCore

Kiểm tra sức khỏe

Trong thế giới kỹ thuật số ngày nay, tính sẵn có của các ứng dụng là rất quan trọng để hoạt động của doanh nghiệp. Nếu ứng dụng của bạn không hoạt động sẽ dẫn đến thất thoát doanh thu, khách hàng không hài lòng và ảnh hưởng đến danh tiếng doanh nghiệp. Từ phía phần cứng, chúng tôi thực hiện nhiều bước để tránh lỗi như máy chủ cân bằng tải, trang web chuyển đổi dự phòng, trang khôi phục thảm họa, máy nhân bản đĩa, v.v. Điều gì sẽ xảy ra nếu ứng dụng của chúng tôi không khỏe mạnh, bị lỗi hoặc hoạt động không bình thường.

Vì vậy, chúng ta cần chủ động kiểm tra tình trạng ứng dụng của mình, tức là chúng ta cần phát hiện các lỗi, nếu có, trong ứng dụng của chúng ta trước khi người dùng bắt đầu gặp sự cố và báo cáo như vậy. Sử dụng các thư viện tình trạng có sẵn trong ASP.NET Core, chúng tôi có thể xác định ứng dụng không lành mạnh và thực hiện hành động để khắc phục nó ngay lập tức hoặc thông báo cho khách hàng về sự cố ngừng hoạt động với thời gian cần thiết để giải quyết.

Thư viện kiểm tra tình trạng trong ASP.NET Core cho phép cấu hình các kiểm tra có thể báo cáo tình trạng của ứng dụng. Các kiểm tra sức khỏe này có thể được hiển thị dưới dạng điểm cuối HTTP trong bất kỳ ứng dụng ASP.NET Core nào. Thư viện này có thể được sử dụng để định cấu hình kiểm tra tình trạng ứng dụng như bộ nhớ, đĩa, tài nguyên máy chủ và các phụ thuộc ứng dụng khác như cơ sở dữ liệu hoặc điểm cuối dịch vụ của bên thứ ba.

Liên kết Thư viện - https://www.nuget.org/packages/Microsoft.Extensions.Diagnostics.HealthChecks/6.0.5

Bản tóm tắt

Trong bài viết này, chúng ta đã tìm hiểu về 10 thư viện thiết yếu cho ASP.NET Core, tại sao chúng ta nên sử dụng các thư viện này và những tính năng nào được cung cấp bởi các thư viện này? Việc sử dụng các thư viện này trong dự án của bạn sẽ cho phép bạn sử dụng mã đã được thử và kiểm tra cho các chức năng phổ biến và bạn chỉ có thể tập trung vào các chức năng nghiệp vụ cần được phát triển như một phần của ứng dụng của mình.

Link: https://procodeguide.com/asp-net-core/10-essential-nuget-libraries/

#dotnet # aps.net #csharp #dotnetcore

10 Bibliothèques NuGet Essentielles Pour ASP.NET Core

Dans cet article, nous discuterons des 10 principales bibliothèques NuGet essentielles pour ASP.NET Core que chaque développeur devrait connaître pour développer de meilleures applications ASP.NET Core et également réduire le temps nécessaire au développement de ces applications.

Aperçu

Le framework .NET Core s'est développé si rapidement de .NET Core 1.0 à .NET 6 et de nombreuses bibliothèques ont également été développées pour aider les développeurs à implémenter les fonctionnalités communes requises dans l'application. Il devient donc très important pour les développeurs de comprendre quelles sont ces bibliothèques et quels problèmes sont résolus en utilisant ces bibliothèques.

Ces 10 bibliothèques NuGet essentielles pour ASP.NET Core sont du code réutilisable gratuit et open source écrit par quelqu'un d'autre. Le but de ces bibliothèques NuGet est d'aider à résoudre les problèmes courants de manière plus simple et vous permet également d'améliorer la productivité du développement d'applications.

L'utilisation de ces bibliothèques permettra aux développeurs d'utiliser un code éprouvé pour la plupart des fonctionnalités courantes requises dans votre application. Cela facilitera non seulement le développement rapide d'applications, mais permettra également aux développeurs de se concentrer uniquement sur les exigences fonctionnelles de l'application.

Avantages et inconvénients de l'utilisation de bibliothèques tierces

Il est également important de connaître les avantages et les inconvénients de l'utilisation d'une bibliothèque tierce dans votre application afin de pouvoir prendre une décision éclairée. Voici les avantages et les inconvénients de l'utilisation d'une bibliothèque tierce dans votre application

Avantages

• Gain de temps dans le développement et les tests
• Les développeurs peuvent se concentrer sur les exigences fonctionnelles
• Code essayé et testé

Les inconvénients

• Dépendance à un code tiers
• Parfois, il n'y a pas assez de support disponible pour les bibliothèques tierces
• Il peut y avoir des problèmes de sécurité avec la bibliothèque.

10 bibliothèques NuGet essentielles pour ASP.NET Core

Voici les 10 meilleures bibliothèques NuGet essentielles pour ASP.NET Core pour améliorer la productivité du développeur et développer de meilleures applications à l'aide de ces bibliothèques.

Sérilog

L'écriture du journal d'application est essentielle pour toute application car elle vous permet d'analyser le comportement de l'application dans l'environnement de production et vous aide à identifier la cause première en cas d'exceptions survenues dans l'application. La journalisation peut également être utilisée pour consigner les paramètres de performance afin d'identifier les morceaux de code qui s'exécutent lentement. Serilog peut être utilisé pour implémenter la journalisation dans les applications ASP.NET Core.

Serilog est une bibliothèque tierce qui fournit des fonctionnalités pour la journalisation des événements d'application, des informations et des exceptions vers la destination souhaitée comme la console, le fichier, la base de données, le cloud, etc. Serilog permet également de formater les entrées de journal en tant que journaux structurés afin que ces entrées puissent être lu et traité par un programme informatique.

Lien vers la bibliothèque – https://github.com/serilog/serilog

Pimpant

Le mappage objet-relationnel (ORM) est la technique de programmation dans laquelle vous écrivez les requêtes de base de données (SQL) dans votre langage préféré et obtenez la sortie de la base de données en tant qu'objets du langage de programmation. L'ORM cache toutes les complexités et encapsule les requêtes SQL dans des objets. Le Dapper est l'un des meilleurs ORM pouvant être utilisé dans ASP.NET Core pour interagir avec la base de données.

Un Dapper est un simple mappeur relationnel objet ou un micro ORM qui peut être utilisé pour mapper les résultats de la base de données aux objets .NET C#. En utilisant Dapper dans ASP.NET Core, nous pouvons écrire des instructions SQL comme si nous les écrivions dans le studio de gestion SQL Server, mais les résultats sont mappés à l'objet de classe .NET C# 0domain. Dapper fournit cette interface avec la base de données avec de bons résultats de performance et est presque aussi rapide que RAW ADO.NET. Dapper prend également en charge les requêtes paramétrées qui peuvent être utilisées pour éviter les attaques par injection SQL sur l'application ASP.NET Core.

Lien vers la bibliothèque – https://github.com/DapperLib/Dapper

xUnit

Il est toujours essentiel de tester l'application avant de la déployer en production ou de la livrer au client pour test, car de bons tests côté développeur garantissent la bonne qualité de l'application livrée. À mesure que la taille du code augmente, cela ajoute de la complexité à l'application, de sorte que le temps requis pour les tests augmente. Donc, à cette fin, il est toujours préférable d'automatiser les tests dans l'application, car cela réduira le temps et les efforts nécessaires pour tester l'application.

Il existe des applications dans certaines organisations qui doivent déployer des modifications en production toutes les heures, de sorte que les tests unitaires automatisés dans ces projets deviennent une nécessité pour garantir la bonne qualité du code livré. Le xUnit.NET peut être utilisé pour automatiser les tests unitaires de l'application dans ASP.NET Core

xUnit.net est un outil de test unitaire gratuit, open source et axé sur la communauté pour .NET Core et .NET. xUnit.Net est le tout dernier framework de test unitaire pour les projets ASP.NET Core et a gagné en popularité lorsque Microsoft a commencé à l'utiliser pour créer le code pour ASP.NET Core Framework. xUnit.net peut également être utilisé pour implémenter des tests unitaires dans les frameworks .NET Core et .NET Full. XUnit.net est le dernier framework de test qui implémente un ensemble d'attributs ou de décorateurs pouvant être utilisés dans les méthodes de test et à l'aide desquels nous pouvons écrire du code de test unitaire pour tester automatiquement les composants logiciels ou les unités d'une application dans ASP.NET Core.

Pour en savoir plus sur la façon d'implémenter les tests unitaires dans ASP.NET Core, vous pouvez lire mon article Implémenter les tests unitaires dans l'application ASP.NET Core 5 - Mise en route

Lien vers la bibliothèque – https://github.com/xunit/xunit

Moq

Comme indiqué ci-dessus, les tests unitaires automatisés sont importants pour fournir un produit de qualité, mais parfois l'écriture de ces tests unitaires est une tâche difficile car les composants testés peuvent dépendre d'autres parties et ces autres parties peuvent ne pas être prêtes ou il peut être difficile d'utiliser ces autres parties pour écrire les tests unitaires. C'est là que les objets fictifs viennent aider, une version fictive d'un objet est quelque chose qui implémente la même interface que l'objet réel afin qu'il puisse agir comme un objet réel mais le comportement de l'objet fictif dans le code de test unitaire peut être contrôlé à l'aide de la configuration ou par code.

Les objets fictifs ne sont rien d'autre que de fausses classes qui renvoient une valeur connue et configurée pour l'entrée fournie. Moq peut être utilisé pour implémenter ces objets fictifs à des fins de test unitaire.

Moq est le framework de simulation le plus populaire et le plus convivial disponible sur GitHub pour créer des objets fictifs dans .NET et .NET Core. Moq prend en charge la configuration d'objets fictifs, comme vous pouvez configurer des propriétés d'objet, ajouter des méthodes avec une entrée pour des arguments spécifiques et renvoyer des valeurs spécifiques, etc. Ces objets fictifs peuvent être utilisés dans le code de test pour les appels d'objets fictifs.

Lien vers la bibliothèque – https://github.com/moq/moq

AutoMappeur

Dans vos applications où vous vous interfacez avec une base de données pour enregistrer des données, vous aurez différents objets pour les modèles de vue et les entités de base de données. L'objet de modèle de vue est utilisé pour obtenir des données des utilisateurs et les entités de base de données correspondent exactement aux tables de base de données conçues pour interagir avec la base de données. Dans ce scénario, vous devrez copier les données de l'instance du modèle vers l'instance de l'entité de base de données.

Étant donné que les objets sont de classes différentes, vous ne pouvez pas définir une instance d'un objet sur un autre objet, vous devrez utiliser l'approche traditionnelle consistant à copier des données d'un objet à un autre champ par champ. Pour simplifier ce travail de mappage de données d'un objet à un autre objet, AutoMapper peut être utilisé.

Automapper dans ASP.NET Core est une petite bibliothèque populaire pour un mappage d'objet à objet utilisé pour mapper des objets de différentes classes. Automapper dans ASP.NET Core est une bibliothèque open-source et il mappe les propriétés de deux objets différents. Automapper peut être utilisé pour mapper des objets de n'importe quelle classe, mais les noms des propriétés dans les deux classes doivent être identiques. Si le nom des propriétés n'est pas identique, dans ce cas, Automapper fournit une option pour spécifier manuellement l'ensemble des noms de propriété source et de destination.

Pour en savoir plus sur la façon d'implémenter Automapper dans ASP.NET Core, vous pouvez lire mon article Implémenter Automapper dans ASP.NET Core 3.1 - Guide rapide et facile

Lien vers la bibliothèque – https://github.com/AutoMapper/AutoMapper

Newtonsoft Json.NET

De nos jours, il est très courant que les applications appellent l'API Web pour diverses raisons telles que la récupération de données, le service de messagerie, le service SMS, le service cloud, etc. Ces API peuvent être nos propres projets développés ou d'autres API tierces. Lorsqu'il s'agit d'échanger des données entre différentes API, JSON est le format le plus populaire et préféré. Lorsque vous travaillez sur des applications ASP.NET Core et que vous interagissez avec l'API Web, la conversion de la chaîne de données JSON en objet .NET C# et vice versa sera nécessaire pour accéder à l'API basée sur JSON.

Le processus de conversion des objets .NET C# en chaînes au format JSON est appelé sérialisation et la conversion des chaînes au format JSON en objets .NET C# est appelée désérialisation. Newtonsoft Json.NET est une bibliothèque qui peut être utilisée pour la sérialisation et la désérialisation.

Json.NET est un framework JSON pour .NET de Newtonsoft. Json.NET est un framework très populaire et très performant pour JSON. Json.NET prend en charge des fonctionnalités telles que la sérialisation et la désérialisation de tout objet .NET C #, LINQ to Json, la prise en charge XML, etc. Newtonsoft Json.NET est une bibliothèque tierce haute performance et facile à utiliser. Json.NET prend en charge plusieurs plates-formes telles que Windows, macOS, Linux, Mono et Xamarin.

Lien vers la bibliothèque – https://github.com/JamesNK/Newtonsoft.Json

FluentValidation

Aujourd'hui, nous écrivons des API publiques accessibles à tous sur Internet et différents utilisateurs peuvent fournir toutes sortes d'entrées. Aujourd'hui, quelqu'un avec une mauvaise intention peut faire tomber notre application si nous ne validons pas correctement l'entrée. Ainsi, les validations des données d'entrée sont essentielles pour que toute application fonctionne sans aucun problème en raison des différentes entrées fournies par les utilisateurs.

En ce qui concerne la validation des entrées dans ASP.NET Core C#, l'approche préférée est celle des annotations de données dans lesquelles vous spécifiez des attributs pour chaque propriété du modèle. Ces attributs sont les validations qui sont effectuées lorsque le modèle est validé pour le traitement. Cette approche n'est pas extensible et le modèle peut également être gonflé. De plus, ces annotations de données dans le modèle ne sont pas conformes à l'architecture de code propre et aux principes SOLID . La bibliothèque FluentValidation peut être utilisée pour effectuer une validation dans ASP.NET Core afin de résoudre certaines des préoccupations.

FluentValidation est une bibliothèque de validation .NET gratuite et populaire qui peut être utilisée pour créer des règles de validation fortement typées. Les règles de validation dans FluentVlidations sont faciles à créer, à nettoyer et à maintenir. Il ne gonfle pas votre modèle comme les annotations de données. En utilisant FluentValidations pour les validations dans ASP.NET Core, vous avez un meilleur contrôle sur les validations dans votre application.

Lien vers la bibliothèque – https://github.com/FluentValidation/FluentValidation

Polly

Nous n'aurons pas tout à fait raison si nous supposons que nous avons soigneusement testé notre application et qu'il n'y aura donc pas de panne dans l'environnement de production. Les pannes d'application sont inévitables dans l'environnement de production. Ces défaillances d'application peuvent être dues à des raisons imprévues telles que des charges élevées, une défaillance matérielle, des problèmes de réseau, des défaillances d'API tierces, etc.

Toujours dans le monde des microservices d'aujourd'hui, il est nécessaire de créer des applications tolérantes aux pannes ou résilientes, c'est-à-dire des applications où le service est toujours disponible avec des fonctionnalités et des performances acceptables, même dans des conditions telles qu'une charge élevée, des pannes de service tiers, des pannes de réseau, etc. Polly peut être utilisé pour créer des services Web résilients ou des microservices dans ASP.NET Core.

Polly est une bibliothèque de résilience .NET et de gestion des erreurs transitoires qui permet aux développeurs d'exprimer des politiques telles que Retry, Circuit Breaker, Timeout, Bulkhead Isolation et Fallback de manière fluide et thread-safe.

En implémentant Polly dans ASP.NET Core, nous pouvons créer des applications résilientes qui peuvent être conçues pour fonctionner sans problème malgré les défaillances partielles qui se produisent dans l'application. Avec Polly, quelques lignes de code suffisent pour implémenter la tolérance aux pannes dans les microservices. Polly prend en charge des politiques telles que Retry, Circuit Breaker, Timeout, Bulkhead Isolation, Cache, Fallback & Policy Wrap.

Pour en savoir plus sur la façon de créer des applications résilientes avec Polly dans ASP.NET Core, vous pouvez lire mon article Build Resilient Microservices (Web API) using Polly in ASP.NET Core

Lien vers la bibliothèque – https://github.com/App-vNext/Polly

Swashbuckle

Lorsque vous avez développé une API Web qui sera consommée par différentes autres applications, dans ce cas, il est très important de fournir une documentation complète et détaillée pour l'API. De plus, les développeurs utilisant cette API Web tentent de résoudre des problèmes commerciaux. Il est donc très important de comprendre ses différentes méthodes. La documentation de l'API fournit des instructions sur l'utilisation et l'intégration de l'API dans votre application. Ce problème de génération rapide et précise d'une documentation utile complète et détaillée pour l'API Web peut être résolu par Swagger, également connu sous le nom d'OpenAPI.

Swashbuckle est une bibliothèque open source permettant de générer des documents swagger pour l'API Web ASP.NET Core. Vous pouvez générer une belle documentation d'API, y compris une interface utilisateur pour explorer et tester les méthodes d'action de l'API. Il fournit des fonctionnalités telles que la génération de SDK client, la documentation interactive et la possibilité de découvrir l'API. Swashbuckle fournit également une interface utilisateur géniale qui est alimentée par le JSON swagger généré.

Swashbuckle fournit principalement 3 fonctionnalités principales Modèle d'objet et middleware Swagger pour exposer les documents swagger en tant que point de terminaison, fonctionnalité pour générer des documents JSON swagger et une version intégrée des outils swagger-ui.

Lien vers la bibliothèque – https://github.com/domaindrivendev/Swashbuckle.AspNetCore

Bilans de santé

Dans le monde numérique d'aujourd'hui, la disponibilité des applications est essentielle au bon fonctionnement de l'entreprise. Si votre application est en panne, cela entraîne une perte de revenus, des clients mécontents et un impact sur la réputation de l'entreprise. Du côté matériel, nous prenons de nombreuses mesures pour éviter les pannes comme les serveurs à charge équilibrée, les sites de basculement, les sites de reprise après sinistre, les miroirs de disque, etc. Que se passe-t-il si notre application est malsaine, en panne ou ne fonctionne pas correctement.

Nous devons donc vérifier de manière proactive la santé de notre application, c'est-à-dire que nous devons détecter les erreurs, le cas échéant, dans notre application avant que les utilisateurs ne commencent à rencontrer des problèmes et les signaler. À l'aide des bibliothèques d'intégrité disponibles dans ASP.NET Core, nous pouvons déterminer l'application défectueuse et prendre les mesures nécessaires pour la réparer immédiatement ou informer le client de la panne avec le temps nécessaire à la résolution.

La bibliothèque de vérifications de l'état dans ASP.NET Core permet de configurer des vérifications pouvant signaler l'état de l'application. Ces vérifications de l'état peuvent être exposées en tant que points de terminaison HTTP dans n'importe quelle application ASP.NET Core. Cette bibliothèque peut être utilisée pour configurer les vérifications de l'état des applications telles que la mémoire, le disque, les ressources du serveur et d'autres dépendances d'application telles que la base de données ou les points de terminaison de service tiers.

Lien vers la bibliothèque – https://www.nuget.org/packages/Microsoft.Extensions.Diagnostics.HealthChecks/6.0.5

Sommaire

Dans cet article, nous avons appris quelles sont ces 10 bibliothèques essentielles pour ASP.NET Core, pourquoi devrions-nous utiliser ces bibliothèques et quelles fonctionnalités sont offertes par ces bibliothèques ? L'utilisation de ces bibliothèques dans votre projet vous permettra d'utiliser un code éprouvé pour les fonctionnalités courantes et vous pourrez vous concentrer uniquement sur les fonctionnalités métier qui doivent être développées dans le cadre de votre application.

Link: https://procodeguide.com/asp-net-core/10-essential-nuget-libraries/

#dotnet #aps.net #csharp #dotnetcore

10 個適用於 ASP.NET Core 的基本 NuGet 庫

在本文中，我們將討論 ASP.NET Core 的 10 個基本 NuGet 庫，每個開發人員都應該知道這些庫，以開發更好的 ASP.NET Core 應用程序並減少開發這些應用程序所需的時間。

概述

.NET Core 框架從 .NET Core 1.0 快速發展到 .NET 6，並且還開發了許多庫來幫助開發人員實現應用程序所需的通用功能。因此，對於開發人員來說，了解哪些是這些庫以及使用這些庫解決了哪些問題變得非常重要。

這 10 個用於 ASP.NET Core 的基本 NuGet 庫是由其他人編寫的免費和開源可重用代碼。這些 NuGet 庫的目的是幫助以更簡單的方式解決常見問題，並允許您提高應用程序開發的生產力。

使用這些庫將允許開發人員使用經過驗證的代碼來實現應用程序所需的大多數常見功能。這不僅有助於快速應用程序開發，而且還允許開發人員只關注應用程序的功能需求。

使用第三方庫的優缺點

了解在應用程序中使用任何第三方庫的利弊也很重要，這樣您才能做出明智的決定。以下是在您的應用程序中使用第三方庫的優點和缺點

優點

• 節省開發和測試時間
• 開發人員可以專注於功能需求
• 久經考驗的代碼

缺點

• 對第三方代碼的依賴
• 有時第三方庫沒有足夠的支持
• 圖書館可能存在安全問題。

10 個適用於 ASP.NET Core 的基本 NuGet 庫

以下是 ASP.NET Core 的 10 個基本 NuGet 庫，可提高開發人員的工作效率並使用這些庫開發更好的應用程序。

Serilog

應用程序日誌寫入對於任何應用程序都至關重要，因為它可以讓您分析生產環境中的應用程序行為，並幫助您在應用程序發生異常的情況下確定根本原因。日誌記錄還可用於記錄性能參數，以識別運行緩慢的代碼片段。Serilog 可用於在 ASP.NET Core 應用程序中實現日誌記錄。

Serilog 是一個第三方庫，提供將應用程序事件、信息和異常記錄到所需目的地（如控制台、文件、數據庫、雲等）的功能。Serilog 還允許將日誌條目格式化為結構化日誌，以便這些條目可以由計算機程序讀取和處理。

圖書館鏈接 - https://github.com/serilog/serilog

小巧玲瓏

對象關係映射 (ORM) 是一種編程技術，您可以在其中使用首選語言編寫數據庫 (SQL) 查詢，並從數據庫中獲取作為編程語言對象的輸出。ORM 隱藏了所有復雜性並將 SQL 查詢封裝到對像中。Dapper 是可用於 ASP.NET Core 與數據庫交互的最佳 ORM 之一。

Dapper 是一個簡單的對象關係映射器或微型 ORM，可用於將數據庫結果映射到 .NET C# 對象。通過在 ASP.NET Core 中使用 Dapper，我們可以編寫 SQL 語句，就像我們在 SQL Server 管理工作室中編寫它們一樣，但結果會映射到 .NET C# 0domain 類對象。Dapper 為數據庫提供了這個接口，具有良好的性能結果，幾乎與 RAW ADO.NET 一樣快。Dapper 還支持參數化查詢，可用於避免對 ASP.NET Core 應用程序的 SQL 注入攻擊。

圖書館鏈接 - https://github.com/DapperLib/Dapper

xUnit

在我們將應用程序部署到生產環境或將其交付給客戶進行測試之前，測試應用程序始終至關重要，因為在開發人員端進行良好的測試可確保交付的應用程序具有良好的質量。隨著代碼大小的增加，它會增加應用程序的複雜性，因此測試所需的時間也會增加。因此，為此目的，最好在應用程序中自動化測試，因為這將減少測試應用程序所需的時間和精力。

一些組織中的應用程序需要每小時將更改部署到生產環境，因此這些項目中的自動化單元測試成為確保交付代碼質量的必要條件。xUnit.NET 可用於在 ASP.NET Core 中自動執行應用程序的單元測試

xUnit.net 是一個免費的、開源的、以社區為中心的單元測試工具，適用於 .NET Core 和 .NET。xUnit.Net 是 ASP.NET Core 項目的最新單元測試框架，並在 Microsoft 開始使用它來構建 ASP.NET Core Framework 的代碼時廣受歡迎。xUnit.net 也可用於在 .NET Core 和 .NET Full 框架中實現單元測試。XUnit.net 是最新的測試框架，它實現了一組可用於測試方法的屬性或裝飾器，我們可以使用它們編寫單元測試代碼來自動測試 ASP.NET Core 中的軟件組件或應用程序單元。

要了解有關如何在 ASP.NET Core 中實現單元測試的更多詳細信息，您可以閱讀我的文章在 ASP.NET Core 5 應用程序中實現單元測試 - 入門

圖書館鏈接 - https://github.com/xunit/xunit

起訂量

如上所述，自動化單元測試對於交付高質量的產品很重要，但有時編寫這些單元測試是一項艱鉅的任務，因為被測試的組件可能依賴於其他部分，而這些其他部分可能還沒有準備好，或者可能難以使用這些其他部分編寫單元測試的部分。這就是模擬對象來幫助的地方，一個對象的模擬版本是實現與真實對象相同的接口的東西，這樣它就可以像一個真實的對像一樣工作，但是模擬對像在單元測試代碼中的行為可以使用配置或通過代碼控制。

模擬對像只不過是假類，它們為所提供的輸入返回已知和配置的值。Moq 可用於實現這些模擬對像以進行單元測試。

Moq 是 GitHub 上最流行和最友好的模擬框架，用於在 .NET 和 .NET Core 中創建模擬對象。Moq 支持模擬對象的配置，例如您可以設置對象屬性、添加具有特定參數的輸入方法和返回特定值等。這些模擬對象可用於測試代碼中以調用模擬對象。

圖書館鏈接 - https://github.com/moq/moq

自動映射器

在與數據庫交互以保存數據的應用程序中，視圖模型和數據庫實體將具有不同的對象。視圖模型對像用於從用戶那裡獲取數據，數據庫實體與設計用於與數據庫交互的數據庫表完全匹配。在這種情況下，您必須將數據從模型實例複製到數據庫實體實例。

由於對象屬於不同的類，因此您無法將一個對象的實例設置為另一個對象，因此您必須使用傳統方法將數據從一個對象逐個字段複製到另一個對象。為了簡化將數據從一個對象映射到另一個對象的工作，可以使用 AutoMapper。

ASP.NET Core 中的 Automapper 是一個小型且流行的對像到對象映射庫，用於映射不同類的對象。ASP.NET Core 中的 Automapper 是一個開源庫，它映射兩個不同對象的屬性。Automapper 可用於映射任何類的對象，但兩個類中的屬性名稱應相同。如果屬性的名稱不相同，那麼在這種情況下 Automapper 提供了一個選項來手動指定源和目標屬性名稱的集合。

要了解有關如何在 ASP.NET Core 中實現 Automapper 的更多詳細信息，您可以閱讀我的文章在 ASP.NET Core 3.1 中實現 Automapper – 快速簡單指南

圖書館鏈接 - https://github.com/AutoMapper/AutoMapper

牛頓軟件 Json.NET

如今，應用程序由於數據檢索、電子郵件服務、短信服務、雲服務等各種原因調用 Web API 非常普遍。這些 API 可以是我們自己開發的項目或其他第三方 API。在不同 API 之間交換數據時，JSON 是最流行和首選的格式。當您處理 ASP.NET Core 應用程序並與 Web API 交互時，需要將 JSON 數據字符串轉換為 .NET C# 對象，反之亦然，才能訪問基於 JSON 的 API。

將 .NET C# 對象轉換為 JSON 格式字符串的過程稱為序列化，將 JSON 格式字符串轉換為 .NET C# 對象稱為反序列化。Newtonsoft Json.NET 是一個可用於序列化和反序列化的庫。

Json.NET 是 Newtonsoft 的 .NET 的 JSON 框架。Json.NET 是一個非常流行的高性能 JSON 框架。Json.NET 支持任何 .NET C# 對象的序列化和反序列化、LINQ to Json、XML 支持等功能。Newtonsoft Json.NET 是高性能且易於使用的第三方庫。Json.NET 支持 Windows、macOS、Linux、Mono 和 Xamarin 等多平台。

圖書館鏈接 - https://github.com/JamesNK/Newtonsoft.Json

流利驗證

今天，我們正在編寫公共 API，互聯網上的任何人都可以訪問，不同的用戶可以提供各種輸入。今天，如果我們沒有正確驗證輸入，懷有錯誤意圖的人可能會破壞我們的應用程序。因此，由於用戶提供的不同輸入，輸入數據驗證對於任何應用程序正常運行都至關重要。

在 ASP.NET Core C# 中進行輸入驗證時，最首選的方法是數據註釋，您可以在其中為模型中的每個屬性指定屬性。這些屬性是在驗證模型以進行處理時執行的驗證。這種方法不可擴展，模型也會變得臃腫。而且，模型中的這些數據標註也不符合乾淨代碼架構和SOLID原則。FluentValidation 庫可用於在 ASP.NET Core 中執行驗證，以解決一些問題。

FluentValidation 是一個免費且流行的 .NET 驗證庫，可用於構建強類型驗證規則。FluentVlidations 中的驗證規則易於創建、清理和維護。它不會像數據註釋那樣使您的模型膨脹。通過在 ASP.NET Core 中使用 FluentValidations 進行驗證，您可以更好地控制應用程序中的驗證。

圖書館鏈接 - https://github.com/FluentValidation/FluentValidation

波莉

如果我們假設我們已經徹底測試了我們的應用程序，那麼我們將不完全正確，因此生產環境中不會出現任何中斷。應用程序故障必然會發生在生產環境中。這些應用程序故障可能是由於不可預見的原因，如高負載、硬件故障、網絡問題、第三方 API 故障等。

同樣在當今的微服務世界中，需要創建容錯或彈性應用程序，即即使在高負載、第三方服務故障、網絡故障等條件下，服務也始終可用且具有可接受的功能和性能的應用程序。可以使用 Polly在 ASP.NET Core 中構建彈性 Web 服務或微服務。

Polly 是一個 .NET 彈性和瞬態故障處理庫，允許開發人員以流暢和線程安全的方式表達重試、斷路器、超時、隔板隔離和回退等策略。

通過在 ASP.NET Core 中實現 Polly，我們可以構建彈性應用程序，這些應用程序可以設計為即使在應用程序中發生部分故障也能順利運行。使用 Polly，只需幾行代碼即可在微服務中實現容錯。Polly 支持重試、斷路器、超時、隔板隔離、緩存、回退和策略包裝等策略。

要了解有關如何在 ASP.NET Core 中使用 Polly 構建彈性應用程序的更多詳細信息，您可以閱讀我的文章Build Resilient Microservices (Web API) using Polly in ASP.NET Core

圖書館鏈接 - https://github.com/App-vNext/Polly

花花公子

當您開發了一個將由不同的其他應用程序使用的 Web API 時，提供 API 的完整詳細文檔非常重要。此外，使用此 Web API 的開發人員正在嘗試解決業務問題，因此了解其各種方法非常重要。API 文檔提供了有關如何使用 API 並將其集成到應用程序中的說明。Swagger（也稱為 OpenAPI）可以解決快速準確地為 Web API 生成完整詳細的有用文檔的問題。

Swashbuckle 是一個開源庫，用於為 ASP.NET Core Web API 生成 swagger 文檔。您可以生成漂亮的 API 文檔，包括用於探索和測試 API 操作方法的 UI。它提供了客戶端 SDK 生成、交互式文檔和 API 可發現性等功能。Swashbuckle 還提供了很棒的 swagger-ui，它由生成的 swagger JSON 提供支持。

Swashbuckle 主要提供 3 個主要功能 Swagger 對像模型和中間件將 swagger 文檔公開為端點、生成 swagger JSON 文檔的功能和嵌入式版本的 swagger-ui 工具。

庫鏈接 - https://github.com/domaindrivendev/Swashbuckle.AspNetCore

健康檢查

在當今的數字世界中，應用程序的可用性對於業務運作至關重要。如果您的應用程序出現故障，則會導致收入損失、客戶不滿意並影響商業聲譽。在硬件方面，我們採取了許多措施來避免故障，例如負載平衡服務器、故障轉移站點、災難恢復站點、磁盤鏡像等。如果我們的應用程序不健康、崩潰或無法正常運行怎麼辦。

因此，我們需要主動檢查應用程序的健康狀況，即我們需要在用戶開始面臨問題並報告問題之前檢測應用程序中的錯誤（如果有）。使用 ASP.NET Core 中可用的運行狀況庫，我們可以確定不正常的應用程序並採取措施立即修復它，或者在解決問題所需的時間內通知客戶中斷。

ASP.NET Core 中的運行狀況檢查庫允許配置可以報告應用程序運行狀況的檢查。這些運行狀況檢查可以在任何 ASP.NET Core 應用程序中作為 HTTP 端點公開。該庫可用於配置應用程序健康檢查，如內存、磁盤、服務器資源和其他應用程序依賴項，如數據庫或第三方服務端點。

庫鏈接 - https://www.nuget.org/packages/Microsoft.Extensions.Diagnostics.HealthChecks/6.0.5

概括

在本文中，我們了解了這 10 個 ASP.NET Core 的基本庫，我們為什麼要使用這些庫以及這些庫提供了哪些功能？在您的項目中使用這些庫將允許您使用經過驗證的代碼來實現常見功能，並且您可以只關注需要作為應用程序一部分開發的業務功能。

Link: https://procodeguide.com/asp-net-core/10-essential-nuget-libraries/

#dotnet #aps.net #csharp #dotnetcore

10 основных библиотек NuGet для ASP.NET Core

В этой статье мы обсудим 10 основных основных библиотек NuGet для ASP.NET Core, которые должен знать каждый разработчик, чтобы разрабатывать лучшие приложения ASP.NET Core, а также сокращать время, необходимое для разработки этих приложений.

Обзор

Платформа .NET Core так быстро выросла с .NET Core 1.0 до .NET 6, и многие библиотеки также были разработаны, чтобы помочь разработчикам реализовать общие функции, необходимые в приложении. Поэтому разработчикам становится очень важно понять, что это за библиотеки и какие проблемы решаются с помощью этих библиотек.

Эти 10 основных библиотек NuGet для ASP.NET Core представляют собой бесплатный код с открытым исходным кодом для многократного использования, написанный кем-то другим. Цель этих библиотек NuGet — упростить решение распространенных проблем, а также повысить производительность разработки приложений.

Использование этих библиотек позволит разработчикам использовать испытанный и проверенный код для большинства общих функций, необходимых в вашем приложении. Это не только поможет в быстрой разработке приложений, но также позволит разработчикам сосредоточиться только на функциональных требованиях приложения.

Плюсы и минусы использования сторонних библиотек

Также важно знать плюсы и минусы использования любой сторонней библиотеки в вашем приложении, чтобы вы могли принять взвешенное решение. Вот преимущества и недостатки использования сторонней библиотеки в вашем приложении.

Плюсы

• Экономит время на разработку и тестирование
• Разработчики могут сосредоточиться на функциональных требованиях
• Пробный код

Минусы

• Зависимость от стороннего кода
• Иногда не хватает поддержки для сторонних библиотек.
• В библиотеке могут быть проблемы с безопасностью.

10 основных библиотек NuGet для ASP.NET Core

Вот 10 основных библиотек NuGet для ASP.NET Core, которые помогут повысить производительность разработчиков и разработать более качественные приложения с использованием этих библиотек.

Серилог

Запись журнала приложения имеет решающее значение для любого приложения, поскольку позволяет анализировать поведение приложения в производственной среде и помогает определить основную причину в случае возникновения исключений в приложении. Ведение журнала также можно использовать для регистрации параметров производительности, чтобы выявить медленно работающие фрагменты кода. Serilog можно использовать для реализации ведения журнала в приложениях ASP.NET Core.

Serilog — это сторонняя библиотека, которая обеспечивает функциональность для регистрации событий, информации и исключений приложений в желаемом месте назначения, таком как консоль, файл, база данных, облако и т. д. Serilog также позволяет форматировать записи журнала как структурированные журналы, чтобы эти записи могли быть прочитаны и обработаны компьютерной программой.

Ссылка на библиотеку — https://github.com/serilog/serilog

щеголеватый

Объектно-реляционное отображение (ORM) — это метод программирования, при котором вы пишете запросы к базе данных (SQL) на предпочитаемом вами языке и получаете выходные данные из базы данных в виде объектов языка программирования. ORM скрывает все сложности и инкапсулирует запросы SQL в объекты. Dapper — одна из лучших ORM, которые можно использовать в ASP.NET Core для взаимодействия с базой данных.

Dapper — это простой объектно-реляционный преобразователь или микро ORM, который можно использовать для сопоставления результатов базы данных с объектами .NET C#. Используя Dapper в ASP.NET Core, мы можем писать операторы SQL, как будто мы пишем их в студии управления SQL Server, но результаты сопоставляются с объектом класса домена .NET C# 0. Dapper предоставляет этот интерфейс с базой данных с хорошими результатами производительности и почти так же быстр, как RAW ADO.NET. Dapper также поддерживает параметризованные запросы, которые можно использовать для предотвращения атак путем внедрения кода SQL в приложение ASP.NET Core.

Ссылка на библиотеку — https://github.com/DapperLib/Dapper

xUnit

Всегда важно протестировать приложение, прежде чем мы развернем его на производстве или доставим заказчику для тестирования, поскольку хорошее тестирование на стороне разработчика обеспечивает хорошее качество поставляемого приложения. По мере увеличения размера кода приложение усложняется, поэтому время, необходимое для тестирования, увеличивается. Поэтому для этой цели всегда лучше автоматизировать тестирование в приложении, поскольку это сократит время и усилия, необходимые для тестирования приложения.

В некоторых организациях есть приложения, которым необходимо развертывать изменения в рабочей среде каждый час, поэтому автоматические модульные тесты в этих проектах становятся необходимостью для обеспечения хорошего качества поставляемого кода. xUnit.NET можно использовать для автоматизации модульного тестирования приложения в ASP.NET Core.

xUnit.net — это бесплатный инструмент модульного тестирования с открытым исходным кодом для .NET Core и .NET, ориентированный на сообщество. xUnit.Net — это новейшая платформа модульного тестирования для проектов ASP.NET Core, которая приобрела популярность, когда Microsoft начала использовать ее для создания кода для ASP.NET Core Framework. xUnit.net можно использовать для реализации модульного тестирования как в .NET Core, так и в .NET Full framework. XUnit.net — это новейшая среда тестирования, которая реализует набор атрибутов или декораторов, которые можно использовать в методах тестирования и с помощью которых мы можем писать код модульного тестирования для автоматического тестирования программных компонентов или модулей приложения в ASP.NET Core.

Чтобы узнать больше о том, как реализовать модульное тестирование в ASP.NET Core, вы можете прочитать мою статью «Внедрение модульного тестирования в приложении ASP.NET Core 5 — начало работы».

Ссылка на библиотеку — https://github.com/xunit/xunit

Минимальный заказ

Как обсуждалось выше, автоматизированные модульные тесты важны для выпуска качественного продукта, но иногда написание этих модульных тестов является сложной задачей, поскольку тестируемые компоненты могут зависеть от других частей, а эти другие части могут быть не готовы или может быть сложно использовать эти другие. частей для написания модульных тестов. Здесь на помощь приходят фиктивные объекты, фиктивная версия объекта — это то, что реализует тот же интерфейс, что и реальный объект, поэтому он может вести себя как реальный объект, но поведение фиктивного объекта в коде модульного теста может быть изменено. управляется с помощью конфигурации или кода.

Мок-объекты — это не что иное, как поддельные классы, которые возвращают известное и настроенное значение для предоставленного ввода. Moq можно использовать для реализации этих фиктивных объектов в целях модульного тестирования.

Moq — это самая популярная и удобная платформа для создания макетов, доступная на GitHub, для создания макетов объектов в .NET и .NET Core. Moq поддерживает настройку фиктивных объектов, например, вы можете настраивать свойства объекта, добавлять методы с входными данными для конкретных аргументов и возвращать определенные значения и т. д. Эти фиктивные объекты можно использовать в тестовом коде для вызовов фиктивных объектов.

Ссылка на библиотеку — https://github.com/moq/moq

Автокартограф

В ваших приложениях, где вы взаимодействуете с базой данных для сохранения данных, у вас будут разные объекты для моделей представления и сущностей базы данных. Объект модели представления используется для получения данных от пользователей, а объекты базы данных точно соответствуют таблицам базы данных, предназначенным для взаимодействия с базой данных. В этом случае вам придется скопировать данные из экземпляра модели в экземпляр объекта базы данных.

Поскольку объекты относятся к разным классам, вы не можете установить экземпляр одного объекта в другой объект, вам придется использовать традиционный подход копирования данных из одного объекта в другой поле за полем. Чтобы упростить эту работу по отображению данных из одного объекта в другой объект, можно использовать AutoMapper.

Automapper в ASP.NET Core — это небольшая и популярная библиотека для сопоставления объектов, используемая для сопоставления объектов разных классов. Automapper в ASP.NET Core — это библиотека с открытым исходным кодом, которая сопоставляет свойства двух разных объектов. Automapper можно использовать для сопоставления объектов любого класса, но имена свойств в обоих классах должны быть идентичными. Если имена свойств не идентичны, то в этом случае Automapper предоставляет возможность вручную указать набор имени исходного и целевого свойств.

Чтобы узнать больше о том, как внедрить Automapper в ASP.NET Core, вы можете прочитать мою статью «Внедрение Automapper в ASP.NET Core 3.1 — краткое и простое руководство».

Ссылка на библиотеку — https://github.com/AutoMapper/AutoMapper

Ньютонсофт Json.NET

В наши дни приложения очень часто обращаются к веб-API по разным причинам, таким как поиск данных, служба электронной почты, служба SMS, облачная служба и т. д. Эти API могут быть нашими собственными разработанными проектами или другими сторонними API. Когда дело доходит до обмена данными между различными API, JSON является наиболее популярным и предпочтительным форматом. Когда вы работаете с приложениями ASP.NET Core и взаимодействуете с веб-API, для доступа к API на основе JSON потребуется преобразование строки данных JSON в объект .NET C# и наоборот.

Процесс преобразования объектов .NET C# в строки формата JSON называется сериализацией, а преобразование строк формата JSON в объекты .NET C# называется десериализацией. Newtonsoft Json.NET — это библиотека, которую можно использовать для сериализации и десериализации.

Json.NET — это платформа JSON для .NET от Newtonsoft. Json.NET — очень популярный и высокопроизводительный фреймворк для JSON. Json.NET поддерживает такие функции, как сериализация и десериализация любого объекта .NET C#, LINQ to Json, поддержка XML и т. д. Newtonsoft Json.NET — это высокопроизводительная и простая в использовании сторонняя библиотека. Json.NET поддерживает несколько платформ, таких как Windows, macOS, Linux, Mono и Xamarin.

Ссылка на библиотеку — https://github.com/JamesNK/Newtonsoft.Json

FluentValidation

Сегодня мы пишем общедоступные API-интерфейсы, к которым может получить доступ любой пользователь в Интернете, и разные пользователи могут предоставлять всевозможные входные данные. Сегодня кто-то с неправильным намерением может вывести наше приложение из строя, если мы не проверим входные данные должным образом. Таким образом, проверка входных данных имеет решающее значение для того, чтобы любое приложение функционировало без каких-либо проблем из-за различного ввода, предоставляемого пользователями.

Когда дело доходит до проверки входных данных в ASP.NET Core C#, наиболее предпочтительным подходом являются аннотации данных, в которых вы указываете атрибуты для каждого свойства в модели. Эти атрибуты представляют собой проверки, которые выполняются, когда модель проверяется для обработки. Этот подход не является расширяемым, а также модель может раздуться. Кроме того, эти аннотации данных в модели не соответствуют архитектуре чистого кода и принципам SOLID . Библиотеку FluentValidation можно использовать для выполнения проверки в ASP.NET Core для решения некоторых проблем.

FluentValidation — это бесплатная и популярная библиотека проверки .NET, которую можно использовать для создания правил проверки строгого типа. Правила проверки в FluentVlidations легко создавать, очищать и поддерживать. Это не раздувает вашу модель, как аннотации данных. Используя FluentValidations для проверок в ASP.NET Core, вы лучше контролируете проверки в своем приложении.

Ссылка на библиотеку — https://github.com/FluentValidation/FluentValidation

Полли

Мы будем не совсем правы, если предположим, что мы тщательно протестировали наше приложение и поэтому никаких сбоев в производственной среде не будет. Сбои приложений неизбежно происходят в производственной среде. Эти сбои приложений могут быть вызваны непредвиденными причинами, такими как высокие нагрузки, сбой оборудования, проблемы с сетью, сбои сторонних API и т. д.

Кроме того, в современном мире микросервисов требуется создавать отказоустойчивые или отказоустойчивые приложения, т. е. приложения, в которых служба всегда доступна с приемлемой функциональностью и производительностью, даже в таких условиях, как высокая нагрузка, сбои сторонних служб, сбои сети и т. д. Можно использовать Polly. для создания отказоустойчивых веб-служб или микрослужб в ASP.NET Core.

Polly — это библиотека устойчивости .NET и обработки временных сбоев, которая позволяет разработчикам выражать политики, такие как повторная попытка, автоматический выключатель, тайм-аут, изоляция переборки и откат, плавным и потокобезопасным способом.

Внедряя Polly в ASP.NET Core, мы можем создавать устойчивые приложения, которые можно спроектировать так, чтобы они функционировали бесперебойно, несмотря на частичные сбои, возникающие в приложении. В Polly для реализации отказоустойчивости в микросервисах требуется всего несколько строк кода. Polly поддерживает такие политики, как Retry, Circuit Breaker, Timeout, Bulkhead Isolation, Cache, Fallback и Policy Wrap.

Чтобы узнать больше о том, как создавать устойчивые приложения с помощью Polly в ASP.NET Core, вы можете прочитать мою статью Создание устойчивых микросервисов (веб-API) с использованием Polly в ASP.NET Core.

Ссылка на библиотеку — https://github.com/App-vNext/Polly

Свашбакл

Когда вы разработали веб-API, который будет использоваться другими приложениями, в этом случае очень важно предоставить полную подробную документацию по API. Кроме того, разработчики, использующие этот веб-API, пытаются решить бизнес-задачи, поэтому очень важно понимать его различные методы. Документация по API содержит инструкции по использованию и интеграции API в ваше приложение. Эту проблему быстрого и точного создания полной подробной полезной документации для веб-API можно решить с помощью Swagger, также известного как OpenAPI.

Swashbuckle — это библиотека с открытым исходным кодом для создания документов swagger для веб-API ASP.NET Core. Вы можете создавать красивую документацию по API, включая пользовательский интерфейс для изучения и тестирования методов действий API. Он предоставляет такие функции, как создание клиентского SDK, интерактивная документация и возможность обнаружения API. Swashbuckle также предоставляет потрясающий пользовательский интерфейс swagger, основанный на сгенерированном swagger JSON.

Swashbuckle в основном предоставляет 3 основные функции Объектная модель и промежуточное ПО Swagger для предоставления документов swagger в качестве конечной точки, функциональность для создания документов swagger JSON и встроенную версию инструментов swagger-ui.

Ссылка на библиотеку — https://github.com/domaindrivendev/Swashbuckle.AspNetCore

Проверки здоровья

В современном цифровом мире доступность приложений имеет решающее значение для функционирования бизнеса. Если ваше приложение не работает, это приводит к потере дохода, недовольным клиентам и влияет на деловую репутацию. Что касается оборудования, мы предпринимаем множество шагов, чтобы избежать сбоев, таких как серверы с балансировкой нагрузки, отказоустойчивые сайты, сайты аварийного восстановления, зеркала дисков и т. д. Что делать, если наше приложение неработоспособно, дало сбой или не работает должным образом.

Поэтому нам нужно заранее проверять работоспособность нашего приложения, т. е. нам нужно обнаруживать ошибки, если таковые имеются, в нашем приложении до того, как пользователи начнут сталкиваться с проблемами и сообщать о них. Используя библиотеки работоспособности, доступные в ASP.NET Core, мы можем определить неработоспособное приложение и принять меры для его немедленного исправления или сообщить клиенту о сбое с указанием времени, необходимого для устранения.

Библиотека проверок работоспособности в ASP.NET Core позволяет настраивать проверки, которые сообщают о работоспособности приложения. Эти проверки работоспособности могут быть представлены как конечные точки HTTP в любом приложении ASP.NET Core. Эту библиотеку можно использовать для настройки проверки работоспособности приложений, таких как память, диск, ресурсы сервера и другие зависимости приложений, такие как базы данных или конечные точки сторонних служб.

Ссылка на библиотеку — https://www.nuget.org/packages/Microsoft.Extensions.Diagnostics.HealthChecks/6.0.5

Резюме

В этой статье мы узнали, какие это 10 основных библиотек для ASP.NET Core, почему мы должны использовать эти библиотеки и какие функции предлагают эти библиотеки? Использование этих библиотек в вашем проекте позволит вам использовать проверенный код для общих функций, и вы сможете сосредоточиться только на бизнес-функциях, которые необходимо разработать как часть вашего приложения.

#dotnet #aps.net #csharp #dotnetcore

Comment Télécharger Un Fichier Dans ASP.NET Core 6

Aperçu

Le téléchargement de fichiers dans une application est une fonctionnalité à l'aide de laquelle les utilisateurs peuvent télécharger un fichier présent sur le système ou le réseau local de l'utilisateur vers l'application Web. L'application Web prend le fichier à traiter, puis si nécessaire, elle effectuera des validations sur le fichier et stockera finalement ce fichier dans le stockage configuré dans le système pour enregistrer les fichiers, c'est-à-dire dans le stockage local, le stockage distant partagé ou la base de données, etc. sur les exigences.

Le téléchargement de fichiers est une fonctionnalité importante qui peut être utilisée pour télécharger la photo de profil d'un utilisateur, les détails KYC du client comme la photo, la signature et d'autres documents justificatifs. Les téléchargements de fichiers peuvent également être utilisés pour télécharger des données où, au lieu de soumettre un seul enregistrement à la fois, les utilisateurs peuvent soumettre une liste d'enregistrements ensemble à l'aide d'un format de fichier CSV ou XML .

Dans cet article, l'accent sera mis sur la façon dont nous pouvons implémenter le téléchargement de fichiers dans ASP.NET Core MVC. L'interface IFormFile fait partie de l'espace de noms Microsoft.AspNetCore.Http peut être utilisé pour télécharger un ou plusieurs fichiers dans ASP.NET Core. ASP.NET Core prend en charge le téléchargement de fichiers à l'aide de la liaison de modèle mise en mémoire tampon pour les fichiers plus petits et de la diffusion en continu sans mise en mémoire tampon pour les fichiers volumineux.

Approches de téléchargement de fichiers

Il existe deux approches disponibles pour effectuer le téléchargement de fichiers dans ASP.NET Core

Mise en mémoire tampon

Dans cette approche, IFormFile qui est une représentation C# du fichier est utilisé pour transférer, traiter et enregistrer un fichier sur le serveur Web. Le fichier entier est lu dans un objet IFormFile, de sorte que les besoins en disque et en mémoire sur le serveur dépendent du nombre et de la taille des téléchargements de fichiers simultanés.

Tout fichier unique téléchargé s'il est supérieur à 64 Ko, le fichier est déplacé de la mémoire vers le fichier temporaire sur le disque. Si les ressources d'une application ou d'un serveur Web sont épuisées en raison d'une taille de fichier importante et d'un trop grand nombre de téléchargements de fichiers simultanés, il convient d'envisager d'utiliser l'approche de diffusion en continu dans ce cas.

Diffusion

Dans cette approche, le fichier est téléchargé dans une requête en plusieurs parties et directement traité ou enregistré par l'application. Pour le téléchargement, l'approche de streaming de fichiers consomme moins de mémoire ou d'espace disque par rapport à l'approche de mise en mémoire tampon. Le streaming devrait être l'approche préférée lors du téléchargement de fichiers plus volumineux sur le serveur Web.

Implémenter le téléchargement de fichiers dans ASP.NET Core

Aux fins du développement de l'application de démonstration, nous utiliserons Visual Studio Community 2022 Version 17.2.1 avec .NET 6.0 SDK

Approche générale

Pour la démonstration de la façon d'effectuer le téléchargement de fichiers dans ASP.NET Core, nous adopterons l'approche suivante

• Nous allons d'abord créer une application de type ASP.NET Core MVC et la nommer ProCodeGuide.Samples.FileUpload
• Nous implémenterons les deux types de téléchargements de fichiers, c'est-à-dire la liaison de modèle tamponnée pour les petits fichiers et la diffusion en continu pour les gros fichiers.
• Nous ajouterons le contrôleur requis avec le ViewModel requis qui prend le fichier en entrée et l'enregistre dans le dossier local.
• Nous allons ajouter la vue à l'aide de laquelle l'utilisateur peut sélectionner le fichier dans le système de fichiers local pour le télécharger et soumettre le fichier à la méthode d'action du contrôleur.
• Enfin, nous exécuterons l'application et testerons le téléchargement du fichier de fonctionnalité dans ASP.NET Core.

Créer un projet ASP.NET Core pour la démonstration

Créez un nouveau projet de type ASP.NET Core MVC selon les captures d'écran ci-dessous avec le nom du projet comme ProCodeGuide.Samples.FileUpload

Nous utiliserons ce projet pour démontrer les deux types, c'est-à-dire la mise en mémoire tampon et le streaming pour effectuer le téléchargement de fichiers dans ASP.NET Core

Télécharger un petit fichier avec une liaison de modèle tamponnée

Ici, nous verrons comment télécharger un petit fichier à l'aide de la liaison de modèle tamponnée. Ici, pour effectuer le téléchargement de fichiers dans ASP.NET Core, nous utiliserons une approche de liaison de modèle tamponnée qui est simple à implémenter et peut être utilisée pour télécharger de petits fichiers.

Ajouter un service

Nous ajouterons un service qui prendra un IFormFile en entrée et enregistrera le fichier soumis dans un dossier nommé UploadedFile sous le répertoire actuel de l'environnement de chemin. Ce service sera utilisé dans le contrôleur pour enregistrer le fichier publié en tant que liaison de modèle tamponnée.

Nous ajouterons le code ci-dessous pour l'interface sous Interfaces/IBufferedFileUploadService.cs

public interface IBufferedFileUploadService
{
    Task<bool> UploadFile(IFormFile file);
}

Nous ajouterons le code ci-dessous pour le service sous Services/BufferedFileUploadLocalService.cs

public class BufferedFileUploadLocalService : IBufferedFileUploadService
{
    public async Task<bool> UploadFile(IFormFile file)
    {
        string path = "";
        try
        {
            if (file.Length > 0)
            {
                path = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "UploadedFiles"));
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }
                using (var fileStream = new FileStream(Path.Combine(path, file.FileName), FileMode.Create))
                {
                    await file.CopyToAsync(fileStream);
                }
                return true;
            }
            else
            {
                return false;
            }
        }
        catch (Exception ex)
        {
            throw new Exception("File Copy Failed", ex);
        }
    }
}

Dans le code ci-dessus dans le service

• Le fichier téléchargé est accessible via la liaison de modèle à l'aide de IFormFile
• Le Path.GetFullPath est utilisé pour obtenir le chemin complet pour enregistrer le fichier téléchargé.
• Le Directory.CreateDirectory est utilisé pour créer le chemin qualifié complet s'il n'existe pas
• Le contenu du fichier dans IFormFile est accessible à l'aide de Stream.
• Le chemin d'accès avec le nom du fichier est transmis au flux de fichiers. Si le nom de fichier n'est pas spécifié, il lèvera une exception.
• Enregistre les fichiers dans le système de fichiers sur le chemin spécifié en utilisant le nom de fichier fourni par IFormFile. (cela a été fait pour garder le code simple, sinon vous devez générer un nouveau nom de fichier et ne pas utiliser le nom de fichier spécifié par l'utilisateur).

Maintenant que nous avons ajouté le service, nous allons enregistrer ce service dans le conteneur de dépendances afin qu'il puisse être injecté dans le contrôleur à l'aide du constructeur. Pour enregistrer le service dans le conteneur de dépendances, nous ajouterons la ligne de code ci-dessous dans le fichier Program.cs.

builder.Services.AddTransient<IBufferedFileUploadService, BufferedFileUploadLocalService>();

Ajouter un contrôleur

Ajoutons maintenant le contrôleur MVC pour le téléchargement de fichiers mis en mémoire tampon qui implémentera l'action get pour afficher la vue et la post-action pour gérer le téléchargement de fichiers dans ASP.NET Core.

Nous allons ajouter un contrôleur sous Controllers\BufferedFileUploadController.cs selon le code ci-dessous

public class BufferedFileUploadController : Controller
{
    readonly IBufferedFileUploadService _bufferedFileUploadService;

    public BufferedFileUploadController(IBufferedFileUploadService bufferedFileUploadService)
    {
        _bufferedFileUploadService = bufferedFileUploadService;
    }

    public IActionResult Index()
    {
        return View();
    }

    [HttpPost]
    public async Task<ActionResult> Index(IFormFile file)
    {
        try
        {
            if (await _bufferedFileUploadService.UploadFile(file))
            {
                ViewBag.Message = "File Upload Successful";
            }
            else
            {
                ViewBag.Message = "File Upload Failed";
            }
        }
        catch (Exception ex)
        {
            //Log ex
            ViewBag.Message = "File Upload Failed";
        }
        return View();
    }
}

Dans le contrôleur ci-dessus, nous avons injecté le BufferedFileUploadService via le constructeur en utilisant l'injection de dépendance.

La post-action ci-dessus prend l'entrée de fichier en tant que IFormFile et les fichiers téléchargés à l'aide de IFormFile sont mis en mémoire tampon dans la mémoire ou le disque sur le serveur avant de traiter le fichier dans le contrôleur ou le service.

Ajouter une vue

Nous ajouterons la vue pour permettre à l'utilisateur de sélectionner le fichier à télécharger et de le soumettre au serveur. Nous allons ajouter une vue sous Views\BufferedFileUpload\Index.cshtml selon le code ci-dessous

<h1>Buffered File Upload</h1>

<hr />

<form method="post" enctype="multipart/form-data">
    <input type="file" name="file" /> 
    <button type="submit">Upload File</button>
</form>
 
@if(ViewBag.Message != null)
{
    <div class="alert" style="margin-top:20px">
        @ViewBag.Message
    </div>
}

Pour effectuer le téléchargement de fichiers dans ASP.NET Core, les formulaires HTML doivent spécifier un type d'encodage (enctype) en tant que multipart/form-data.

Pour que l'élément d'entrée télécharge le fichier, vous devez spécifier le type d'entrée en tant que 'fichier'

Qu'est-ce que les données multipart/form ?

Le multipart/form-data n'est rien d'autre qu'un des en-têtes de type de contenu de la méthode post. Ce type de contenu est principalement utilisé pour envoyer les fichiers dans le cadre de la demande. Lorsque ce type de contenu est utilisé, cela signifie que chaque valeur est envoyée sous forme de bloc de données.

Exécuter et tester le code

Enfin, après avoir ajouté tout le code requis, compilez et exécutez le code. Après l'exécution, accédez au chemin /BufferedFileUpload/Index et l'écran ci-dessous devrait s'afficher.

Sur l'écran ci-dessus, vous pouvez sélectionner le fichier à télécharger, puis cliquer sur le bouton Télécharger le fichier pour effectuer le téléchargement du fichier dans ASP.NET Core. Une fois la soumission réussie, vous devriez pouvoir voir le fichier sur le serveur sous le dossier UploadedFiles

Téléchargez un fichier volumineux avec le streaming

Ici, nous verrons comment télécharger des fichiers volumineux en utilisant le streaming. Ici, pour effectuer le téléchargement de fichiers dans ASP.NET Core, nous utiliserons une approche de diffusion en continu qui peut être utilisée pour télécharger des fichiers plus volumineux.

Ajouter un service

Nous ajouterons un service qui lira l'entrée du fichier sous forme de flux et enregistrera le fichier soumis dans un dossier nommé UploadedFile sous le répertoire actuel de l'environnement de chemin. Ce service sera utilisé dans le contrôleur pour enregistrer le fichier posté sous forme de flux.

Nous ajouterons le code ci-dessous pour l'interface sous Interfaces/IStreamFileUploadService.cs

public interface IStreamFileUploadService
{
    Task<bool> UploadFile(MultipartReader reader, MultipartSection section);
}

Nous ajouterons le code ci-dessous pour le service sous Services/StreamFileUploadLocalService.cs

public class StreamFileUploadLocalService : IStreamFileUploadService
{
    public async Task<bool> UploadFile(MultipartReader reader,MultipartSection? section)
    {
        while (section != null)
        {
            var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(
                section.ContentDisposition, out var contentDisposition
            );

            if (hasContentDispositionHeader)
            {
                if (contentDisposition.DispositionType.Equals("form-data") &&
                (!string.IsNullOrEmpty(contentDisposition.FileName.Value) ||
                !string.IsNullOrEmpty(contentDisposition.FileNameStar.Value)))
                {
                    string filePath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "UploadedFiles"));
                    byte[] fileArray;
                    using (var memoryStream = new MemoryStream())
                    {
                        await section.Body.CopyToAsync(memoryStream);
                        fileArray = memoryStream.ToArray();
                    }
                    using (var fileStream = System.IO.File.Create(Path.Combine(filePath, contentDisposition.FileName.Value)))
                    {
                        await fileStream.WriteAsync(fileArray);
                    }
                }
            }
            section = await reader.ReadNextSectionAsync();
        }
        return true;
    }
}

Dans ce modèle, la liaison ne lit pas le formulaire, les paramètres liés à partir du formulaire ne se lient pas. La méthode post-action fonctionne directement avec la propriété Request. Un MultipartReader est utilisé pour lire chaque section.

Maintenant que nous avons ajouté le service, nous allons enregistrer ce service dans le conteneur de dépendances afin qu'il puisse être injecté dans le contrôleur à l'aide du constructeur. Pour enregistrer le service dans le conteneur de dépendances, nous ajouterons la ligne de code ci-dessous dans le fichier Program.cs.

builder.Services.AddTransient<IStreamFileUploadService, StreamFileUploadLocalService>();

Ajouter un contrôleur

Ajoutons maintenant le contrôleur MVC pour le téléchargement du fichier de flux qui implémentera l'action get pour afficher la vue et la post-action pour gérer le téléchargement du fichier dans ASP.NET Core.

Nous allons ajouter un contrôleur sous Controllers\StreamFileUploadController.cs selon le code ci-dessous

public class StreamFileUploadController : Controller
{
    readonly IStreamFileUploadService _streamFileUploadService;

    public StreamFileUploadController(IStreamFileUploadService streamFileUploadService)
    {
        _streamFileUploadService = streamFileUploadService;
    }

    [HttpGet]
    public IActionResult Index()
    {
        return View();
    }

    [ActionName("Index")]
    [HttpPost]
    public async Task<IActionResult> SaveFileToPhysicalFolder()
    {
        var boundary = HeaderUtilities.RemoveQuotes(
            MediaTypeHeaderValue.Parse(Request.ContentType).Boundary
        ).Value;

        var reader = new MultipartReader(boundary, Request.Body);

        var section = await reader.ReadNextSectionAsync();

        string response = string.Empty;
        try
        {
            if (await _streamFileUploadService.UploadFile(reader, section))
            {
                ViewBag.Message = "File Upload Successful";
            }
            else
            {
                ViewBag.Message = "File Upload Failed";
            }
        }
        catch (Exception ex)
        {
            //Log ex
            ViewBag.Message = "File Upload Failed";
        }
        return View();
    }
}

Dans le contrôleur ci-dessus, nous avons injecté le StreamFileUploadService via le constructeur en utilisant l'injection de dépendance.

La post-action ci-dessus lit l'entrée de fichier à partir du flux et les fichiers téléchargés à l'aide du flux ne sont pas mis en mémoire tampon ou sur le disque du serveur avant de traiter le fichier dans le contrôleur ou le service. Le fichier d'entrée du flux ne peut être lu qu'une seule fois.

L'objet lecteur de type Microsoft.AspNetCore.WebUtilities.MultipartReader est créé pour lire un flux de sous-parties à partir des données multiparties.

Ajouter une vue

Nous ajouterons la vue pour permettre à l'utilisateur de sélectionner le fichier à télécharger et de le soumettre au serveur. Nous allons ajouter une vue sous Views\StreamFileUpload\Index.cshtml selon le code ci-dessous

<h1>Stream File Upload</h1>

<hr />

<div>
    <form asp-route="StreamFileUpload/Index"  enctype="multipart/form-data" method="POST">
        <input type="file" name="file" /> 
        <button type="submit" class="btn btn-primary">Save</button>
    </form>
</div>

@if(ViewBag.Message != null)
{
    <div class="alert" style="margin-top:20px">
        @ViewBag.Message
    </div>
}

Exécuter et tester le code

Enfin, après avoir ajouté tous les services requis, le contrôleur et la vue, compilez et exécutez le code. Après l'exécution, accédez au chemin /StreamFileUpload/Index et l'écran ci-dessous devrait s'afficher.

Sur l'écran ci-dessus, vous pouvez sélectionner le fichier à télécharger, puis cliquer sur le bouton Télécharger le fichier pour effectuer le téléchargement du fichier dans ASP.NET Core. Une fois la soumission réussie, vous devriez pouvoir voir le fichier sur le serveur sous le dossier UploadedFiles

Options de stockage de fichiers

Dans notre démonstration ci-dessus, nous enregistrons le fichier dans un système de fichiers local. Néanmoins, il existe également d'autres options disponibles lorsqu'il s'agit de sélectionner une destination pour le stockage d'un fichier sur le serveur Web. Les options de stockage communes disponibles pour les fichiers sont les suivantes

• Système de fichiers – Dans cette option, le fichier est enregistré sur le stockage physique localement ou sur le partage réseau.
• Base de données – Dans cette option, le fichier est enregistré dans la table de la base de données dans l'une des colonnes sous forme de BLOB ou de données brutes.
• Cloud – Dans cette option, le fichier est enregistré dans le cloud à l'aide d'un service fourni par le fournisseur de cloud pour le stockage de fichiers.

Les options ci-dessus sont également prises en charge pour le téléchargement de fichiers dans ASP.NET Core. Vous trouverez ci-dessous quelques points à prendre en compte lors du choix des options de stockage

• Pour les téléchargements de fichiers plus petits, la base de données est normalement une option plus rapide par rapport au stockage physique
• Pour les téléchargements de fichiers plus volumineux, le stockage physique s'avère moins économique que le stockage de base de données.
• Une base de données peut s'avérer une option efficace pour le stockage de fichiers, car lorsque nous sélectionnons l'enregistrement dans la base de données, nous pouvons également sélectionner les données du fichier avec l'enregistrement.
• De plus, lorsque vous stockez un fichier dans la base de données, vous pouvez insérer un enregistrement avec les données du fichier dans le cadre de la même transaction de base de données, sinon si un fichier se trouve dans un magasin physique et que l'enregistrement se trouve dans une base de données, s'il n'est pas conçu correctement, il peut créer quelques incohérences entre l'enregistrement et les données du fichier.
• Lorsque vous stockez des fichiers plus volumineux dans la base de données, la taille de la base de données augmente considérablement, ce qui rend les sauvegardes et la restauration de la base de données un processus lourd et chronophage.
• Les limites de la base de données peuvent imposer certaines restrictions sur la taille maximale du fichier autorisée pour le stockage.
• Dans le cas d'un stockage physique, l'application qui tente d'enregistrer des fichiers sur le chemin physique doit disposer d'une autorisation de lecture-écriture sur l'emplacement de stockage.
• Le stockage dans le cloud offre souvent une meilleure stabilité et résilience que les solutions sur site
• Le stockage physique est généralement moins économique que le stockage de base de données et le stockage de base de données peut également s'avérer moins coûteux que le service de stockage de données en nuage.

Considérations de sécurité

Il serait utile que vous soyez toujours prudent lorsque vous fournissez une fonctionnalité de téléchargement de fichiers dans votre application, car des attaquants pourraient essayer d'exploiter l'application via cette fonctionnalité de téléchargement de fichiers dans ASP.NET Core. Les attaquants peuvent essayer de faire tomber le système en téléchargeant un fichier infecté par des virus ou des logiciels malveillants ou peuvent tenter de s'introduire dans le système pour accéder au réseau ou aux serveurs.

Vous trouverez ci-dessous les mesures que vous devriez envisager car elles vous aideront à empêcher les attaquants de tenter avec succès de briser le système ou de pénétrer dans le système.

• Limitez la taille maximale du fichier pouvant être téléchargé
• Si le stockage physique est utilisé, les fichiers téléchargés doivent être copiés sur un lecteur non système
• Copiez de préférence tous les fichiers téléchargés dans un emplacement dédié afin qu'il soit plus facile d'imposer des droits d'accès à cet emplacement.
• Lorsque vous attribuez une autorisation de lecture-écriture au disque pour copier des fichiers téléchargés, assurez-vous de ne pas accorder d'autorisations d'exécution.
• Vous devez copier les fichiers téléchargés dans un répertoire différent du répertoire dans lequel l'application est déployée.
• En premier lieu, ne permettez pas à un utilisateur de décider du nom de fichier du fichier en cours de téléchargement ou si l'utilisateur est autorisé à sélectionner un nom de fichier, assurez-vous d'avoir toute la validation du fichier en place afin que les mots-clés ou caractères indésirables soient évité
• Validez également les extensions de fichier afin que seuls les types de fichiers autorisés soient autorisés pour le téléchargement.
• Effectuez une recherche de virus\maclware sur tous les fichiers en cours de téléchargement. Pour cela, vous pouvez utiliser une API tierce pour la recherche de virus/programmes malveillants sur le contenu téléchargé.
• Assurez-vous qu'en dehors des validations côté client, vous effectuez également toutes les validations sur le fichier côté serveur également

Sommaire

Nous avons appris comment effectuer le téléchargement de fichiers dans l'application ASP.NET Core pour les types de mise en mémoire tampon et de flux. L'approche tamponnée est préférable dans les scénarios où la taille du fichier est plus petite et le nombre de soumissions de fichiers simultanées est également inférieur.

L'approche par flux doit être utilisée lorsque nous soumettons des fichiers volumineux ou lorsque le nombre de soumissions de fichiers simultanées est plus élevé. Le type de flux aidera à réduire les besoins en mémoire et en disque sur le serveur.

Lien : https://procodeguide.com/programming/file-upload-in-aspnet-core/

#dotnet #aps.net #csharp #dotnetcore

Cách Tải Lên Tệp Trong ASP.NET Core 6

Tổng quan

Tải lên tệp trong ứng dụng là một tính năng sử dụng mà người dùng có thể tải tệp có trên hệ thống cục bộ hoặc mạng của người dùng lên ứng dụng web. Ứng dụng web lấy tệp để xử lý, sau đó nếu được yêu cầu, nó sẽ thực hiện một số xác thực trên tệp và cuối cùng sẽ lưu tệp này trong bộ lưu trữ được định cấu hình trong hệ thống để lưu tệp, tức là trong bộ nhớ cục bộ, bộ lưu trữ từ xa được chia sẻ hoặc cơ sở dữ liệu, v.v. về các yêu cầu.

Tải lên tệp là một tính năng quan trọng có thể được sử dụng để tải lên ảnh Hồ sơ của người dùng, các chi tiết KYC của khách hàng như ảnh, chữ ký và các tài liệu hỗ trợ khác. Tải lên tệp cũng có thể được sử dụng để tải lên dữ liệu, thay vì gửi một bản ghi tại một thời điểm, người dùng có thể gửi danh sách các bản ghi cùng nhau bằng cách sử dụng định dạng tệp CSV hoặc XML .

Trong bài viết này, trọng tâm chính sẽ là cách chúng ta có thể triển khai tải lên tệp trong ASP.NET Core MVC. Giao diện IFormFile là một phần của không gian tên Microsoft.AspNetCore.Http có thể được sử dụng để tải lên một hoặc nhiều tệp trong ASP.NET Core. ASP.NET Core hỗ trợ tải lên tệp bằng cách sử dụng liên kết mô hình đệm cho các tệp nhỏ hơn và phát trực tuyến không đệm cho các tệp lớn.

Các Phương pháp Tải lên Tệp

Có hai cách tiếp cận có sẵn để thực hiện tải lên tệp trong ASP.NET Core

Đệm

Trong cách tiếp cận này, IFormFile là đại diện C # của tệp được sử dụng để truyền, xử lý và lưu tệp trên máy chủ web. Toàn bộ tệp được đọc thành một đối tượng IFormFile nên yêu cầu về đĩa và bộ nhớ trên máy chủ sẽ phụ thuộc vào số lượng và kích thước của các tệp tải lên đồng thời.

Bất kỳ tệp đơn lẻ nào đang được tải lên nếu lớn hơn 64KB thì tệp đó sẽ được chuyển từ bộ nhớ sang tệp tạm thời trên đĩa. Nếu một ứng dụng hoặc tài nguyên máy chủ web đang bị cạn kiệt do kích thước tệp lớn và quá nhiều tệp tải lên đồng thời thì bạn nên xem xét sử dụng phương pháp phát trực tuyến trong trường hợp đó.

Truyền trực tuyến

Theo cách tiếp cận này, tệp được tải lên theo yêu cầu nhiều phần và được ứng dụng xử lý hoặc lưu trực tiếp. Đối với việc tải tệp lên, phương pháp truyền trực tuyến tiêu tốn ít bộ nhớ hoặc không gian đĩa hơn so với phương pháp đệm. Truyền trực tuyến nên là cách tiếp cận ưu tiên khi tải lên các tệp lớn hơn trên máy chủ web.

Triển khai Tải lên tệp trong ASP.NET Core

Với mục đích phát triển ứng dụng trình diễn, chúng tôi sẽ sử dụng Cộng đồng Visual Studio 2022 Phiên bản 17.2.1 với .NET 6.0 SDK

Cách tiếp cận tổng thể

Để trình bày về cách thực hiện tải lên tệp trong ASP.NET Core, chúng tôi sẽ thực hiện phương pháp sau

• Đầu tiên chúng ta sẽ tạo một ứng dụng kiểu ASP.NET Core MVC và đặt tên là ProCodeGuide.
• Chúng tôi sẽ thực hiện cả hai loại tải lên tệp tức là liên kết mô hình đệm cho các tệp nhỏ và Truyền trực tuyến cho các tệp lớn.
• Chúng tôi sẽ thêm bộ điều khiển cần thiết với ViewModel được yêu cầu để lấy tệp làm đầu vào và lưu vào thư mục cục bộ.
• Chúng tôi sẽ thêm chế độ xem bằng cách sử dụng mà người dùng có thể chọn tệp từ hệ thống tệp cục bộ để tải lên và gửi tệp tới phương thức hành động của bộ điều khiển.
• Cuối cùng, chúng tôi sẽ chạy ứng dụng và kiểm tra tải lên tệp tính năng trong ASP.NET Core.

Tạo dự án cốt lõi ASP.NET để trình diễn

Tạo một dự án mới kiểu ASP.NET Core MVC theo ảnh chụp màn hình được hiển thị bên dưới với tên của dự án là ProCodeGuide.

Chúng tôi sẽ sử dụng dự án này để chứng minh cả hai loại tức là được đệm và truyền trực tuyến để thực hiện tải lên tệp trong ASP.NET Core

Tải lên tệp nhỏ với ràng buộc mô hình đệm

Ở đây chúng ta sẽ thấy cách tải lên một tệp nhỏ bằng cách sử dụng ràng buộc mô hình đệm. Ở đây để thực hiện tải lên tệp trong ASP.NET Core, chúng tôi sẽ sử dụng phương pháp ràng buộc mô hình đệm, dễ thực hiện và có thể được sử dụng để tải lên các tệp nhỏ.

Thêm dịch vụ

Chúng tôi sẽ thêm một dịch vụ sẽ lấy IFormFile làm đầu vào và lưu tệp được gửi vào thư mục có tên UploadedFile trong thư mục hiện tại của môi trường đường dẫn. Dịch vụ này sẽ được sử dụng trong bộ điều khiển để lưu tệp được đăng dưới dạng ràng buộc mô hình đệm.

Chúng tôi sẽ thêm mã bên dưới cho giao diện trong Interfaces / IBufferedFileUploadService.cs

public interface IBufferedFileUploadService
{
    Task<bool> UploadFile(IFormFile file);
}

Chúng tôi sẽ thêm mã bên dưới cho dịch vụ trong Services / BufferedFileUploadLocalService.cs

public class BufferedFileUploadLocalService : IBufferedFileUploadService
{
    public async Task<bool> UploadFile(IFormFile file)
    {
        string path = "";
        try
        {
            if (file.Length > 0)
            {
                path = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "UploadedFiles"));
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }
                using (var fileStream = new FileStream(Path.Combine(path, file.FileName), FileMode.Create))
                {
                    await file.CopyToAsync(fileStream);
                }
                return true;
            }
            else
            {
                return false;
            }
        }
        catch (Exception ex)
        {
            throw new Exception("File Copy Failed", ex);
        }
    }
}

Trong đoạn mã trên trong dịch vụ

• Tệp đã tải lên được truy cập thông qua liên kết mô hình bằng IFormFile
• Path.GetFullPath được sử dụng để lấy đường dẫn đủ điều kiện để lưu tệp đã tải lên.
• Directory.CreateDirectory được sử dụng để tạo đường dẫn đủ điều kiện nếu nó không tồn tại
• Nội dung của tệp trong IFormFile được truy cập bằng Luồng.
• Đường dẫn cùng với tên tệp được chuyển đến Dòng tệp. Nếu tên tệp không được chỉ định thì nó sẽ ném ra một ngoại lệ.
• Lưu các tệp vào hệ thống tệp trên đường dẫn được chỉ định bằng cách sử dụng tên tệp do IFormFile cung cấp. (điều này đã được thực hiện để giữ cho mã đơn giản, nếu không bạn nên tạo một tên tệp mới và không sử dụng tên tệp do người dùng chỉ định).

Bây giờ chúng ta đã thêm dịch vụ, chúng ta sẽ đăng ký dịch vụ này trong vùng chứa phụ thuộc để nó có thể được đưa vào bộ điều khiển bằng cách sử dụng phương thức khởi tạo. Để đăng ký dịch vụ trong vùng chứa phụ thuộc, chúng tôi sẽ thêm dòng mã bên dưới vào tệp Program.cs.

builder.Services.AddTransient<IBufferedFileUploadService, BufferedFileUploadLocalService>();

Thêm bộ điều khiển

Bây giờ, hãy thêm bộ điều khiển MVC để tải lên tệp được đệm sẽ thực hiện hành động nhận để hiển thị chế độ xem và hành động hậu để xử lý tải tệp lên trong ASP.NET Core.

Chúng tôi sẽ thêm một bộ điều khiển trong Controllers \ BufferedFileUploadController.cs theo mã được hiển thị bên dưới

public class BufferedFileUploadController : Controller
{
    readonly IBufferedFileUploadService _bufferedFileUploadService;

    public BufferedFileUploadController(IBufferedFileUploadService bufferedFileUploadService)
    {
        _bufferedFileUploadService = bufferedFileUploadService;
    }

    public IActionResult Index()
    {
        return View();
    }

    [HttpPost]
    public async Task<ActionResult> Index(IFormFile file)
    {
        try
        {
            if (await _bufferedFileUploadService.UploadFile(file))
            {
                ViewBag.Message = "File Upload Successful";
            }
            else
            {
                ViewBag.Message = "File Upload Failed";
            }
        }
        catch (Exception ex)
        {
            //Log ex
            ViewBag.Message = "File Upload Failed";
        }
        return View();
    }
}

Trong bộ điều khiển trên, chúng tôi đã chèn BufferedFileUploadService thông qua phương thức khởi tạo bằng cách sử dụng chèn phụ thuộc.

Hành động sau ở trên nhận đầu vào tệp dưới dạng IFormFile và các tệp được tải lên bằng IFormFile được lưu vào bộ đệm trong bộ nhớ hoặc đĩa trên máy chủ trước khi xử lý tệp trong bộ điều khiển hoặc dịch vụ.

Thêm chế độ xem

Chúng tôi sẽ thêm chế độ xem để cho phép người dùng chọn tệp để tải lên và gửi tệp đó lên máy chủ. Chúng tôi sẽ thêm một chế độ xem trong Views \ BufferedFileUpload \ Index.cshtml theo mã được hiển thị bên dưới

<h1>Buffered File Upload</h1>

<hr />

<form method="post" enctype="multipart/form-data">
    <input type="file" name="file" /> 
    <button type="submit">Upload File</button>
</form>
 
@if(ViewBag.Message != null)
{
    <div class="alert" style="margin-top:20px">
        @ViewBag.Message
    </div>
}

Để thực hiện tải lên tệp trong ASP.NET Core, biểu mẫu HTML phải chỉ định kiểu mã hóa (enctype) là đa phần / biểu mẫu-dữ liệu.

Để tạo phần tử đầu vào để tải tệp lên, bạn cần chỉ định loại đầu vào là 'tệp'

Multiart / form-data là gì?

Multiart / form-data không là gì khác ngoài một trong những tiêu đề kiểu nội dung của phương thức post. Loại nội dung này chủ yếu được sử dụng để gửi các tệp như một phần của yêu cầu. Khi loại nội dung này được sử dụng, nghĩa là mỗi giá trị được gửi dưới dạng một khối dữ liệu.

Chạy và kiểm tra mã

Cuối cùng sau khi thêm tất cả các biên dịch mã cần thiết và thực thi mã. Sau khi thực hiện, điều hướng đến đường dẫn / BufferedFileUpload / Index và nó sẽ hiển thị màn hình như bên dưới.

Trên màn hình trên, bạn có thể chọn tệp cần tải lên rồi nhấp vào nút Tải tệp lên để thực hiện tải tệp lên trong ASP.NET Core. Khi gửi thành công, bạn sẽ có thể xem tệp trên máy chủ trong thư mục UploadedFiles

Tải lên tệp lớn bằng tính năng phát trực tuyến

Ở đây chúng ta sẽ thấy cách tải lên các tệp lớn bằng cách sử dụng Streaming. Ở đây để thực hiện tải lên tệp trong ASP.NET Core, chúng tôi sẽ sử dụng phương pháp truyền trực tuyến có thể được sử dụng để tải lên các tệp lớn hơn.

Thêm dịch vụ

Chúng tôi sẽ thêm một dịch vụ sẽ đọc đầu vào tệp dưới dạng một luồng và lưu tệp được gửi vào thư mục có tên UploadedFile trong thư mục hiện tại của môi trường đường dẫn. Dịch vụ này sẽ được sử dụng trong bộ điều khiển để lưu tệp được đăng dưới dạng luồng.

Chúng tôi sẽ thêm mã bên dưới cho giao diện trong Interfaces / IStreamFileUploadService.cs

public interface IStreamFileUploadService
{
    Task<bool> UploadFile(MultipartReader reader, MultipartSection section);
}

Chúng tôi sẽ thêm mã bên dưới cho dịch vụ trong Services / StreamFileUploadLocalService.cs

public class StreamFileUploadLocalService : IStreamFileUploadService
{
    public async Task<bool> UploadFile(MultipartReader reader,MultipartSection? section)
    {
        while (section != null)
        {
            var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(
                section.ContentDisposition, out var contentDisposition
            );

            if (hasContentDispositionHeader)
            {
                if (contentDisposition.DispositionType.Equals("form-data") &&
                (!string.IsNullOrEmpty(contentDisposition.FileName.Value) ||
                !string.IsNullOrEmpty(contentDisposition.FileNameStar.Value)))
                {
                    string filePath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "UploadedFiles"));
                    byte[] fileArray;
                    using (var memoryStream = new MemoryStream())
                    {
                        await section.Body.CopyToAsync(memoryStream);
                        fileArray = memoryStream.ToArray();
                    }
                    using (var fileStream = System.IO.File.Create(Path.Combine(filePath, contentDisposition.FileName.Value)))
                    {
                        await fileStream.WriteAsync(fileArray);
                    }
                }
            }
            section = await reader.ReadNextSectionAsync();
        }
        return true;
    }
}

Trong liên kết mô hình này không đọc biểu mẫu, các tham số được ràng buộc từ biểu mẫu không liên kết. Phương thức hậu hành động hoạt động trực tiếp với thuộc tính Yêu cầu. MultipartReader được sử dụng để đọc từng phần.

Bây giờ chúng ta đã thêm dịch vụ, chúng ta sẽ đăng ký dịch vụ này trong vùng chứa phụ thuộc để nó có thể được đưa vào bộ điều khiển bằng cách sử dụng phương thức khởi tạo. Để đăng ký dịch vụ trong vùng chứa phụ thuộc, chúng tôi sẽ thêm dòng mã bên dưới vào tệp Program.cs.

builder.Services.AddTransient<IStreamFileUploadService, StreamFileUploadLocalService>();

Thêm bộ điều khiển

Bây giờ chúng ta hãy thêm bộ điều khiển MVC để tải lên tệp luồng sẽ thực hiện hành động nhận để hiển thị chế độ xem và hành động hậu để xử lý tải tệp lên trong ASP.NET Core.

Chúng tôi sẽ thêm một bộ điều khiển trong Controllers \ StreamFileUploadController.cs theo mã được hiển thị bên dưới

public class StreamFileUploadController : Controller
{
    readonly IStreamFileUploadService _streamFileUploadService;

    public StreamFileUploadController(IStreamFileUploadService streamFileUploadService)
    {
        _streamFileUploadService = streamFileUploadService;
    }

    [HttpGet]
    public IActionResult Index()
    {
        return View();
    }

    [ActionName("Index")]
    [HttpPost]
    public async Task<IActionResult> SaveFileToPhysicalFolder()
    {
        var boundary = HeaderUtilities.RemoveQuotes(
            MediaTypeHeaderValue.Parse(Request.ContentType).Boundary
        ).Value;

        var reader = new MultipartReader(boundary, Request.Body);

        var section = await reader.ReadNextSectionAsync();

        string response = string.Empty;
        try
        {
            if (await _streamFileUploadService.UploadFile(reader, section))
            {
                ViewBag.Message = "File Upload Successful";
            }
            else
            {
                ViewBag.Message = "File Upload Failed";
            }
        }
        catch (Exception ex)
        {
            //Log ex
            ViewBag.Message = "File Upload Failed";
        }
        return View();
    }
}

Trong bộ điều khiển trên, chúng tôi đã chèn StreamFileUploadService thông qua phương thức khởi tạo bằng cách sử dụng chèn phụ thuộc.

Hành động sau ở trên đọc đầu vào tệp từ luồng và các tệp được tải lên bằng luồng không được lưu vào bộ đệm trong bộ nhớ hoặc đĩa trên máy chủ trước khi xử lý tệp trong bộ điều khiển hoặc dịch vụ. Đầu vào tệp từ luồng chỉ có thể được đọc một lần.

Đối tượng trình đọc kiểu Microsoft.AspNetCore.WebUtilities.MultipartReader được tạo để đọc một luồng các phần con từ dữ liệu nhiều phần.

Thêm chế độ xem

Chúng tôi sẽ thêm chế độ xem để cho phép người dùng chọn tệp để tải lên và gửi tệp đó lên máy chủ. Chúng tôi sẽ thêm một chế độ xem trong Views \ StreamFileUpload \ Index.cshtml theo mã được hiển thị bên dưới

<h1>Stream File Upload</h1>

<hr />

<div>
    <form asp-route="StreamFileUpload/Index"  enctype="multipart/form-data" method="POST">
        <input type="file" name="file" /> 
        <button type="submit" class="btn btn-primary">Save</button>
    </form>
</div>

@if(ViewBag.Message != null)
{
    <div class="alert" style="margin-top:20px">
        @ViewBag.Message
    </div>
}

Chạy và kiểm tra mã

Cuối cùng, sau khi thêm tất cả các dịch vụ cần thiết, bộ điều khiển và chế độ xem, biên dịch và thực thi mã. Sau khi thực hiện điều hướng đến đường dẫn / StreamFileUpload / Index và nó sẽ hiển thị màn hình như bên dưới

Trên màn hình trên, bạn có thể chọn tệp cần tải lên rồi nhấp vào nút Tải tệp lên để thực hiện tải tệp lên trong ASP.NET Core. Khi gửi thành công, bạn sẽ có thể xem tệp trên máy chủ trong thư mục UploadedFiles

Tùy chọn lưu trữ tệp

Trong phần trình bày ở trên, chúng tôi lưu tệp vào hệ thống tệp cục bộ. Tuy nhiên, cũng có các tùy chọn khác có sẵn khi chọn đích để lưu trữ tệp trên máy chủ web. Các tùy chọn lưu trữ phổ biến có sẵn cho các tệp như sau

• Hệ thống tệp - Trong tùy chọn này, tệp được lưu trên bộ nhớ vật lý cục bộ hoặc trên mạng chia sẻ.
• Cơ sở dữ liệu - Trong tùy chọn này, tệp được lưu trong bảng cơ sở dữ liệu ở một trong các cột dưới dạng BLOB hoặc dữ liệu thô.
• Đám mây - Trong tùy chọn này, tệp được lưu trên đám mây bằng cách sử dụng một số dịch vụ do nhà cung cấp đám mây cung cấp để lưu trữ tệp.

Các tùy chọn trên cũng được hỗ trợ để tải lên tệp trong ASP.NET Core. Dưới đây là một số điểm cần được xem xét khi đánh dấu sự lựa chọn cho các tùy chọn lưu trữ

• Đối với các tệp tải lên nhỏ hơn, cơ sở dữ liệu thường là một tùy chọn nhanh hơn so với bộ nhớ vật lý
• Để tải lên tệp lớn hơn, lưu trữ vật lý hoạt động kém tiết kiệm hơn so với lưu trữ cơ sở dữ liệu.
• Cơ sở dữ liệu có thể trở thành một tùy chọn hiệu quả để lưu trữ tệp vì khi chúng ta chọn bản ghi từ cơ sở dữ liệu, chúng ta cũng có thể chọn dữ liệu tệp cùng với bản ghi.
• Ngoài ra, khi bạn lưu trữ tệp trong cơ sở dữ liệu thì bạn có thể chèn bản ghi cùng với dữ liệu tệp như một phần của cùng một giao dịch cơ sở dữ liệu khác nếu tệp nằm trong cửa hàng thực và bản ghi nằm trong cơ sở dữ liệu thì nếu không được thiết kế đúng cách, nó có thể tạo một số mâu thuẫn giữa bản ghi và dữ liệu tệp.
• Khi bạn lưu trữ các tệp lớn hơn trong cơ sở dữ liệu thì kích thước cơ sở dữ liệu tăng lên đáng kể khiến cho việc sao lưu và khôi phục cơ sở dữ liệu trở thành một quá trình nặng nhọc và tốn thời gian.
• Các giới hạn cơ sở dữ liệu có thể đưa ra một số hạn chế về kích thước tối đa của tệp được phép lưu trữ.
• Trong trường hợp lưu trữ vật lý, ứng dụng đang cố gắng lưu tệp trên đường dẫn vật lý phải có quyền đọc-ghi đối với vị trí lưu trữ.
• Lưu trữ đám mây thường cung cấp độ ổn định và khả năng phục hồi tốt hơn so với các giải pháp tại chỗ
• Lưu trữ vật lý ở mức độ chung ít tiết kiệm hơn so với lưu trữ cơ sở dữ liệu và lưu trữ cơ sở dữ liệu cũng có thể hoạt động ít tốn kém hơn so với dịch vụ lưu trữ dữ liệu đám mây.

Cân nhắc về Bảo mật

Sẽ hữu ích nếu bạn luôn thận trọng khi cung cấp tính năng tải tệp lên trong ứng dụng của mình vì những kẻ tấn công có thể cố gắng khai thác ứng dụng thông qua tính năng tải tệp lên trong ASP.NET Core này. Những kẻ tấn công có thể cố gắng phá hủy hệ thống bằng cách tải lên một tệp bị nhiễm vi-rút hoặc phần mềm độc hại hoặc có thể cố gắng đột nhập vào hệ thống để giành quyền truy cập vào mạng hoặc máy chủ.

Dưới đây là các biện pháp mà bạn nên xem xét vì những biện pháp này sẽ giúp bạn ngăn chặn những kẻ tấn công thực hiện thành công một nỗ lực phá vỡ hệ thống hoặc đột nhập vào hệ thống

• Đặt giới hạn về kích thước tối đa của tệp có thể được tải lên
• Nếu sử dụng bộ nhớ vật lý, các tệp đã tải lên phải được sao chép vào ổ đĩa không thuộc hệ thống
• Ưu tiên sao chép tất cả các tệp tải lên vào một vị trí chuyên dụng để dễ dàng áp đặt quyền truy cập vào vị trí đó hơn.
• Khi bạn chỉ định quyền đọc-ghi cho đĩa để sao chép các tệp đã tải lên, hãy đảm bảo rằng cuối cùng bạn sẽ không cấp quyền thực thi.
• Bạn nên sao chép các tệp đã tải lên vào một thư mục khác với thư mục mà ứng dụng được triển khai.
• Ngay từ đầu, không cho phép người dùng quyết định tên tệp của tệp đang được tải lên hoặc nếu người dùng được phép chọn tên tệp thì hãy đảm bảo bạn có tất cả xác thực cho tệp tại chỗ để các từ khóa hoặc ký tự không mong muốn. tránh
• Ngoài ra, hãy xác thực phần mở rộng tệp để chỉ những loại tệp được phép mới được phép tải lên.
• Thực hiện kiểm tra vi-rút \ maclware trên tất cả các tệp đang được tải lên. Đối với điều này, bạn có thể sử dụng API của bên thứ ba để quét vi rút / phần mềm độc hại trên nội dung đã tải lên.
• Đảm bảo rằng ngoài xác thực phía máy khách, bạn cũng thực hiện tất cả xác thực trên tệp ở phía máy chủ

Bản tóm tắt

Chúng tôi đã tìm hiểu về cách thực hiện tải lên tệp trong Ứng dụng ASP.NET Core cho các loại luồng và bộ đệm. Phương pháp đệm sẽ thích hợp hơn trong các tình huống mà kích thước tệp nhỏ hơn và số lần gửi tệp đồng thời cũng ít hơn.

Phương pháp tiếp cận luồng nên được sử dụng khi chúng tôi đang gửi các tệp lớn hoặc số lượng gửi tệp đồng thời ở phía cao hơn. Loại luồng sẽ giúp giảm yêu cầu về bộ nhớ và đĩa trên máy chủ.

Liên kết: https://procodeguide.com/programming/file-upload-in-aspnet-core/

#dotnet # aps.net #csharp #dotnetcore

如何在 ASP.NET Core 6 中上傳文件

概述

應用程序中的文件上傳是一種功能，用戶可以使用該功能將用戶本地系統或網絡上存在的文件上傳到 Web 應用程序。Web 應用程序處理文件，然後如果需要，它將對文件執行一些驗證，最後將此文件存儲在系統中配置的存儲中以保存文件，即存儲在本地存儲、共享遠程存儲或數據庫等關於要求。

文件上傳是一項重要功能，可用於上傳用戶的個人資料圖片、客戶 KYC 詳細信息（如照片、簽名和其他支持文件）。文件上傳也可用於上傳數據，而不是一次提交單個記錄，用戶可以使用 CSV 或XML文件格式一起提交記錄列表。

在本文中，我們將主要關注如何在 ASP.NET Core MVC 中實現文件上傳。IFormFile 接口是 Microsoft.AspNetCore.Http 命名空間的一部分，可用於在 ASP.NET Core 中上傳一個或多個文件。ASP.NET Core 支持對較小文件使用緩沖模型綁定和對大文件使用無緩衝流式傳輸的文件上傳。

文件上傳方法

有兩種方法可用於在 ASP.NET Core 中執行文件上傳

緩衝

在這種方法中，作為文件的 C# 表示形式的 IFormFile 用於在網絡服務器上傳輸、處理和保存文件。整個文件被讀入 IFormFile 對象，因此服務器上的磁盤和內存需求將取決於並發文件上傳的數量和大小。

如果上傳的任何單個文件大於 64KB，則該文件將從內存移動到磁盤上的臨時文件。如果應用程序或 Web 服務器資源由於文件大小過大和並發文件上傳過多而耗盡，那麼在這種情況下應考慮使用流式處理方法。

流媒體

在這種方法中，文件以多部分請求的形式上傳，並由應用程序直接處理或保存。與緩衝方法相比，上傳文件流方法消耗更少的內存或磁盤空間。在網絡服務器上上傳較大的文件時，流媒體應該是首選方法。

在 ASP.NET Core 中實現文件上傳

為了開發演示應用程序，我們將使用帶有 .NET 6.0 SDK 的 Visual Studio Community 2022 版本 17.2.1

整體方法

為了演示如何在 ASP.NET Core 中進行文件上傳，我們將採用以下方法

• 我們將首先創建一個 ASP.NET Core MVC 類型的應用程序並將其命名為 ProCodeGuide.Samples.FileUpload
• 我們將實現兩種類型的文件上傳，即小文件的緩沖模型綁定和大文件的流式傳輸。
• 我們將使用所需的 ViewModel 添加所需的控制器，該控制器將文件作為輸入並將其保存到本地文件夾。
• 我們將添加視圖，用戶可以使用該視圖從本地文件系統中選擇文件進行上傳並將文件提交給控制器操作方法。
• 最後，我們將運行應用程序並在 ASP.NET Core 中測試功能文件上傳。

創建用於演示的 ASP.NET Core 項目

根據下面顯示的屏幕截圖創建一個 ASP.NET Core MVC 類型的新項目，項目名稱為 ProCodeGuide.Samples.FileUpload

我們將使用這個項目來演示這兩種類型，即緩沖和流，以在 ASP.NET Core 中執行文件上傳

上傳帶有緩沖模型綁定的小文件

在這裡，我們將看到如何使用緩沖模型綁定上傳小文件。在這裡，為了在 ASP.NET Core 中執行文件上傳，我們將使用一種易於實現且可用於上傳小文件的緩沖模型綁定方法。

添加服務

我們將添加一個將 IFormFile 作為輸入的服務，並將提交的文件保存到路徑環境當前目錄下名為 UploadedFile 的文件夾中。該服務將在控制器中用於將發布的文件保存為緩沖模型綁定。

我們將在 Interfaces/IBufferedFileUploadService.cs 下為接口添加以下代碼

public interface IBufferedFileUploadService
{
    Task<bool> UploadFile(IFormFile file);
}

我們將在 Services/BufferedFileUploadLocalService.cs 下為服務添加以下代碼

public class BufferedFileUploadLocalService : IBufferedFileUploadService
{
    public async Task<bool> UploadFile(IFormFile file)
    {
        string path = "";
        try
        {
            if (file.Length > 0)
            {
                path = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "UploadedFiles"));
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }
                using (var fileStream = new FileStream(Path.Combine(path, file.FileName), FileMode.Create))
                {
                    await file.CopyToAsync(fileStream);
                }
                return true;
            }
            else
            {
                return false;
            }
        }
        catch (Exception ex)
        {
            throw new Exception("File Copy Failed", ex);
        }
    }
}

在上面的代碼中的服務

• 使用 IFormFile 通過模型綁定訪問上傳的文件
• Path.GetFullPath 用於獲取保存上傳文件的完全限定路徑。
• Directory.CreateDirectory 用於創建完全限定路徑（如果不存在）
• 使用 Stream 訪問 IFormFile 中文件的內容。
• 路徑與文件名一起傳遞給文件流。如果未指定文件名，則會引發異常。
• 使用 IFormFile 提供的文件名將文件保存到指定路徑上的文件系統。（這樣做是為了保持代碼簡單，否則您應該生成一個新文件名，而不是使用用戶指定的文件名）。

現在我們已經添加了服務，我們將在依賴容器中註冊該服務，以便可以使用構造函數將其註入到控制器中。要在依賴容器中註冊服務，我們將在 Program.cs 文件中添加以下代碼行。

builder.Services.AddTransient<IBufferedFileUploadService, BufferedFileUploadLocalService>();

添加控制器

現在讓我們添加用於緩衝文件上傳的 MVC 控制器，該控制器將實現 get 操作以顯示視圖和後操作以處理 ASP.NET Core 中的文件上傳。

我們將根據下面顯示的代碼在 Controllers\BufferedFileUploadController.cs 下添加一個控制器

public class BufferedFileUploadController : Controller
{
    readonly IBufferedFileUploadService _bufferedFileUploadService;

    public BufferedFileUploadController(IBufferedFileUploadService bufferedFileUploadService)
    {
        _bufferedFileUploadService = bufferedFileUploadService;
    }

    public IActionResult Index()
    {
        return View();
    }

    [HttpPost]
    public async Task<ActionResult> Index(IFormFile file)
    {
        try
        {
            if (await _bufferedFileUploadService.UploadFile(file))
            {
                ViewBag.Message = "File Upload Successful";
            }
            else
            {
                ViewBag.Message = "File Upload Failed";
            }
        }
        catch (Exception ex)
        {
            //Log ex
            ViewBag.Message = "File Upload Failed";
        }
        return View();
    }
}

在上面的控制器中，我們使用依賴注入通過構造函數注入了 BufferedFileUploadService。

上述 post-action 將文件輸入作為 IFormFile，使用 IFormFile 上傳的文件在控制器或服務中處理文件之前緩存在服務器的內存或磁盤中。

添加視圖

我們將添加視圖以允許用戶選擇要上傳的文件並將其提交到服務器。我們將按照下面顯示的代碼在 Views\BufferedFileUpload\Index.cshtml 下添加一個視圖

<h1>Buffered File Upload</h1>

<hr />

<form method="post" enctype="multipart/form-data">
    <input type="file" name="file" /> 
    <button type="submit">Upload File</button>
</form>
 
@if(ViewBag.Message != null)
{
    <div class="alert" style="margin-top:20px">
        @ViewBag.Message
    </div>
}

為了在 ASP.NET Core 中執行文件上傳，HTML 表單必須將編碼類型（enctype）指定為 multipart/form-data。

要使輸入元素上傳文件，您需要將輸入類型指定為“文件”

什麼是多部分/表單數據？

multipart/form-data 只不過是 post 方法的內容類型標頭之一。此內容類型主要用於將文件作為請求的一部分發送。當使用此內容類型時，這意味著每個值都作為數據塊發送。

運行和測試代碼

最後在添加所有必需的代碼後編譯並執行代碼。執行後導航到路徑/BufferedFileUpload/Index，它應該顯示如下所示的屏幕。

在上面的屏幕上，您可以選擇要上傳的文件，然後單擊 Upload File 按鈕，在 ASP.NET Core 中執行文件上傳。提交成功後，您應該能夠在服務器上的 UploadedFiles 文件夾下看到該文件

使用流式上傳大文件

在這裡，我們將看到如何使用 Streaming 上傳大文件。在這裡，為了在 ASP.NET Core 中執行文件上傳，我們將使用可用於上傳較大文件的流式方法。

添加服務

我們將添加一個服務，它將文件輸入作為流讀取並將提交的文件保存到路徑環境當前目錄下名為 UploadedFile 的文件夾中。該服務將在控制器中用於將發布的文件保存為流。

我們將在 Interfaces/IStreamFileUploadService.cs 下為接口添加以下代碼

public interface IStreamFileUploadService
{
    Task<bool> UploadFile(MultipartReader reader, MultipartSection section);
}

我們將在 Services/StreamFileUploadLocalService.cs 下為服務添加以下代碼

public class StreamFileUploadLocalService : IStreamFileUploadService
{
    public async Task<bool> UploadFile(MultipartReader reader,MultipartSection? section)
    {
        while (section != null)
        {
            var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(
                section.ContentDisposition, out var contentDisposition
            );

            if (hasContentDispositionHeader)
            {
                if (contentDisposition.DispositionType.Equals("form-data") &&
                (!string.IsNullOrEmpty(contentDisposition.FileName.Value) ||
                !string.IsNullOrEmpty(contentDisposition.FileNameStar.Value)))
                {
                    string filePath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "UploadedFiles"));
                    byte[] fileArray;
                    using (var memoryStream = new MemoryStream())
                    {
                        await section.Body.CopyToAsync(memoryStream);
                        fileArray = memoryStream.ToArray();
                    }
                    using (var fileStream = System.IO.File.Create(Path.Combine(filePath, contentDisposition.FileName.Value)))
                    {
                        await fileStream.WriteAsync(fileArray);
                    }
                }
            }
            section = await reader.ReadNextSectionAsync();
        }
        return true;
    }
}

在此模型中，綁定不讀取表單，從表單綁定的參數不綁定。post-action 方法直接與 Request 屬性一起使用。MultipartReader 用於讀取每個部分。

現在我們已經添加了服務，我們將在依賴容器中註冊該服務，以便可以使用構造函數將其註入到控制器中。要在依賴容器中註冊服務，我們將在 Program.cs 文件中添加以下代碼行。

builder.Services.AddTransient<IStreamFileUploadService, StreamFileUploadLocalService>();

添加控制器

現在讓我們添加用於流文件上傳的 MVC 控制器，它將實現 get 操作以顯示視圖和後操作以處理 ASP.NET Core 中的文件上傳。

我們將根據下面顯示的代碼在 Controllers\StreamFileUploadController.cs 下添加一個控制器

public class StreamFileUploadController : Controller
{
    readonly IStreamFileUploadService _streamFileUploadService;

    public StreamFileUploadController(IStreamFileUploadService streamFileUploadService)
    {
        _streamFileUploadService = streamFileUploadService;
    }

    [HttpGet]
    public IActionResult Index()
    {
        return View();
    }

    [ActionName("Index")]
    [HttpPost]
    public async Task<IActionResult> SaveFileToPhysicalFolder()
    {
        var boundary = HeaderUtilities.RemoveQuotes(
            MediaTypeHeaderValue.Parse(Request.ContentType).Boundary
        ).Value;

        var reader = new MultipartReader(boundary, Request.Body);

        var section = await reader.ReadNextSectionAsync();

        string response = string.Empty;
        try
        {
            if (await _streamFileUploadService.UploadFile(reader, section))
            {
                ViewBag.Message = "File Upload Successful";
            }
            else
            {
                ViewBag.Message = "File Upload Failed";
            }
        }
        catch (Exception ex)
        {
            //Log ex
            ViewBag.Message = "File Upload Failed";
        }
        return View();
    }
}

在上面的控制器中，我們使用依賴注入通過構造函數注入了 StreamFileUploadService。

上述後操作從流中讀取文件輸入，使用流上傳的文件在控制器或服務中處理文件之前不會緩沖在服務器的內存或磁盤中。來自流的文件輸入只能讀取一次。

創建 Microsoft.AspNetCore.WebUtilities.MultipartReader 類型的讀取器對像以從多部分數據中讀取子部分流。

添加視圖

我們將添加視圖以允許用戶選擇要上傳的文件並將其提交到服務器。我們將按照下面顯示的代碼在 Views\StreamFileUpload\Index.cshtml 下添加一個視圖

<h1>Stream File Upload</h1>

<hr />

<div>
    <form asp-route="StreamFileUpload/Index"  enctype="multipart/form-data" method="POST">
        <input type="file" name="file" /> 
        <button type="submit" class="btn btn-primary">Save</button>
    </form>
</div>

@if(ViewBag.Message != null)
{
    <div class="alert" style="margin-top:20px">
        @ViewBag.Message
    </div>
}

運行和測試代碼

最後，在添加所有必需的服務、控制器和視圖之後，編譯並執行代碼。執行後導航到路徑/StreamFileUpload/Index，它應該顯示如下所示的屏幕

在上面的屏幕上，您可以選擇要上傳的文件，然後單擊 Upload File 按鈕，在 ASP.NET Core 中執行文件上傳。提交成功後，您應該能夠在服務器上的 UploadedFiles 文件夾下看到該文件

文件存儲選項

在我們上面的演示中，我們將文件保存到本地文件系統。不過，在選擇在網絡服務器上存儲文件的目標時，還有其他可用選項。文件可用的常用存儲選項如下

• 文件系統- 在此選項中，文件保存在本地或網絡共享的物理存儲中。
• 數據庫- 在此選項中，文件以 BLOB 或原始數據的形式保存在數據庫表中的其中一列中。
• 雲- 在此選項中，使用雲提供商提供的某些服務將文件保存在雲中以進行文件存儲。

ASP.NET Core 中的文件上傳也支持上述選項。以下是在選擇存儲選項時應考慮的一些要點

• 對於較小的文件上傳，與物理存儲相比，數據庫通常是更快的選擇
• 對於較大的文件上傳，物理存儲不如數據庫存儲經濟。
• 數據庫可以成為文件存儲的有效選擇，因為當我們從數據庫中選擇記錄時，我們還可以選擇文件數據和記錄。
• 此外，當您將文件存儲在數據庫中時，您可以將記錄與文件數據一起作為同一數據庫事務的一部分插入，否則如果文件在物理存儲中並且記錄在數據庫中，那麼如果設計不當，它可能會創建記錄和文件數據之間有些不一致。
• 當您在數據庫中存儲較大的文件時，數據庫的大小會顯著增長，從而使數據庫備份和恢復成為一個繁重且耗時的過程。
• 數據庫限制可能會對允許存儲的文件的最大大小施加一些限制。
• 在物理存儲的情況下，試圖在物理路徑上保存文件的應用程序應該對存儲位置具有讀寫權限。
• 與本地解決方案相比，雲存儲通常提供更好的穩定性和彈性
• 與數據庫存儲相比，物理存儲在一般層面上不太經濟，而且與雲數據存儲服務相比，數據庫存儲可能更便宜。

安全注意事項

如果您在應用程序中提供文件上傳功能時始終保持謹慎，這將有所幫助，因為攻擊者可能會嘗試通過 ASP.NET Core 中的文件上傳功能來利用該應用程序。攻擊者可能會嘗試通過上傳感染病毒或惡意軟件的文件來關閉系統，或者可能會嘗試闖入系統以訪問網絡或服務器。

以下是您應該考慮的措施，因為這些措施將幫助您阻止攻擊者成功嘗試破壞系統或侵入系統

• 限制可以上傳的文件的最大大小
• 如果使用物理存儲，則應將上傳的文件複製到非系統驅動器
• 最好將所有上傳文件複製到專用位置，以便更容易在該位置施加訪問權限。
• 當您為磁盤分配讀寫權限以復制上傳的文件時，請確保您最終不會授予執行權限。
• 您應該將上傳的文件複製到與部署應用程序的目錄不同的目錄。
• 首先，不允許用戶決定要上傳的文件的文件名，或者如果允許用戶選擇文件名，那麼請確保您對文件進行了所有驗證，以便不想要的關鍵字或字符是避免
• 此外，請驗證文件擴展名，以便僅允許上傳允許的文件類型。
• 對所有上傳的文件執行病毒\maclware 檢查。為此，您可以使用第三方 API 對上傳的內容進行病毒/惡意軟件掃描。
• 確保除了客戶端驗證之外，您還可以在服務器端對文件執行所有驗證

概括

我們了解瞭如何在 ASP.NET Core 應用程序中為緩沖和流類型執行文件上傳。在文件較小且並發文件提交數也較少的情況下，緩衝的方法更可取。

當我們提交大文件或者並發文件提交的數量較高時，應該使用流方法。流類型將有助於減少對服務器內存和磁盤的需求。

鏈接：https ://procodeguide.com/programming/file-upload-in-aspnet-core/

#dotnet #aps.net #csharp #dotnetcore

Как загрузить файл в ASP.NET Core 6

Обзор

Загрузка файла в приложение — это функция, с помощью которой пользователи могут загружать файл, присутствующий в локальной системе или сети пользователя, в веб-приложение. Веб-приложение берет файл для обработки, затем, если требуется, оно выполняет некоторые проверки файла и, наконец, сохраняет этот файл в хранилище, настроенном в системе для сохранения файлов, то есть либо в локальном хранилище, в общем удаленном хранилище, либо в базе данных и т. д. на основе на требованиях.

Загрузка файла — важная функция, которую можно использовать для загрузки изображения профиля пользователя, сведений о клиенте KYC, таких как фотография, подпись и другие подтверждающие документы. Загрузку файлов также можно использовать для загрузки данных, когда вместо отправки одной записи за раз пользователи могут отправлять список записей вместе, используя форматы файлов CSV или XML .

В этой статье основное внимание будет уделено тому, как мы можем реализовать загрузку файлов в ASP.NET Core MVC. Интерфейс IFormFile является частью пространства имен Microsoft.AspNetCore.Http и может использоваться для загрузки одного или нескольких файлов в ASP.NET Core. ASP.NET Core поддерживает загрузку файлов с использованием буферизованной привязки модели для небольших файлов и небуферизованной потоковой передачи для больших файлов.

Подходы к загрузке файлов

Существует два подхода для загрузки файлов в ASP.NET Core.

Буферизация

В этом подходе IFormFile, который является представлением файла C #, используется для передачи, обработки и сохранения файла на веб-сервере. Весь файл считывается в объект IFormFile, поэтому требования к диску и памяти на сервере будут зависеть от количества и размера одновременно загружаемых файлов.

Любой загружаемый файл, размер которого превышает 64 КБ, перемещается из памяти во временный файл на диске. Если ресурсы приложения или веб-сервера исчерпываются из-за большого размера файла и слишком большого количества одновременных загрузок файлов, в этом случае следует рассмотреть возможность использования потокового подхода.

Потоковое

При таком подходе файл загружается в составном запросе и напрямую обрабатывается или сохраняется приложением. Для загрузки файлов потоковый подход потребляет меньше памяти или дискового пространства по сравнению с буферным подходом. Потоковая передача должна быть предпочтительным подходом при загрузке больших файлов на веб-сервер.

Реализовать загрузку файлов в ASP.NET Core

Для разработки демонстрационного приложения мы будем использовать Visual Studio Community 2022 версии 17.2.1 с пакетом SDK для .NET 6.0.

Общий подход

Для демонстрации того, как выполнить загрузку файлов в ASP.NET Core, мы воспользуемся следующим подходом.

• Сначала мы создадим приложение типа ASP.NET Core MVC и назовем его ProCodeGuide.Samples.FileUpload.
• Мы реализуем оба типа загрузки файлов, т. е. привязку буферизованной модели для небольших файлов и потоковую передачу для больших файлов.
• Мы добавим требуемый контроллер с необходимой ViewModel, которая принимает файл на вход и сохраняет его в локальную папку.
• Мы добавим представление, с помощью которого пользователь может выбрать файл из локальной файловой системы для загрузки и отправить файл в метод действия контроллера.
• Наконец, мы запустим приложение и протестируем загрузку файла функций в ASP.NET Core.

Создание основного проекта ASP.NET для демонстрации

Создайте новый проект типа ASP.NET Core MVC, как показано на снимках экрана ниже, с именем проекта ProCodeGuide.Samples.FileUpload.

Мы будем использовать этот проект для демонстрации обоих типов, т. е. буферизации и потоковой передачи для выполнения загрузки файлов в ASP.NET Core.

Загрузить небольшой файл с буферизованной привязкой модели

Здесь мы увидим, как загрузить небольшой файл, используя буферизованную привязку модели. Здесь, чтобы выполнить загрузку файлов в ASP.NET Core, мы будем использовать подход привязки модели с буферизацией, который прост в реализации и может использоваться для загрузки небольших файлов.

Добавить услугу

Мы добавим службу, которая будет принимать IFormFile в качестве входных данных и сохранять файл, отправленный в папку с именем UploadedFile в текущем каталоге среды пути. Эта служба будет использоваться в контроллере для сохранения файла, опубликованного как буферизованная привязка модели.

Мы добавим приведенный ниже код для интерфейса в Interfaces/IBufferedFileUploadService.cs.

public interface IBufferedFileUploadService
{
    Task<bool> UploadFile(IFormFile file);
}

Мы добавим приведенный ниже код для службы в Services/BufferedFileUploadLocalService.cs.

public class BufferedFileUploadLocalService : IBufferedFileUploadService
{
    public async Task<bool> UploadFile(IFormFile file)
    {
        string path = "";
        try
        {
            if (file.Length > 0)
            {
                path = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "UploadedFiles"));
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }
                using (var fileStream = new FileStream(Path.Combine(path, file.FileName), FileMode.Create))
                {
                    await file.CopyToAsync(fileStream);
                }
                return true;
            }
            else
            {
                return false;
            }
        }
        catch (Exception ex)
        {
            throw new Exception("File Copy Failed", ex);
        }
    }
}

В приведенном выше коде в сервисе

• Доступ к загруженному файлу осуществляется через привязку модели с использованием IFormFile.
• Path.GetFullPath используется для получения полного пути для сохранения загруженного файла.
• Directory.CreateDirectory используется для создания полного пути, если он не существует.
• Доступ к содержимому файла в IFormFile осуществляется с помощью метода Stream.
• Путь вместе с именем файла передается в файловый поток. Если имя файла не указано, будет выдано исключение.
• Сохраняет файлы в файловой системе по указанному пути, используя имя файла, предоставленное IFormFile. (это было сделано для простоты кода, иначе вы должны сгенерировать новое имя файла, а не использовать имя файла, указанное пользователем).

Теперь, когда мы добавили службу, мы зарегистрируем эту службу в контейнере зависимостей, чтобы ее можно было внедрить в контроллер с помощью конструктора. Чтобы зарегистрировать службу в контейнере зависимостей, мы добавим приведенную ниже строку кода в файл Program.cs.

builder.Services.AddTransient<IBufferedFileUploadService, BufferedFileUploadLocalService>();

Добавить контроллер

Теперь давайте добавим контроллер MVC для загрузки буферизованного файла, который реализует действие get для отображения представления и пост-действие для обработки загрузки файла в ASP.NET Core.

Мы добавим контроллер в Controllers\BufferedFileUploadController.cs в соответствии с кодом, показанным ниже.

public class BufferedFileUploadController : Controller
{
    readonly IBufferedFileUploadService _bufferedFileUploadService;

    public BufferedFileUploadController(IBufferedFileUploadService bufferedFileUploadService)
    {
        _bufferedFileUploadService = bufferedFileUploadService;
    }

    public IActionResult Index()
    {
        return View();
    }

    [HttpPost]
    public async Task<ActionResult> Index(IFormFile file)
    {
        try
        {
            if (await _bufferedFileUploadService.UploadFile(file))
            {
                ViewBag.Message = "File Upload Successful";
            }
            else
            {
                ViewBag.Message = "File Upload Failed";
            }
        }
        catch (Exception ex)
        {
            //Log ex
            ViewBag.Message = "File Upload Failed";
        }
        return View();
    }
}

В приведенном выше контроллере мы внедрили BufferedFileUploadService через конструктор, используя внедрение зависимостей.

Вышеупомянутое пост-действие принимает входной файл как IFormFile, а файлы, загруженные с помощью IFormFile, буферизуются в памяти или на диске на сервере перед обработкой файла в контроллере или службе.

Добавить вид

Мы добавим представление, чтобы пользователь мог выбрать файл для загрузки и отправить его на сервер. Мы добавим представление в Views\BufferedFileUpload\Index.cshtml в соответствии с кодом, показанным ниже.

<h1>Buffered File Upload</h1>

<hr />

<form method="post" enctype="multipart/form-data">
    <input type="file" name="file" /> 
    <button type="submit">Upload File</button>
</form>
 
@if(ViewBag.Message != null)
{
    <div class="alert" style="margin-top:20px">
        @ViewBag.Message
    </div>
}

Чтобы выполнить загрузку файлов в ASP.NET Core, HTML-формы должны указывать тип кодировки (enctype) как multipart/form-data.

Чтобы элемент ввода загружал файл, вам нужно указать тип ввода как «файл».

Что такое multipart/form-data?

Данные multipart/form — это не что иное, как один из заголовков типа содержимого метода post. Этот тип контента в основном используется для отправки файлов как части запроса. Когда используется этот тип контента, это означает, что каждое значение отправляется как блок данных.

Запустите и протестируйте код

Наконец, после добавления всего необходимого кода, скомпилируйте и выполните код. После выполнения перейдите к пути /BufferedFileUpload/Index, и он должен отобразить экран, показанный ниже.

На приведенном выше экране вы можете выбрать файл для загрузки, а затем нажать кнопку «Загрузить файл», чтобы выполнить загрузку файла в ASP.NET Core. После успешной отправки вы сможете увидеть файл на сервере в папке UploadedFiles.

Загрузить большой файл с потоковой передачей

Здесь мы увидим, как загружать большие файлы с помощью потоковой передачи. Здесь, чтобы выполнить загрузку файлов в ASP.NET Core, мы будем использовать потоковый подход, который можно использовать для загрузки больших файлов.

Добавить услугу

Мы добавим службу, которая будет считывать ввод файла в виде потока и сохранять файл, отправленный в папку с именем UploadedFile в текущем каталоге среды пути. Этот сервис будет использоваться в контроллере для сохранения файла, опубликованного в виде потока.

Мы добавим приведенный ниже код для интерфейса в Interfaces/IStreamFileUploadService.cs.

public interface IStreamFileUploadService
{
    Task<bool> UploadFile(MultipartReader reader, MultipartSection section);
}

Мы добавим приведенный ниже код для службы в Services/StreamFileUploadLocalService.cs.

public class StreamFileUploadLocalService : IStreamFileUploadService
{
    public async Task<bool> UploadFile(MultipartReader reader,MultipartSection? section)
    {
        while (section != null)
        {
            var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(
                section.ContentDisposition, out var contentDisposition
            );

            if (hasContentDispositionHeader)
            {
                if (contentDisposition.DispositionType.Equals("form-data") &&
                (!string.IsNullOrEmpty(contentDisposition.FileName.Value) ||
                !string.IsNullOrEmpty(contentDisposition.FileNameStar.Value)))
                {
                    string filePath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "UploadedFiles"));
                    byte[] fileArray;
                    using (var memoryStream = new MemoryStream())
                    {
                        await section.Body.CopyToAsync(memoryStream);
                        fileArray = memoryStream.ToArray();
                    }
                    using (var fileStream = System.IO.File.Create(Path.Combine(filePath, contentDisposition.FileName.Value)))
                    {
                        await fileStream.WriteAsync(fileArray);
                    }
                }
            }
            section = await reader.ReadNextSectionAsync();
        }
        return true;
    }
}

В этой модели привязка не читает форму, параметры, привязанные к форме, не привязываются. Метод постдействия работает непосредственно со свойством Request. MultipartReader используется для чтения каждого раздела.

Теперь, когда мы добавили службу, мы зарегистрируем эту службу в контейнере зависимостей, чтобы ее можно было внедрить в контроллер с помощью конструктора. Чтобы зарегистрировать службу в контейнере зависимостей, мы добавим приведенную ниже строку кода в файл Program.cs.

builder.Services.AddTransient<IStreamFileUploadService, StreamFileUploadLocalService>();

Добавить контроллер

Теперь давайте добавим контроллер MVC для потоковой загрузки файла, который будет реализовывать действие get для отображения представления и пост-действие для обработки загрузки файла в ASP.NET Core.

Мы добавим контроллер в Controllers\StreamFileUploadController.cs в соответствии с кодом, показанным ниже.

public class StreamFileUploadController : Controller
{
    readonly IStreamFileUploadService _streamFileUploadService;

    public StreamFileUploadController(IStreamFileUploadService streamFileUploadService)
    {
        _streamFileUploadService = streamFileUploadService;
    }

    [HttpGet]
    public IActionResult Index()
    {
        return View();
    }

    [ActionName("Index")]
    [HttpPost]
    public async Task<IActionResult> SaveFileToPhysicalFolder()
    {
        var boundary = HeaderUtilities.RemoveQuotes(
            MediaTypeHeaderValue.Parse(Request.ContentType).Boundary
        ).Value;

        var reader = new MultipartReader(boundary, Request.Body);

        var section = await reader.ReadNextSectionAsync();

        string response = string.Empty;
        try
        {
            if (await _streamFileUploadService.UploadFile(reader, section))
            {
                ViewBag.Message = "File Upload Successful";
            }
            else
            {
                ViewBag.Message = "File Upload Failed";
            }
        }
        catch (Exception ex)
        {
            //Log ex
            ViewBag.Message = "File Upload Failed";
        }
        return View();
    }
}

В приведенном выше контроллере мы внедрили StreamFileUploadService через конструктор, используя внедрение зависимостей.

Вышеупомянутое пост-действие считывает ввод файла из потока, и файлы, загруженные с использованием потока, не буферизируются в памяти или на диске на сервере перед обработкой файла в контроллере или службе. Входной файл из потока может быть прочитан только один раз.

Объект чтения типа Microsoft.AspNetCore.WebUtilities.MultipartReader создается для чтения потока подчастей из составных данных.

Добавить вид

Мы добавим представление, чтобы пользователь мог выбрать файл для загрузки и отправить его на сервер. Мы добавим представление в Views\StreamFileUpload\Index.cshtml в соответствии с кодом, показанным ниже.

<h1>Stream File Upload</h1>

<hr />

<div>
    <form asp-route="StreamFileUpload/Index"  enctype="multipart/form-data" method="POST">
        <input type="file" name="file" /> 
        <button type="submit" class="btn btn-primary">Save</button>
    </form>
</div>

@if(ViewBag.Message != null)
{
    <div class="alert" style="margin-top:20px">
        @ViewBag.Message
    </div>
}

Запустите и протестируйте код

Наконец, после добавления всех необходимых служб, контроллера и представления, скомпилируйте и выполните код. После выполнения перейдите к пути /StreamFileUpload/Index, и он должен отобразить экран, показанный ниже.

На приведенном выше экране вы можете выбрать файл для загрузки, а затем нажать кнопку «Загрузить файл», чтобы выполнить загрузку файла в ASP.NET Core. После успешной отправки вы сможете увидеть файл на сервере в папке UploadedFiles.

Параметры хранения файлов

В нашей демонстрации выше мы сохраняем файл в локальной файловой системе. Тем не менее, есть и другие доступные варианты, когда дело доходит до выбора места хранения файла на веб-сервере. Общие параметры хранения, доступные для файлов, следующие:

• Файловая система — в этом случае файл сохраняется в физическом хранилище либо локально, либо в сетевой папке.
• База данных — в этом варианте файл сохраняется в таблице базы данных в одном из столбцов либо как BLOB, либо как необработанные данные.
• Облако — в этом варианте файл сохраняется в облаке с использованием какой-либо службы, предоставляемой облачным провайдером для хранения файлов.

Вышеупомянутые параметры также поддерживаются для загрузки файлов в ASP.NET Core. Ниже приведены некоторые моменты, которые следует учитывать при выборе вариантов хранения.

• Для загрузки небольших файлов база данных обычно является более быстрым вариантом по сравнению с физическим хранилищем.
• Для загрузки больших файлов физическое хранилище оказывается менее экономичным, чем хранилище базы данных.
• База данных может оказаться эффективным вариантом для хранения файлов, поскольку, когда мы выбираем запись из базы данных, мы также можем выбирать данные файла вместе с записью.
• Кроме того, когда вы сохраняете файл в базе данных, вы можете вставить запись вместе с данными файла как часть той же транзакции базы данных, иначе, если файл находится в физическом хранилище, а запись находится в базе данных, то, если она не спроектирована должным образом, она может создать некоторое несоответствие между записью и данными файла.
• Когда вы храните большие файлы в базе данных, размер базы данных значительно увеличивается, что делает резервное копирование и восстановление базы данных тяжелым и трудоемким процессом.
• Ограничения базы данных могут налагать некоторые ограничения на максимальный размер файла, разрешенного для хранения.
• В случае физического хранилища приложение, пытающееся сохранить файлы по физическому пути, должно иметь разрешение на чтение и запись в место хранения.
• Облачное хранилище часто обеспечивает лучшую стабильность и отказоустойчивость по сравнению с локальными решениями.
• Физическое хранилище на общем уровне менее экономично по сравнению с хранилищем базы данных, а также хранилище базы данных может оказаться менее дорогим по сравнению с облачным хранилищем данных.

Вопросы безопасности

Было бы полезно, если бы вы всегда были осторожны, предоставляя функцию загрузки файлов в своем приложении, поскольку злоумышленники могут попытаться использовать приложение с помощью этой функции загрузки файлов в ASP.NET Core. Злоумышленники могут попытаться вывести систему из строя, загрузив файл, зараженный вирусами или вредоносными программами, или могут попытаться проникнуть в систему, чтобы получить доступ к сети или серверам.

Ниже приведены меры, которые вы должны принять во внимание, поскольку они помогут вам помешать злоумышленникам предпринять успешную попытку сломать систему или проникнуть в систему.

• Установите ограничение на максимальный размер файла, который можно загрузить
• Если используется физическое хранилище, загружаемые файлы следует копировать на несистемный диск.
• Желательно скопировать все загружаемые файлы в выделенное место, чтобы было проще устанавливать права доступа к этому месту.
• Когда вы назначаете разрешение на чтение и запись на диск для копирования загруженных файлов, убедитесь, что вы не предоставляете разрешения на выполнение.
• Вы должны скопировать загруженные файлы в каталог, отличный от каталога, в котором развернуто приложение.
• Во-первых, не позволяйте пользователю выбирать имя загружаемого файла или, если пользователю разрешено выбирать имя файла, убедитесь, что у вас есть все проверки для файла, чтобы нежелательные ключевые слова или символы были избегали
• Кроме того, проверьте расширения файлов, чтобы для загрузки были разрешены только разрешенные типы файлов.
• Выполните проверку на вирусы\maclware для всех загружаемых файлов. Для этого вы можете использовать сторонний API для сканирования загруженного контента на вирусы и вредоносные программы.
• Убедитесь, что помимо проверки на стороне клиента вы также выполняете всю проверку файла на стороне сервера.

Резюме

Мы узнали о том, как выполнять загрузку файлов в основном приложении ASP.NET для буферизованных и потоковых типов. Подход с буферизацией предпочтительнее в сценариях, где размер файла меньше, а количество одновременных отправок файлов также меньше.

Потоковый подход следует использовать там, где мы отправляем большие файлы, или когда количество одновременных отправок файлов находится на более высокой стороне. Тип потока поможет снизить требования к памяти и диску на сервере.

Ссылка: https://procodeguide.com/programming/file-upload-in-aspnet-core/

#dotnet #aps.net #csharp #dotnetcore

How to Create an ASP.NET CORE WEB API CRUD using .NET CORE & Angular

In this video, we will learn how to create an ASP.NET CORE WEB API CRUD using .NET CORE 6 and also Create A CRUD Website using ANGULAR 13 and connect our Angular application to .NET Core Web API.

This will be a detailed tutorial in which we will first create an ASP.NET CORE WEB API using .NET version 6.
We will Install Entity Framework Core inside our ASP.NET CORE WEB API project and connect our .NET 6 WEB API to SQL Server.

We will use Entity Framework Core Migrations to create a SQL SERVER database using EF CORE Code first approach.

We will then create a new controller and create CRUD operations (HTTP GET, POST, DELETE, PUT) to Read, write and fetch data from our SQL server database using EF core.

Then we will create a new Angular application website using Angular 13.

We will create the HTML structure for our Angular website and create some CSS styles for our Angular component.

Then we will connect our Angular application to our ASP.NET CORE WEB API.

We will also ENABLE CORS inside our ASP.NET CORE WEB API.

Then we will create ANGULAR CRUD OPERATIONS by connecting our Angular 13 application to ASP.NET CORE 6 API.

☕ Buy me a coffee: https://www.buymeacoffee.com/SameerSaini

💖 Subscribe to show support: https://bit.ly/2FAgXzS 

#dotnet #api #angular #dotnetcore #aspdotnet 

Search videos through the YouTube Data API from C#

Search videos through the YouTube Data API from C# https://blog.elmah.io/search-videos-through-the-youtube-data-api-from-c/ #aspnetcore #dotnet #dotnetcore #csharp #youtube

How to integrate with the Trello API from .NET/C#

How to integrate with the Trello API from .NET/C# https://blog.elmah.io/how-to-integrate-with-the-trello-api-from-net-c/ #dotnet #dotnetcore #csharp #trello

Debug Dotnet Core Application In Visual Studio Code

Debug Dotnet Core Application In Visual Studio Code

Explained how to create .net core application using .net SDK and explained how to debug it using Visual studio Code.

https://youtu.be/PjQOWLOttbA

#dotnet  #dotnetcore  #debug 

Home repository for .NET Core

.NET Home

The dotnet/core repository is a good starting point for .NET.

The latest major release is .NET 6.0. The latest patch updates are listed in .NET release notes.

.NET Releases

• Download the latest .NET SDK
• .NET releases
• .NET daily builds

Learn about .NET

• Learn about .NET
• .NET Roadmap
• Learn about the .NET platform
• .NET release notes
• .NET Announcements
• .NET blog

Getting help

• File an issue
• Ask on Stack Overflow
• Contact Microsoft Support
• VS Developer Community Portal for .NET Framework feedback (or via Report a Problem tool)

How to Engage, Contribute and Provide Feedback

The .NET team encourages contributions, both issues and PRs. The first step is finding the .NET repository that you want to contribute to.

Check the product roadmap to see what the team is focusing on.

Community

This project uses the .NET Foundation Code of Conduct to define expected conduct in our community. Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting a project maintainer at conduct@dotnetfoundation.org.

.NET Foundation

The .NET platform is part of the .NET Foundation.

Download Details:
Author: dotnet
Source Code: https://github.com/dotnet/core
License: View license

#dotnet  #aspdotnet  #csharp #dotnetcore