基于.NET与Dynamic EDM Model的可编辑OData服务示例及方案咨询

Absolutely! There are several open-source examples and proven approaches to build an editable OData service with a dynamic EDM model in .NET. Let's break this down for you:

Open-Source Examples to Reference #

• Microsoft Official OData Dynamic Model Samples
  The official Microsoft OData GitHub organization hosts samples that demonstrate editable operations with dynamic EDM models. Look for examples that extend the basic dynamic model setup to include CRUD handlers—these typically show how to map POST/PUT/PATCH/DELETE requests to dynamic entities, leveraging OData's built-in routing and model validation.

• Community-Driven Dynamic OData Services
  Many individual developers have shared ASP.NET Core OData projects that implement full CRUD for dynamic entities. These examples often use flexible data stores (like in-memory dictionaries or NoSQL databases) to accommodate the dynamic schema, and show how to validate requests against the runtime EDM model.

Implementation Recommendations #

Here’s a step-by-step approach to convert your read-only dynamic OData service to an editable one:

1. Build Dynamic CRUD Controller Logic #

Instead of creating a separate controller for each static entity, use a generic or single ODataController implementation that handles all dynamic entities:

• Use HttpContext.ODataFeature().Model to access your runtime dynamic EDM model.
• Parse the request path to identify the target entity set and entity type (e.g., using EntitySetSegment from the OData path).
• Implement handlers for POST, PUT, PATCH, and DELETE that work with flexible entity representations (like Dictionary<string, object>).

Example snippet for a POST handler:

public class DynamicODataController : ODataController
{
    private readonly IDynamicEntityStore _entityStore;

    public DynamicODataController(IDynamicEntityStore entityStore)
    {
        _entityStore = entityStore;
    }

    [HttpPost]
    public IActionResult Post([FromBody] Dictionary<string, object> entityData)
    {
        var entitySetSegment = Request.ODataFeature().Path?.Segments
            .OfType<EntitySetSegment>().FirstOrDefault();
        
        if (entitySetSegment == null)
            return BadRequest("Could not resolve target entity set.");

        var edmEntityType = entitySetSegment.EntitySet.EntityType();
        // Validate required properties against EDM model
        foreach (var edmProperty in edmEntityType.Properties())
        {
            if (!edmProperty.IsNullable && !entityData.ContainsKey(edmProperty.Name))
            {
                return BadRequest($"Missing required property: {edmProperty.Name}");
            }
        }

        var createdEntity = _entityStore.Add(entitySetSegment.EntitySet.Name, entityData);
        return Created(createdEntity);
    }
}

2. Choose a Flexible Data Store #

Since your schema is dynamic, avoid rigid relational databases (unless you’re using a schema-on-read approach). Opt for:

• In-memory dictionaries: Great for prototyping and examples (as shown in the snippet below).
• NoSQL databases: MongoDB or Cosmos DB work well, as they support flexible document schemas that align with dynamic entities.

Example in-memory store implementation:

public interface IDynamicEntityStore
{
    Dictionary<string, object> Add(string entitySetName, Dictionary<string, object> entity);
    bool Update(string entitySetName, string entityKey, Dictionary<string, object> updatedEntity);
    bool Delete(string entitySetName, string entityKey);
    Dictionary<string, object> Get(string entitySetName, string entityKey);
}

public class InMemoryDynamicStore : IDynamicEntityStore
{
    private readonly Dictionary<string, Dictionary<string, Dictionary<string, object>>> _store = new();

    public Dictionary<string, object> Add(string entitySetName, Dictionary<string, object> entity)
    {
        if (!_store.ContainsKey(entitySetName))
            _store[entitySetName] = new Dictionary<string, Dictionary<string, object>>();
        
        // Assume "Id" is the primary key (adjust based on your dynamic model)
        var key = entity["Id"].ToString();
        _store[entitySetName][key] = entity;
        return entity;
    }

    // Implement Update, Delete, Get methods similarly
}

3. Handle Partial Updates (PATCH) #

To support JSON Patch requests, use the Microsoft.AspNetCore.JsonPatch library:

• Deserialize the patch document and apply it to your dynamic entity (represented as a Dictionary<string, object>).
• Validate patch operations against the EDM model to ensure properties exist and data types match.

4. Validate Requests Against the Dynamic EDM Model #

Before processing any write operation, validate the incoming data against your runtime EDM model:

• Check that all required properties are present.
• Verify that property values match the expected data type (e.g., a property defined as Edm.Int32 shouldn’t receive a string value).
• Ensure navigation property references are valid (if your model includes associations).

5. Configure OData Routing and Model Registration #

In your ASP.NET Core startup code, ensure your dynamic EDM model is correctly registered and routes are configured to support CRUD:

builder.Services.AddOData()
    .AddRouteComponents("odata", BuildDynamicEdmModel()); // Your dynamic model builder method

builder.Services.AddScoped<IDynamicEntityStore, InMemoryDynamicStore>();

Make sure the OData routing conventions recognize your dynamic entity sets—this typically works out of the box if your dynamic model properly defines EntitySet elements.

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