Problem with deserialization for custom json mime types.

[MarcelWilke42]

Describe the bug
With the removal of AddHandler the check for wildcards is probably lost. So there is no deserialization when the server sends a content type of e.g. application/vnd.somebody.something+json.

To Reproduce
Just try to deserialize something from an API that sends a content type like application/vnd.somebody.something+json.

Expected behavior
That the serialization of content types like "application/vnd.somebody.something+json" works.

Stack trace
There is no Stack trace

Desktop (please complete the following information):

• OS: Windows 10 (20H2)
• .NET version: 4.7.2
• Version: 107.1.1

Additional context
Currently the json serializer supports the following strings:

"application/json", "text/json", "text/x-json", "text/javascript", "*+json"

If an API now returns e.g. application/json everything is ok and the deserialization works. But if the API returns e.g. application/vnd.somebody.something+json there is no deserialization. Since here:

https://github.com/restsharp/RestSharp/blob/dev/src/RestSharp/RestClient.Serialization.cs#L94

is only checked with a Contains. So there is no match on *+json and no matching serializer is found and no deserialization is done.

If you copy e.g. JsonNetSerializer and name it JsonNetSerializerNew and add SupportedContentTypes to application/vnd.somebody.something+json everything works perfectly, because the Contains is matched again.

PR #1709 partially fixes the problem (since DetectContentType acts as a fallback here). However, it does not fix the original problem that WildCards are no longer supported.

[alexeyzimarev]

Yes, you're right. RestSharp used to have a more advanced parsing of the content type. I was looking at it yesterday, it bothers me as well.

[alexeyzimarev]

I am making a quick attempt to solve it without parsing wildcards. Basically, the idea is to check if the content type contains json and if yes - consider it JSON. Do you think it would work?

[MarcelWilke42]

Yes by merging #1709 it already works. Since we have here:

https://github.com/restsharp/RestSharp/blob/dev/src/RestSharp/RestClient.Serialization.cs#L89

then we end up in the false case and DetectContentType then returns Json.

However feels but not 100% correct because actually we should load in true case. Since the content type is known and also actually supported. Then we would not have to "guess" the type with DetectContentType either.

The variant with SupportedContentTypes and *+json feels actually so far correctly, if it is correctly recognized e.g. by a Regex instead of a wildcard.

[alexeyzimarev]

My question is more about the need for regex or this would be enough:

    public bool SupportsContentType(string contentType) => contentType.Contains("json");

[MarcelWilke42]

One could then do the following:

• all serializers would have to get SupportsContentType as a function through the interface
• remove the initial check from GetContentDeserializer and run through all serializers with the check for "SupportsContentType" instead
• thus DetectContentType is omitted as well
  And in the case of json, SupportsContentType would then be as follows:

public bool SupportsContentType(string contentType)
            => SupportedContentTypes.Contains(contentType) || contentType.EndsWith("json");

(note the EndsWith instead of Contains)

[alexeyzimarev]

I had to rename SupportedContentTypes to AcceptedContentTypes because wildcards were driving some servers nuts. My question is how important is it to do the first check (array scan) as the second condition is much after to check. If that's enough, maybe the array scan isn't necessary.

[alexeyzimarev]

Btw I already added the function to the interface, it's not pushed yet.

[alexeyzimarev]

That's what I came up with. The 'Detect' function is still there as a fallback because .NET minimal API that I use for tests sometimes return null content type (weird) but I don't want to start debugging it.

RestSharp/src/RestSharp/RestClient.Serialization.cs

Lines 94 to 105 in c94dfcd

	IDeserializer? GetContentDeserializer(RestResponseBase response, DataFormat requestFormat) {
	var contentType = response.ContentType ?? DetectContentType();
	if (contentType == null) return null;
	var serializer = Serializers.Values.FirstOrDefault(x => x.SupportsContentType(contentType));
	var factory = serializer ?? (Serializers.ContainsKey(requestFormat) ? Serializers[requestFormat] : null);
	return factory?.GetSerializer().Deserializer;
	string? DetectContentType()
	=> response.Content!.StartsWith("<") ? ContentType.Xml
	: response.Content.StartsWith("{") || response.Content.StartsWith("[") ? ContentType.Json : null;
	}

[MarcelWilke42]

To me this looks very good. The only thing that is lost (but doesn't really bother me^^) is the support for "text/javascript".

And one more technical question. Is the content type always lowercase? (didn't check further if this happens somewhere in the code).

[alexeyzimarev]

I've never seen any uppercase content type values. I think they must be lowercase.

[MarcelWilke42]

You are right, by convention the mime types are case-insensitive.
Here is a list of the registrieten types https://www.iana.org/assignments/media-types/media-types.xhtml