在ASP.NET Web API中是否有@JsonView等效

Question

I have much more experience in Spring and Java, but now I am working on ASP.NET Web API project.

So in Spring there is @JsonView annotation with which I can annotate my DTOs, so I could select which data I will show through REST. And I find that very useful. But I cannot find any equivalent in ASP.NET. So I would need to create DTO for every special usecase.

So for example in Java if I have UserEntity that contains information about users. Some information can be seen publicly and some can be seen only by admins. The siple solution could be this

public class UserEntity {
  @JsonView(Views.Public.class)
  @JsonProperty("ID")
  private Integer id;

  @JsonView(Views.Public.class)
  private String name;

  @JsonView(Views.Admin.class)
  @JsonFormat(
  shape = JsonFormat.Shape.STRING, 
  pattern = "dd-MM-yyyy hh:mm:ss")
  private Date dateOfBirth;

  @JsonView(Views.Admin.class)
  private String email;

  @JsonIgnore
  private String password;
  private Integer version;
}

So in this case for equivalent functionality in ASP.NET I would need to create 2 DTOs. One for user that can be seen publicly and one for user that can be seen only by admin.

public class PublicUserDto {

  public int ID {get; set;}

  public String Name {get; set;}

}

public class AdminUserDto {

  public int ID {get; set;}

  public String Name {get; set;}

  public DateTime DateOfBirth {get; set;}

  public string Email {get; set;}
}

Is there any better solution? Is there some mechanism that I can use to create view over my data in ASP.NET Web API?

Answer 1

JSON.NET has something called Conditional Property Initialization . You can write a method with the following format:

public bool ShouldSerialize[YourPropertyName]() => someBoolCondition;

JSON.NET will call that method to determine if that property should be serialized or not. So you could have something like:

public DateTime DateOfBirth {get; set;}

public bool ShouldSerializeDateOfBirth() => isAdmin;

It's not as pretty as JsonView but it should do the job.

Answer 2

You can implement that yourself using custom contract resolver. Suppose you have attribute:

[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
public class JsonViewAttribute : Attribute {
    public JsonViewAttribute(string viewName) {
        ViewName = viewName;
    }

    public string ViewName { get; }
}

Views:

public static class JsonViews {
    public const string Administrator = "Administrator";
}

And DTO class:

public class UserDto
{
    public int ID { get; set; }

    public String Name { get; set; }

    [JsonView(JsonViews.Administrator)]
    public DateTime DateOfBirth { get; set; }
    [JsonView(JsonViews.Administrator)]
    public string Email { get; set; }
}

And your goal is to serialize properties decorated with JsonView only if current user is authenticated and has target role ("Administrator"). Then you can create contract resolver like this:

public class JsonViewContractResolver : JsonContractResolver {
    public JsonViewContractResolver(MediaTypeFormatter formatter) : base(formatter) {
    }

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) {
        JsonProperty property = base.CreateProperty(member, memberSerialization);
        var viewAttr = member.GetCustomAttribute<JsonViewAttribute>();
        if (viewAttr != null) {
            // if decorated with attribute
            property.ShouldSerialize = (instance) => {
                var context = HttpContext.Current;
                if (context == null)
                    return true;
                // we are in context of http request
                if (context.User == null || context.User.Identity == null)
                    return false;
                // should serialize only if user is in target role
                return context.User.Identity.IsAuthenticated && context.User.IsInRole(viewAttr.ViewName);
            };
        }

        return property;
    }
}

And set it in config:

public static void Register(HttpConfiguration config)
{
    config.MapHttpAttributeRoutes();
    config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new JsonViewContractResolver(config.Formatters.JsonFormatter);
}

Now whenever you return json in controller like this:

[System.Web.Http.HttpGet]          
public UserDto Get()
{            
    return new UserDto()
    {
        ID = 1,
        DateOfBirth = DateTime.UtcNow,
        Email = "test",
        Name = "name"
    };
}

And it is serialized to json - admin properties would be omitted if user is not administrator.

Note that if you would do this:

[System.Web.Http.HttpGet]          
public IHttpActionResult Get()
{            
    return Json(new UserDto()
    {
        ID = 1,
        DateOfBirth = DateTime.UtcNow,
        Email = "test",
        Name = "name"
    });
}

Formatter is not used and you have to pass serialization settings with custom formatter yourself (of course you need to make it into reusable method, for example declare Json method in your base controller from which all other inherit):

return Json(new UserDto()
{
    ID = 1,
    DateOfBirth = DateTime.UtcNow,
    Email = "test",
    Name = "name"
}, GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings);

Using roles is just an example to show how you can extend JSON.NET serializer used by asp.net api by default to achieve desired result.