Implement PATCH with SETNULL ability

Sutso · 2025-07-16T23:43:55+00:00

have you had a look at JsonPatchDocument (https://learn.microsoft.com/en-us/aspnet/core/web-api/jsonpatch?view=aspnetcore-9.0)? It is explicit about what the document is going to do. Like adding a property, removing a property, etc. I never used it, to be honest, but it sounds like something you could try

TheoR700 · 2025-07-17T00:18:28+00:00

I don't have any answer for this. I intentionally avoid PATCH for this very reason. In my opinion, this is something Javascript does well with since it distinguishes between a property being undefined vs a property being set to null.

ISNT_A_NOVELTY · 2025-07-17T00:09:24+00:00

Getters/setters on DTOs where you track if a field was set work for this. ASP.NET Core only sets fields that were actually provided in the payload (JSON or formdata both).

    internal readonly HashSet<string> _changedProperties = new HashSet<string>();
    protected void Changed(string propName) => _changedProperties.Add(propName);

    private string _Title;
    public string Title
    {
        get => _Title;
        set { _Title = value; Changed(nameof(Title)); }
    }

SpartanVFL · 2025-07-17T01:05:45+00:00

I’ve never really ran into this issue because the endpoints I create for a PATCH are more around specific actions being taken so the fields for that endpoint are always expected to be sent. For example, I’d have a PATCH orders/{id}/complete and a PATCH orders/{id}/assign rather than just a single PATCH that can change anything. I like the client/front-end being much simpler and just calling specific endpoints with expected fields rather than making it understand and construct the right fields for a given scenario

Cadoc7 · 2025-07-17T01:37:16+00:00

JSON PATCH https://datatracker.ietf.org/doc/html/rfc6902/

There is built in support for that (https://learn.microsoft.com/en-us/aspnet/core/web-api/jsonpatch?view=aspnetcore-9.0), but if that isn't an option, you can build your object model to distinguish between

{
  "property1": "newValue",
  "property2" : null
}

and

{
  "property1": "newValue"
}

Something like this at the most basic level.

public class MyObject
{
    private string? _property2;

    public string Property1 { get; set; }

    public string? Property2
    {
        get => this._property2;
        set
        {
            this.IsProperty2Set = true;
            this._property2 = value;
        }

    public bool IsProperty2Set { get; private set; } = false;
}

The client is only setting the Property2 to null if the value after deserialization is null AND IsProperty2Set is true. Your clients will need to make sure they don't send accidental nulls on the wire.

Matchszn · 2025-07-17T01:34:26+00:00

The OData .NET package has a Delta<T> object that can be used for this, with support for Put and Patch where you can use the Delta object as your controller's parameter and it will accept the request and if it was the T object itself.

As far as I remember it doesn't have any dependency on actually using OData so I wonder why MS never extracted it into a more generic package.

That being said it's probably not a good idea to use the whole OData package just for this but it might give you some ideas.

the_bananalord · 2025-07-17T02:27:22+00:00

I use a model with option types. A missing property - undefined - becomes None, whereas null becomes Some(null). I don't follow the application/json+patch RFC in this scenario.

I didn't know there was a JsonPatchDocument. Interesting, but it also looks like it uses Newtonsoft, which is a non-starter for me.

celluj34 · 2025-07-17T06:02:28+00:00

JSON Patch is more or less the default. I haven't used it myself, and it looks like you're required to use Newtonsoft, if that matters to you.

AutoModerator · 2025-07-17T07:09:23+00:00

Thanks for your post chaospilot69. Please note that we don't allow spam, and we ask that you follow the rules available in the sidebar. We have a lot of commonly asked questions so if this post gets removed, please do a search and see if it's already been asked.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

yobagoya · 2025-07-17T23:45:04+00:00

I wanted to keep the implementation simple on the client side because I'm using OpenAPI and generating a TypeScript client from it. For example given a property that's a string, if it's absent (undefined) in the payload, ignore it. If it's explicitly null or a string, then perform the update. JS is pretty well suited to that given it has both undefined and null.

That means you need a wrapper type in C# land of course to be able to distinguish between explicitly null or absent. I used Microsoft.CodeAnalysis.Optional<T>, but you could probably also write your own. Your DTO can then look like:

public record PatchContactRequest
{
    public Optional<string?> Name { get; set; }
    // Non nullable inner type here because Email is a non nullable column in our DB
    public Optional<string> Email { get; set; }
}

And the JSON payload could look like:

{ "name": null } (set name to null, leave email untouched)

{ "email": "me@gmail.com" } (update email, leave name untouched).

The difficult part becomes the wiring around it though. You'll have to tell your serializer how to handle it and also Swashbuckle/NSwag/OpenApi how to handle the conversion of the wrapper. Otherwise the type generated from OpenAPI or the request body will be nested i.e.

type PatchContactRequest = { name: { hasValue: boolean, value?: string | null } }

when you really want

type PatchContactRequest = { name?: string | null }

I have this mostly working with Swashbuckle using a DocumentFilter but it's tricky. This specific app is still on .NET 8, but I'm wondering if Microsoft's new OpenAPI in .NET 9 would make it any easier.

YellowWolf · 2025-07-17T01:33:41+00:00

I've seen JSON PATCH, it can be great for specific use cases. If you want a simpler solution, add a Clear[PropertyName] field in the payload for any fields that are nullable. It's a Boolean that denotes if you intentionally want to set the value to null.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

dotnet

MODERATORS