/// <summary>
/// Registers an override to be applied for a specific <see cref="Type"/> regardless of what
/// the service states it requires.
/// </summary>
/// <param name="type">The type to register a custom handler for</param>
/// <param name="handler">The handler to use</param>
public void RegisterCustomTypeHandler(Type type, IMediaTypeHandler handler)
{
Ensure.IsNotNull(type, "type");
Ensure.IsNotNull(handler, "handler");
typeSpecificHandlers[type] = handler;
}
/// <summary>
/// Registers a handler for a given media type.
/// </summary>
/// <param name="mediaType">The media type to register against</param>
/// <param name="handler">The handler to register</param>
public void RegisterMediaTypeHandler(string mediaType, IMediaTypeHandler handler)
{
Ensure.IsNotNullOrEmpty(mediaType, "mediaType");
Ensure.IsNotNull(handler, "handler");
mediaTypeHandlers[mediaType] = handler;
}
/// <summary>
/// Attempts to locate a <see cref="IMediaTypeHandler"/> that can handle the requested type.
/// If a custom handler is available for the supplied type, this will be used in preference to
/// the media type. The method returns false if no handler is found that matches either criteria.
/// </summary>
/// <param name="objectType">The type of object to read or write</param>
/// <param name="mediaType">The requested media type by the service</param>
/// <param name="handler">The returned handler if a suitable one is found</param>
/// <returns>True if an appropriate handler was found, otherwise false</returns>
public bool TryGetHandler(Type objectType, string mediaType, out IMediaTypeHandler handler)
{
Ensure.IsNotNull(objectType, "objectType");
Ensure.IsNotNullOrEmpty(mediaType, "mediaType");
return(this.typeSpecificHandlers.TryGetValue(objectType, out handler) ||
this.mediaTypeHandlers.TryGetValue(mediaType, out handler));
}
/// <summary>
/// Deserializes the request, resolve the <see cref="IRouteRequestHandler{TRequest, TResponse}"/>, then writes the response
/// </summary>
/// <param name="mediaHandler">Media handler for the request</param>
/// <param name="context">request context</param>
/// <returns>the awaitable task representing the routing operation</returns>
public async Task Send(IMediaTypeHandler mediaHandler, IRequestContext context)
{
var req = await mediaHandler.Read <TRequest>(context);
var handler = context.GetService <IRouteRequestHandler <TRequest, TResponse> >();
var resp = await handler.Handle(req, context.CancellationToken);
await mediaHandler.Write(context, resp);
}
private static void TestWriteMultiple(IMediaTypeHandler handler)
{
string actual;
using (var stream = new StringBuilderStream())
{
handler.Write<IEnumerable<Customer>>(TestData.MultipleContent, stream).Wait();
actual = stream.StringValue;
}
if (actual == null)
{
throw new Exception("No Output!");
}
}
private static void TestWriteMultiple(IMediaTypeHandler handler)
{
string actual;
using (var stream = new StringBuilderStream())
{
handler.Write <IEnumerable <Customer> >(TestData.MultipleContent, stream).Wait();
actual = stream.StringValue;
}
if (actual == null)
{
throw new Exception("No Output!");
}
}
private static bool TryGetMediaTypeHandler(IContext context, IList <string> acceptedTypes,
out IMediaTypeHandler mediaTypeHandler)
{
try
{
string matchedType;
mediaTypeHandler = new MediaTypeHandlerTable().GetMediaTypeHandler(acceptedTypes, out matchedType);
}
catch (UnsupportedMediaTypeException)
{
context.Response.Status = "415 Unsupported media type requested.";
mediaTypeHandler = null;
return(false);
}
return(true);
}
private static bool TryGetMediaTypeHandler(IContext context, out IMediaTypeHandler mediaTypeHandler)
{
try
{
string matchedType;
mediaTypeHandler = new MediaTypeHandlerTable().GetMediaTypeHandler(context.Request.AcceptTypes, out matchedType);
}
catch (UnsupportedMediaTypeException)
{
context.Response.StatusCode = 415;
context.Response.StatusDescription = "Unsupported media type requested.";
mediaTypeHandler = null;
return false;
}
return true;
}
private static void TestHandler(string name, Func <IMediaTypeHandler> ctor)
{
Console.Write("{0}\t\tS: ", name);
double average = CodeExecutionTimer.Average(Iterations, () =>
{
IMediaTypeHandler handler = ctor();
TestWriteSingle(handler);
});
Console.Write("{0:0.0000000000}s\tM: ", average);
average = CodeExecutionTimer.Average(Iterations, () =>
{
IMediaTypeHandler handler = ctor();
TestWriteMultiple(handler);
});
Console.WriteLine("{0:0.0000000000}s", average);
}
public ValueTask <object> Deserialize(string mediaType, PipeReader reader, Type type, CancellationToken cancellationToken)
{
IMediaTypeHandler handler = default;
try
{
if (this._handlers.TryGetValue(mediaType, out handler))
{
return(handler.Deserialize(reader, type, cancellationToken));
}
}
catch (Exception exc)
{
this._logger.LogWarning(exc, $"Failure to deserialize body into '{mediaType}': {exc.Message}.");
}
return(default);
/// <summary>
/// Gets the first content-type match for the handler from a list of accepted types
/// </summary>
/// <param name="mediaTypeHandler">The content type handler.</param>
/// <param name="acceptedTypes">The accepted types.</param>
/// <returns>The MIME content type, or <c>null</c> if no match is found.</returns>
public static string GetContentType(this IMediaTypeHandler mediaTypeHandler, IList <string> acceptedTypes)
{
HashSet <string> contentTypes;
if (!Cache.TryGetValue(mediaTypeHandler.GetType(), out contentTypes))
{
lock (Sync)
{
if (!Cache.TryGetValue(mediaTypeHandler.GetType(), out contentTypes))
{
contentTypes =
new HashSet <string>(
MediaTypesAttribute.Get(mediaTypeHandler.GetType()).SelectMany(cta => cta.ContentTypes),
StringComparer.OrdinalIgnoreCase);
Cache[mediaTypeHandler.GetType()] = contentTypes;
}
}
}
return(acceptedTypes.FirstOrDefault(x => ContainsMatchingContentType(contentTypes, x)));
}
private static bool TryGetMediaTypeHandler(IContext context, IList<string> acceptedTypes, out IMediaTypeHandler mediaTypeHandler)
{
if (acceptedTypes == null || (acceptedTypes.Count == 1 && acceptedTypes[0].StartsWith("*/*")))
{
mediaTypeHandler = null;
return false;
}
try
{
string matchedType;
mediaTypeHandler = new MediaTypeHandlerTable().GetMediaTypeHandler(acceptedTypes, out matchedType);
}
catch (UnsupportedMediaTypeException)
{
context.Response.Status = "415 Unsupported media type requested.";
mediaTypeHandler = null;
return false;
}
return true;
}
public async ValueTask <bool> Serialize(string mediaType, object obj, PipeWriter writer)
{
IMediaTypeHandler handler = default;
try
{
if (this._handlers.TryGetValue(mediaType, out handler))
{
await handler.Serialize(obj, writer);
return(true);
}
}
catch (Exception exc)
{
this._logger.LogWarning(exc, $"Failure to serialize body into '{mediaType}' using {handler.GetType().FullName}: {exc.Message}.");
}
return(false);
}
/// <summary>
/// Gets the first content-type match for the handler from a list of accepted types
/// </summary>
/// <param name="mediaTypeHandler">The content type handler.</param>
/// <param name="acceptedTypes">The accepted types.</param>
/// <returns>The MIME content type, or <c>null</c> if no match is found.</returns>
public static string GetContentType(this IMediaTypeHandler mediaTypeHandler, IList <string> acceptedTypes)
{
return(MediaTypesAttribute.Get(mediaTypeHandler.GetType()).SelectMany(cta => cta.ContentTypes)
.FirstOrDefault(acceptedTypes.Contains));
}
public Task Send(IMediaTypeHandler mediaHandler, IRequestContext context)
{
HasSent = true;
return(Task.CompletedTask);
}
