/// <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); }