Practical ASP.NET

Returning Raw JSON Data in Web API with Marten

Here's a trick to have Marten automatically deserialize JSON data only when you want it to.

Marten is an open source .NET document database library that allows the storing, loading, updating and deleting of objects as documents in an underlying PostgreSQL database.

Marten stores .NET objects as JSON data in the underlying PostgreSQL database. When these documents are retrieved from the database, Marten deserializes the JSON data back into .NET objects to be used in the application.

Normally this automatic deserialization is exactly what's required -- once you get the document back as an object you can manipulate it just like any other object in the application. However, in some circumstances this automatic deserialization can introduce an unnecessary processing overhead. One such circumstance is the use of Web API to retrieve documents and return them to the client.

Creating a Basic Web API Project That Uses Marten
After creating a new ASP.NET Web API project in Visual Studio, the first thing to do is to define a document class to represent a Player in a fictitious Role Playing Game:

public class Player
{
  public int Id { get; set; }
  public string Name { get; set; }
  public int CurrentHealth { get; set; }
}

Next, the API controller can be created that allows the POSTing of new Players to be added to the database and GET methods to retrieve Players. For simplicity in the example in Listing 1, additional methods such as PUT, validation and logging have not been included.

Listing 1: Initial PlayersController
using System.Collections.Generic;
using System.Net;
using System.Web.Http;
using Marten;
using WebApplication1.Models;

namespace WebApplication1.Controllers
{
  public class PlayersController : ApiController
  {
    private readonly IDocumentSession _session;

    public PlayersController(IDocumentSession session)
    {
      _session = session;
    }

    // GET api/players
    public IEnumerable<Player> Get()
    {
      return _session.Query<Player>();
    }

    // GET api/players/1
    public Player Get(int id)
    {
      var player = _session.Query<Player>().Where(x => x.Id == id).FirstOrDefault();

      if (player != null)
      {
        return player;
      }

      throw new HttpResponseException(HttpStatusCode.NotFound);
    }

    // POST api/players
    public void Post([FromBody] Player player)
    {
      // Validation, etc.

      _session.Store(player);
      _session.SaveChanges();
    }
  }
}

Note in Listing 1 the Marten IDocumentSession is being injected into the controller via its constructor. This assumes that IoC has been configured for the application and that the correct Marten types have been registered with the container. For example, to use StructureMap, the StructureMap.WebApi2 NuGet package can be installed and the Marten types registered, as shown in Listing 2.

Listing 2: Registering Marten Types in the StructreMap DefaultRegistry
ForSingletonOf<IDocumentStore>().Use("Create DocumentStore", () =>
{
  return DocumentStore.For(configure =>
  {
    // Connection would normally be stored in configuration somewhere
    configure.Connection("host = localhost; database = RPGDatabase; 
      password = g7qo84nck22i; username = postgres"); 
    configure.AutoCreateSchemaObjects = AutoCreate.All;
  });
});

For<IDocumentSession>()
  .LifecycleIs<ContainerLifecycle>()
  .Use("Lightweight Marten Document Session", x => x.GetInstance<IDocumentStore>().LightweightSession());

At this point, new Players can be POSTed (as JSON) to /api/players, all players can be retrieved via a GET to /api/players and a single player can be retrieved via a GET to /api/players/{id}.

Reducing Deserialization/Serialization Overhead
In the implementation of the GETs in Listing 1 Marten is deserializing the JSON into Player objects, only for the object to be serialized back to JSON to be returned via Web API. This overhead can be reduced by instructing Marten to not perform deserialization and instead just return the JSON string as stored in PostgreSQL. We can then just return this as a string result from the controller action.

In the case of multiple results, the Marten .ToJsonArray extension method can be included in the LINQ code. This method returns multiple documents inside a JSON array. The following code shows an updated GET method that uses .ToJsonArray to return the JSON stored in the database directly to the clien:

// GET api/players
public HttpResponseMessage Get()
{
  string rawJsonFromDb = _session.Query<Player>().ToJsonArray();

  var response = Request.CreateResponse(HttpStatusCode.OK);
  response.Content = new StringContent(rawJsonFromDb, Encoding.UTF8, "application/json");
  return response;
}

The "find single Player" GET method can also be modified, this time using the Marten AsJson extension method as shown in Listing 3.

Listing 3: Returning a Single Document as Raw JSON
// GET api/players/1
public HttpResponseMessage Get(int id)
{
  var rawJsonFromDb = 
    _session.Query<Player>().Where(x => x.Id == id).AsJson().FirstOrDefault();

  if (!string.IsNullOrEmpty(rawJsonFromDb))
  {
    var response = Request.CreateResponse(HttpStatusCode.OK);
    response.Content = new StringContent(rawJsonFromDb, Encoding.UTF8, "application/json");
    return response;
  }

  throw new HttpResponseException(HttpStatusCode.NotFound);
}

To learn more about Marten, check out the documentation and the series of articles on the Don't Code Tired blog.

About the Author

Jason Roberts is a Microsoft C# MVP with over 15 years experience. He writes a blog at http://dontcodetired.com, has produced numerous Pluralsight courses, and can be found on Twitter as @robertsjason.

comments powered by Disqus

Featured

  • Python in VS Code Adds Data Viewer for Debugging

    The January 2021 update to the Python Extension for Visual Studio Code is out with a short list of new features headed by a data viewer used while debugging.

  • GitHub Ships Enterprise Server 3.0 Release Candidate

    It's described as "the biggest ever change to Enterprise Server," with improvements to Actions, Packages, mobile, security and more.

  • Attacks on .NET Apps Grow in Number, Severity, Says Security Firm

    .NET apps were found to have more serious vulnerabilities and suffer more attacks last year, according to data gathered by Contrast Labs.

  • Microsoft Opens Up Old Win32 APIs to C# and Rust, More Languages to Come

    Microsoft is opening up old Win32 APIs long used for 32-bit Windows programming, letting coders use languages of their choice instead of the default C/C++ option.

Upcoming Events