ServiceStack support for conditionally omitting fi

问题:

<TL;DR>

At a minimum, I'm looking for a way to conditionally exclude certain properties on the resource from being included in the response on a per-call basis (See fields below).

Ideally, I'd like to implement a REST service with ServiceStack that supports all the major points below.

UPDATE
While I really like ServiceStack's approach in general and would prefer to use it if possible, if it isn't particularly well suited towards these ideas I'd rather not bend over backwards bastardizing it to make it work. If that's the case, can anyone point to another c# framework that might be more appropriate? I'm actively exploring other options myself, of course.

</TD;DR>

In this talk entitled Designing REST + JSON APIs, the presenter describes his strategy for Resource References (via href property on resources) in JSON. In addition to this, he describes two query parameters (fields and expand) for controlling what data is included the response of a call to a REST service. I've been trying without success to dig into the ServiceStack framework to achieve support for fields in particular but have thus far been unsuccessful. Is this currently possible in ServiceStack? Ideally the solution would be format agnostic and would therefore work across all of ServiceStack's supported output formats. I would imagine expand would follow the same strategy.

I'll describe these features here but I think the talk at the link does a better job of explaining them.

Lets say we have an Profiles resource with the following properties: givenName, surname, gender, and favColor. The Profiles resource also includes a list of social networks the user belongs to in the socialNetworks property.

href - (42:22 in video) Every resource includes a full link to it on the REST service. A call to GET /profiles/123 would return

{
    "href":"https://host/profiles/123",
    "givenName":"Bob",
    "surname":"Smith",
    "gender":"male",
    "favColor":"red",
    "socialNetworks": {
        "href":"https://host/socialNetworkMemberships?profileId=123"
    }
}

Notice that the socialNetworks property returns an object with just the href value populated. This keeps the response short and focused while also giving the end user enough information to make further requests if desired. The href property, used across the board in this manor, makes it easy (conceptually anyway) to reuse resource data structures as children of other resources.

fields - (55:44 in video) Query string parameter that instructs the server to only include the specified properties of the desired resource in the REST response.

A normal response from GET /profiles/123 would include all the properties of the resource as seen above. When the fields query param is included in the request, only the fields specified are returned. 'GET /propfiles/123?fields=surname,favColor' would return

{
    "href":"https://host/profiles/123",
    "surname":"Smith",
    "favColor":"red"
}

expand - (45:53 in video) Query string parameter that instructs the server to flesh out the specified child resources in the result. Using our example, if you were to call GET /profiles/123?expand=socialNetworks you might receive something like

{
    "href":"https://host/profiles/123",
    "givenName":"Bob",
    "surname":"Smith",
    "gender":"male",
    "favColor":"red",
    "socialNetworks": {
        "href":"https://host/socialNetworkMemberships?profileId=123",
        "items": [
            { 
                "href":"https://host/socialNetworkMemberships/abcde",
                "siteName":"Facebook",
                "profileUrl":"http://www.facebook.com/..."
            },
            ...
        ]
    }
}

回答1:

So...in my opinion ServiceStack's best feature is that it makes sending, receiving and handling POCOs over HTTP super easy. How you set up the POCOs and what you do in between (within the 'Service') is up to you. Does SS have opinions? Yes. Do you have to agree with them? No. (But you probably should :))

I think expanding on something like below would get you close to how you want to handle your api. Probably not the best example of ServiceStack but the ServiceStack code/requirements are barely noticeable and don't get in your way (AppHost configure not shown). You could probably do something similar in other .NET Frameworks (MVC/Web API/etc) but, in my opinion, won't look as much like straight C#/.NET code as with ServiceStack.

Request classes

[Route("/Profiles/{Id}")]
public class Profiles
{
    public int? Id { get; set; }
}

[Route("/SocialNetworks/{Id}")]
public class SocialNetworks
{
    public int? Id { get; set; }
}

Base Response class

public class BaseResponse
{
    protected virtual string hrefPath
    {
        get { return ""; }
    }

    public string Id { get; set; }
    public string href { get { return hrefPath + Id; } }
}

Classes from example

public class Profile : BaseResponse
{
    protected override string hrefPath { get { return "https://host/profiles/"; } }

    public string GivenName { get; set; }
    public string SurName { get; set; }
    public string Gender { get; set; }
    public string FavColor { get; set; }

    public List<BaseResponse> SocialNetworks { get; set; }
}

public class SocialNetwork: BaseResponse
{
    protected override string hrefPath { get { return "https://host/socialNetworkMemberships?profileId="; }}

    public string SiteName { get; set; }
    public string ProfileUrl { get; set; }
}

Services

public class ProfileService : Service
{
    public object Get(Profiles request)
    {
        var testProfile = new Profile { Id= "123", GivenName = "Bob", SurName = "Smith", Gender = "Male", FavColor = "Red", 
                SocialNetworks = new List<BaseResponse>
                    {
                        new SocialNetwork { Id = "abcde", SiteName = "Facebook", ProfileUrl = "http://www.facebook.com/"}
                    }
        };

        if (!String.IsNullOrEmpty(this.Request.QueryString.Get("fields")) || !String.IsNullOrEmpty(this.Request.QueryString.Get("expand")))
            return ServiceHelper.BuildResponseObject<Profile>(testProfile, this.Request.QueryString);

        return testProfile;
    }
}

public class SocialNetworkService : Service
{
    public object Get(SocialNetworks request)
    {
        var testSocialNetwork = new SocialNetwork
            {
                Id = "abcde",
                SiteName = "Facebook",
                ProfileUrl = "http://www.facebook.com/"
            };

        if (!String.IsNullOrEmpty(this.Request.QueryString.Get("fields")) || !String.IsNullOrEmpty(this.Request.QueryString.Get("expand")))
            return ServiceHelper.BuildResponseObject<SocialNetwork>(testSocialNetwork, this.Request.QueryString);

        return testSocialNetwork;
    }
}

Reflection Helper Class

public static class ServiceHelper
{
    public static object BuildResponseObject<T>(T typedObject, NameValueCollection queryString) where T: BaseResponse
    {
        var newObject = new ExpandoObject() as IDictionary<string, object>;
        newObject.Add("href", typedObject.href);

        if (!String.IsNullOrEmpty(queryString.Get("fields")))
        {
            foreach (var propertyName in queryString.Get("fields").Split(',').ToList())
            {
                //could check for 'socialNetwork' and exclude if you wanted
                newObject.Add(propertyName, typedObject.GetType().GetProperty(propertyName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance).GetValue(typedObject, null));
            }
        }

        if (!String.IsNullOrEmpty(queryString.Get("expand")))
        {
            foreach (var propertyName in queryString.Get("expand").Split(',').ToList())
            {
                newObject.Add(propertyName, typedObject.GetType().GetProperty(propertyName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance).GetValue(typedObject, null));
            }
        }

        return newObject;
    }
}

回答2:

Usually you can control the serialization of your DTOs by setting the DataMember attributes. With those attributes you can control if the property should have defaults or not. Meaning if you simply do not define the property of the object you want to return, it should not be serialized and therefore will not be shown in the resulting Json.

ServiceStack internally uses the standard DataContract...Serializer, so this should be supported

Otherwise you could also make use of dynamic objects and simply compose your object at runtime, serialize it and send it back. Here is a very very basic example:

        var seri = JsonSerializer.Create(new JsonSerializerSettings() { });

        using (var textWriter = new StringWriter())
        {
            var writer = new JsonTextWriter(textWriter);

            dynamic item = new { Id = id };

            seri.Serialize(writer, item);

            return textWriter.ToString();
        }