Nancy Web Framework

** Announcement **

Nancy is no longer being maintained.

Support and Maintenance: For organizations with production services depending on Nancy, commercial support, maintenance, and migration services may be available through members of the team. Contact nancyfx.help@gmail.com to discuss options.

Forking: The license is permissive, and forking is encouraged for maintenance purposes. Note that the Nancy name and logos are copyrighted and may not be reused or edited.

Nancy provides several core features for building HTTP services:

• Hosting Agnostic: Can run on ASP.NET/IIS, WCF, Self-hosting, and any OWIN-compliant server.
• HTTP Verb Support: Lightweight declarations for GET, HEAD, PUT, POST, DELETE, OPTIONS, and PATCH.
• View Engine Integration: Supports Razor, Spark, dotLiquid, SuperSimpleViewEngine, and more.
• Path Matching: Powerful request path matching with advanced parameter capabilities and support for custom implementations.
• Easy Response Syntax: Directly return types like int, string, HttpStatusCode, or Action<Stream> without explicit casting.
• Content Negotiation: Built-in support for negotiating content types.
• Testing Framework: Includes a lightweight framework to verify application behavior.

Nancy is a lightweight framework for building HTTP services on .NET Framework/Core and Mono. You define your application logic by inheriting from NancyModule and using a Domain Specific Language (DSL) to declare routes for HTTP verbs like GET, POST, PUT, DELETE, etc.

public class Module : NancyModule
{
    public Module()
    {
        Get("/greet/{name}", x => {
            return string.Concat("Hello ", x.name);
        });
    }
}

The Markdown Viewengine enables writing views in Markdown format. It provides the following capabilities:

• Full Model support
• Master page support
• Support for embedding HTML within Markdown content

To render a Markdown file, use the standard Nancy view return syntax:

You can modify the request or response by adding items to the pipeline. For example, you can use RequestStartup to add a delegate to the AfterRequest pipeline to perform actions like saving database changes or disposing of resources after a request completes.

protected override void RequestStartup(TinyIoCContainer container, IPipelines pipelines, NancyContext context)
{
    base.RequestStartup(container, pipelines, context);

    pipelines.AfterRequest.AddItemToEndOfPipeline(
        (ctx) =>
        {
            var documentSession = container.Resolve<IDocumentSession>();

            if (ctx.Response.StatusCode != HttpStatusCode.InternalServerError)
            {
                documentSession.SaveChanges();
            }

            documentSession.Dispose();
        });
}

Working samples are provided in the /sample directory of the repository. To run them, use the provided build scripts depending on your operating system:

• Windows (PowerShell): ./build.ps1
• Linux/macOS (Bash): ./build.sh

Nancy has built-in content negotiation. You can use the Negotiate object within a route to return different models or views based on the client's Accept header, or to provide custom headers.

Get["/"] = parameters => {
    return Negotiate
        .WithModel(new RatPack {FirstName = "Nancy "})
        .WithMediaRangeModel("text/html", new RatPack {FirstName = "Nancy fancy pants"})
        .WithView("negotiatedview")
        .WithHeader("X-Custom", "SomeValue");
};

Nancy provides a testing library that allows you to test the full request/response cycle without needing to hit a real server. This is useful for verifying status codes, headers, and content negotiation. You can use the Browser class to simulate requests.

[Fact]
public void GetData_WhenRequested_ShouldReturnOKStatusCode()
{
    var browser = new Browser();
    var response = await browser.Get("/GetData", (with) =>
    {
        with.Header("Authorization", "Bearer johnsmith");
        with.Header("Accept", "application/json");
        with.HttpRequest();
    });

    Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
}

Nancy uses a terse syntax for defining routes. You can create a module by inheriting from NancyModule and defining routes within the constructor using the Get, Post, Put, or Delete indexers.

public class HelloModule : NancyModule
{
    public HelloModule()
    {
        Get["/"] = parameters => "Hello World";
    }
}

To host a Nancy application within an ASP.NET environment, you must register the NancyHttpRequestHandler in your web.config. This allows Nancy to intercept incoming requests.

Depending on your IIS mode (Classic vs. Integrated), you may need to add the handler to both <system.web>/<httpHandlers> and <system.webServer>/<handlers>.

<configuration>
  <system.web>
    <httpHandlers>
      <add verb="*" type="Nancy.Hosting.Aspnet.NancyHttpRequestHandler" path="*"/>
    </httpHandlers>
  </system.web>

  <system.webServer>
    <validation validateIntegratedModeConfiguration="false"/>
    <httpErrors existingResponse="PassThrough"/>
    <handlers>
      <add name="Nancy" verb="*" type="Nancy.Hosting.Aspnet.NancyHttpRequestHandler" path="*"/>
    </handlers>
  </system.webServer>
</configuration>

To use the Nancy Razor View Engine in an ASP.NET environment, you must register the build providers in the <system.web>/<compilation>/<buildProviders> section of your web.config. This enables the application to handle .cshtml and .vbhtml files using Nancy's specific build providers.

<system.web>
  <compilation>
    <buildProviders>
      <add extension=".cshtml" type="Nancy.ViewEngines.Razor.BuildProviders.NancyCSharpRazorBuildProvider, Nancy.ViewEngines.Razor.BuildProviders" />
      <add extension=".vbhtml" type="Nancy.ViewEngines.Razor.BuildProviders.NancyVisualBasicRazorBuildProvider, Nancy.ViewEngines.Razor.BuildProviders" />
    </buildProviders>
  </compilation>
</system.web>