public class Startup
{
    // This method gets called by the runtime. Use this method to add services to the container.
    // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSingleton<Serializer>(provider =>
        {
            HyperionSerializerSettings hyperionSerializerSettings = HyperionSerializerSettings.Default;

            return new Serializer(new SerializerOptions(preserveObjectReferences: hyperionSerializerSettings.PreserveObjectReferences,
                                                        versionTolerance: hyperionSerializerSettings.VersionTolerance,
                                                        ignoreISerializable: hyperionSerializerSettings.IgnoreISerializable));
        });

        // If using Kestrel:
        services.Configure<KestrelServerOptions>(options => { options.AllowSynchronousIO = true; });

        // If using IIS:
        services.Configure<IISServerOptions>(options => { options.AllowSynchronousIO = true; });
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseOwin(action => action.UseNancy(options => options.Bootstrapper = new DemoBootstrapper(app.ApplicationServices, env)));
    }
}

public class DemoBootstrapper : DefaultNancyBootstrapper
{
    private readonly IServiceProvider _serviceProvider;
    private readonly IWebHostEnvironment _webHostEnvironment;

    public DemoBootstrapper(IServiceProvider serviceProvider, IWebHostEnvironment webHostEnvironment)
    {
        _serviceProvider = serviceProvider;
        _webHostEnvironment = webHostEnvironment;
    }

    protected override Func<ITypeCatalog, NancyInternalConfiguration> InternalConfiguration
    {
        get
        {
            Type[] processors = {typeof(ViewProcessor), typeof(HyperionProcessor), typeof(JsonProcessor), typeof(XmlProcessor)};

            return NancyInternalConfiguration.WithOverrides(x => x.ResponseProcessors = processors);
        }
    }

    public override void Configure(INancyEnvironment environment)
    {
        if (_webHostEnvironment.IsDevelopment())
        {
            environment.Tracing(true, true);
        }
    }

    protected override void ConfigureApplicationContainer(TinyIoCContainer container)
    {
        base.ConfigureApplicationContainer(container);

        container.Register(_serviceProvider.GetRequiredService<Serializer>());
    }
}

public sealed class HomeModule : NancyModule
{
    public HomeModule()
    {
        Get("/user", args =>
        {
            var user = new User() {Id = Guid.NewGuid(), Name = "Ozgen", Age = 32, CreateDate = DateTime.Now};

            // return Response.AsHyperion<User>(user);

            return user;
        });

        Post("/user", o =>
        {
            var user = this.Bind<User>();

            return "OK";
        });
    }
}

private static async Task Main(string[] args)
{
    var serializer = new Serializer(new SerializerOptions(preserveObjectReferences: true, versionTolerance: true, ignoreISerializable: true));

    var user = new User() {Id = Guid.NewGuid(), Name = "Deniz", Age = 31, CreateDate = DateTime.Now};

    using var client = new HttpClient();
    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-hyperion"));

    var uri = new Uri("<adress>/user");

    using (var stream = new MemoryStream())
    {
        serializer.Serialize(user, stream);

        byte[] content = stream.ToArray();
        var byteArrayContent = new ByteArrayContent(content);
        byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("application/x-hyperion");

        HttpResponseMessage postAsync = await client.PostAsync(uri, byteArrayContent);
    }

    HttpResponseMessage getAsync = await client.GetAsync(uri);

    Stream responseAsync = await getAsync.Content.ReadAsStreamAsync();

    user = serializer.Deserialize<User>(responseAsync);
}