ServiceStack是否支持类似QueryDb的UpdateDb自动映射更新端点？

Great question! ServiceStack doesn’t include a built-in UpdateDb<T> generic type that mirrors QueryDb<T> for handling all write operations (POST/PUT/DELETE) in a single DTO, but there are two straightforward paths to get the behavior you want—using official ServiceStack features or a simple custom implementation.

Option 1: Use AutoQuery CRUD (Official, Recommended) #

ServiceStack’s AutoQuery has dedicated CRUD base classes that handle insert/update/delete operations automatically, similar to how QueryDb<T> works for queries. Instead of a single DTO for all operations, you define separate DTOs for each action—this is the official, supported approach and keeps your endpoints aligned with REST best practices.

Here’s how you’d implement it for your Customer entity:

// Create (POST)
[Route("/edits/customers", "POST")]
[Authenticate]
public class CreateCustomer : CreateDb<ServiceModel.Catalog.Customer> { }

// Update (PUT)
[Route("/edits/customers/{Id}", "PUT")]
[Authenticate]
public class UpdateCustomer : UpdateDb<ServiceModel.Catalog.Customer> { }

// Delete (DELETE)
[Route("/edits/customers/{Id}", "DELETE")]
[Authenticate]
public class DeleteCustomer : DeleteDb<ServiceModel.Catalog.Customer> { }

These base classes (CreateDb<T>, UpdateDb<T>, DeleteDb<T>) automatically map to OrmLite’s underlying CRUD operations—you don’t need to write any service implementation code. Just register AutoQuery in your AppHost (which you likely already do for QueryDb) and these endpoints will work out of the box.

Option 2: Build a Custom UpdateDb Implementation #

If you really want a single DTO to handle all write operations, you can create a generic base class and service handler that mimics QueryDb<T>’s pattern. Here’s a minimal working example:

Step 1: Define the UpdateDb Base Class #

public abstract class UpdateDb<T> : IReturnVoid 
    where T : class, IHasId<int>, new() // Adjust IHasId<T> to match your entity's ID type
{
    public T Entity { get; set; }
    public int? Id { get; set; }
}

Step 2: Create a Service to Handle the Operations #

public class UpdateDbService : Service
{
    public async Task Post<T>(UpdateDb<T> request) 
        where T : class, IHasId<int>, new()
    {
        if (request.Entity == null)
            throw new ArgumentNullException(nameof(request.Entity));
        
        await Db.InsertAsync(request.Entity);
    }

    public async Task Put<T>(UpdateDb<T> request) 
        where T : class, IHasId<int>, new()
    {
        if (request.Entity == null)
            throw new ArgumentNullException(nameof(request.Entity));
        
        // Use provided Id or entity's Id for update
        var id = request.Id ?? request.Entity.Id;
        if (id == 0)
            throw new ArgumentException("No valid ID provided for update");
        
        await Db.UpdateAsync(request.Entity, x => x.Id == id);
    }

    public async Task Delete<T>(UpdateDb<T> request) 
        where T : class, IHasId<int>, new()
    {
        if (request.Id.HasValue)
        {
            await Db.DeleteByIdAsync<T>(request.Id.Value);
        }
        else if (request.Entity != null && request.Entity.Id != 0)
        {
            await Db.DeleteAsync(request.Entity);
        }
        else
        {
            throw new ArgumentException("No valid ID or entity provided for deletion");
        }
    }
}

Step 3: Register Your Custom Service and DTO #

Register the service in your AppHost:

public override void Configure(Container container)
{
    // ... other config
    container.RegisterAs<UpdateDbService, IService>();
}

Then define your endpoint DTO exactly as you wanted:

[Route("/edits/customers", "POST,PUT,DELETE")]
[Authenticate]
public class UpdateCustomers : UpdateDb<ServiceModel.Catalog.Customer> { }

This implementation will route POST requests to insert, PUT to update, and DELETE to remove records—all through one endpoint DTO. You can extend it with validation, filtering, or other business logic as needed.

Option 3: Use CrudService for Auto-Generated CRUD Endpoints #

If you don’t need custom routing, ServiceStack’s CrudService<T> automatically generates standard CRUD endpoints (e.g., POST /customers, PUT /customers/{Id}) for your entity with zero DTO definitions. Just register the service:

public override void Configure(Container container)
{
    // ... other config
    container.RegisterAutoWiredAs<CrudService<ServiceModel.Catalog.Customer>, IService>();
}

This is the fastest way to get CRUD endpoints, but it uses fixed routing conventions instead of custom paths like /edits/customers.

Final Recommendation #

If REST-aligned endpoints are acceptable, go with AutoQuery CRUD—it’s official, maintained, and handles edge cases (like validation, concurrency, and error handling) out of the box. If you need a single DTO for all write operations, the custom UpdateDb<T> implementation is simple to build and maintain.

内容的提问来源于stack exchange，提问作者jkrebsbach