[add] strongly typed model support

Author: i4004

README.md

@@ -59,3 +59,32 @@ public class MyController : Controller<MultipartViewModel>
     }
 }
 ```
+
+### Binding parameters to a strongly typed model
+
+Instead of searching through the `Parameters` list manually, you can bind the multipart form parameters to a strongly typed model the same way as for a regular query/form/JSON request. Inherit your model from `MultipartModel` (which exposes `Files`) and add your own properties:
+
+```csharp
+public class UploadModel : MultipartModel
+{
+    public string Title { get; set; }
+
+    public int Count { get; set; }
+}
+```
+
+The parameters are parsed into the model properties automatically (the same parser as `Simplify.Web` query/form binding is reused, so `[BindProperty]`, `[Exclude]`, `[Format]`, `IList<T>` properties and validation attributes are all supported), while the uploaded files remain accessible via `Model.Files`:
+
+```csharp
+public class MyController : Controller2<UploadModel>
+{
+    public async Task<ControllerResponse> Invoke()
+    {
+        Model.Title; // bound from the "Title" multipart parameter
+        Model.Count; // bound from the "Count" multipart parameter
+        Model.Files; // uploaded files
+    }
+}
+```
+
+The legacy `MultipartViewModel` (which exposes the raw `Parameters` list) still works as before and now also inherits from `MultipartModel`.

src/Simplify.Web.Multipart/CHANGELOG.md

@@ -4,13 +4,18 @@
 
 ### Added
 
+- `MultipartModel` base class which exposes the uploaded `Files` and allows binding the multipart form parameters to a strongly typed model (reusing the `Simplify.Web` model parser, so `[BindProperty]`, `[Exclude]`, `[Format]`, `IList<T>` properties and validation attributes are supported)
 - .NET 10.0 explicit support
 
 ### Removed
 
 - .NET 6.0 explicit support
 - .NET 4.8 explicit support
 
+### Changed
+
+- `MultipartViewModel` now inherits from `MultipartModel` (fully backward compatible, still exposes the raw `Parameters` list)
+
 ### Dependencies
 
 - Simplify.Web bump to 5.3

src/Simplify.Web.Multipart/Model/Binding/HttpMultipartFormModelBinder.cs

@@ -1,7 +1,9 @@
-using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using HttpMultipartParser;
 using Simplify.Web.Model.Binding;
+using Simplify.Web.Model.Binding.Parsers;
 
 namespace Simplify.Web.Multipart.Model.Binding;
 
@@ -14,26 +16,34 @@ public class HttpMultipartFormModelBinder : IModelBinder
 	/// <summary>
 	/// Binds the model.
 	/// </summary>
-	/// <typeparam name="T">Model type</typeparam>
+	/// <typeparam name="T">Model type, should inherit from <see cref="MultipartModel" />.</typeparam>
 	/// <param name="args">The <see cref="ModelBinderEventArgs{T}" /> instance containing the event data.</param>
 	public async Task BindAsync<T>(ModelBinderEventArgs<T> args)
 	{
 		if (!args.Context.Request.ContentType.Contains("multipart/form-data"))
 			return;
 
-		var multipartModelType = typeof(MultipartViewModel);
-
-		if (typeof(T) != multipartModelType)
-			throw new ModelBindingException("For HTTP multipart form data model type should be: " + multipartModelType.Name);
+		if (!typeof(MultipartModel).IsAssignableFrom(typeof(T)))
+			throw new ModelBindingException("For HTTP multipart form data the model type should inherit from: " + nameof(MultipartModel));
 
 		var parser = await MultipartFormDataParser.ParseAsync(args.Context.Request.Body);
-		var obj = Activator.CreateInstance<T>();
 
-		var model = (MultipartViewModel)(object)obj;
+		// Bind the parameters to the strongly typed model properties reusing Simplify.Web parser.
+		var model = ListToModelParser.Parse<T>(ToKeyValuePairs(parser.Parameters));
+
+		var multipartModel = (MultipartModel)(object)model;
 
-		model.Files = parser.Files;
-		model.Parameters = parser.Parameters;
+		multipartModel.Files = parser.Files;
 
-		args.SetModel(obj);
+		// Keep the raw parameters available for the backward compatible model.
+		if (multipartModel is MultipartViewModel viewModel)
+			viewModel.Parameters = parser.Parameters;
+
+		args.SetModel(model);
 	}
-}
+
+	private static IList<KeyValuePair<string, string[]>> ToKeyValuePairs(IEnumerable<ParameterPart> parameters) =>
+		[.. parameters
+			.GroupBy(x => x.Name)
+			.Select(x => new KeyValuePair<string, string[]>(x.Key, [.. x.Select(p => p.Data)]))];
+}

src/Simplify.Web.Multipart/Model/MultipartModel.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using HttpMultipartParser;
+using Simplify.Web.Model.Binding.Attributes;
+
+namespace Simplify.Web.Multipart.Model;
+
+/// <summary>
+/// Base HTTP multipart form data model providing access to the uploaded files.
+/// Inherit from this class and add your own properties to have the multipart form
+/// parameters bound to them automatically (the same way as for a regular query/form/JSON model).
+/// </summary>
+public class MultipartModel
+{
+	/// <summary>
+	/// HTTP multipart form data files
+	/// </summary>
+	/// <value>
+	/// The files.
+	/// </value>
+	[Exclude]
+	public IReadOnlyList<FilePart> Files { get; set; }
+}

src/Simplify.Web.Multipart/Model/MultipartViewModel.cs

@@ -1,26 +1,22 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using HttpMultipartParser;
+using Simplify.Web.Model.Binding.Attributes;
 
 namespace Simplify.Web.Multipart.Model;
 
 /// <summary>
-/// HTTP multipart form data model
+/// HTTP multipart form data model exposing the raw files and parameters lists.
+/// Use it when you want to work with the parameters list directly; to bind the
+/// parameters to a strongly typed model inherit from <see cref="MultipartModel" /> instead.
 /// </summary>
-public class MultipartViewModel
+public class MultipartViewModel : MultipartModel
 {
-	/// <summary>
-	/// HTTP multipart form data files
-	/// </summary>
-	/// <value>
-	/// The files.
-	/// </value>
-	public IReadOnlyList<FilePart> Files { get; set; }
-
 	/// <summary>
 	/// HTTP multipart form data parameters
 	/// </summary>
 	/// <value>
 	/// The parameters.
 	/// </value>
+	[Exclude]
 	public IReadOnlyList<ParameterPart> Parameters { get; set; }
-}
+}

src/TestClient/Program.cs

@@ -1,10 +1,21 @@
-using System;
+using System;
 using System.IO;
 using Flurl.Http;
 
 var result = await "http://localhost:5000/api/v1/testIn"
 	.PostMultipartAsync(mp =>
 		mp.AddFile("test file", new MemoryStream("Hello World!!!"u8.ToArray()), "MyFile.txt", "text/plain"));
 
-Console.WriteLine("HTTP status: " + result.StatusCode);
-Console.ReadLine();
+Console.WriteLine("Untyped model HTTP status: " + result.StatusCode);
+
+var typedResult = await "http://localhost:5000/api/v1/testInTyped"
+	.PostMultipartAsync(mp =>
+	{
+		mp.AddFile("test file", new MemoryStream("Hello World!!!"u8.ToArray()), "MyFile.txt", "text/plain");
+		mp.AddString("Title", "My title");
+		mp.AddString("Count", "42");
+	});
+
+Console.WriteLine("Typed model HTTP status: " + typedResult.StatusCode);
+
+Console.ReadLine();

src/TestServer/Controllers/Api/v1/TestInTypedController.cs

@@ -0,0 +1,40 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Simplify.Web;
+using Simplify.Web.Attributes;
+using Simplify.Web.Multipart.Model;
+using TestServer.Requests;
+
+namespace TestServer.Controllers.Api.v1;
+
+[Post("/api/v1/testInTyped")]
+public class TestInTypedController : Controller2<UploadModel>
+{
+	public async Task<ControllerResponse> Invoke()
+	{
+		var file = Model.Files[0] ?? throw new ArgumentException("No files in model");
+
+		using var stream = new StreamReader(file.Data);
+
+		var fileData = await stream.ReadToEndAsync();
+
+		// Assert parameters were bound to the typed model
+
+		if (Model.Title != "My title")
+			return Content($"Wrong title, actual: '{Model.Title}'", 500);
+
+		if (Model.Count != 42)
+			return Content($"Wrong count, actual: '{Model.Count}'", 500);
+
+		// Assert file is still accessible
+
+		if (file.FileName != "MyFile.txt")
+			return Content($"Wrong file name, actual: '{file.FileName}'", 500);
+
+		if (fileData != "Hello World!!!")
+			return Content($"Wrong file data, actual: '{fileData}'", 500);
+
+		return NoContent();
+	}
+}

src/TestServer/Requests/UploadModel.cs

@@ -0,0 +1,15 @@
+using Simplify.Web.Model.Validation.Attributes;
+using Simplify.Web.Multipart.Model;
+
+namespace TestServer.Requests;
+
+/// <summary>
+/// Strongly typed multipart model: the parameters are bound to the model properties automatically.
+/// </summary>
+public class UploadModel : MultipartModel
+{
+	[Required]
+	public string Title { get; set; }
+
+	public int Count { get; set; }
+}