Skip to main content

Nancy Web Framework

Nancy is a lightweight, open-source web framework for building web applications in .NET.

It is designed to be simple, flexible, and easy to use, allowing developers to quickly create web applications with minimal effort.

History of Nancy Framework​

Nancy was first released in 2010 by Andreas Håkansson and Steven Robbins. The framework was inspired by the simplicity and elegance of Ruby's Sinatra framework. The goal of Nancy was to provide a similar experience for .NET developers, offering a lightweight and unobtrusive alternative to more complex web frameworks.

Over the years, Nancy has gained popularity among developers due to its simplicity, extensibility, and vibrant community. It has become a popular choice for building small to medium-sized web applications in the .NET ecosystem.

Features of Nancy Framework​

Lightweight and Minimalistic​

Nancy is designed to be lightweight and minimalistic, providing only the essential features needed for building web applications. It has a small footprint and minimal dependencies, making it easy to get started and deploy applications.

Routing​

Nancy provides a powerful routing system that allows developers to define URL patterns and map them to specific handlers. The routing system is flexible and supports both convention-based and attribute-based routing.

Get("/hello/{name}", parameters => {
    var name = parameters.name;
    return $"Hello, {name}!";
});

In the above example, a GET request to /hello/John would return the response Hello, John!. The {name} parameter in the route is captured and passed to the handler.

Dependency Injection​

Nancy has built-in support for dependency injection, allowing developers to easily manage and inject dependencies into their application components. It integrates well with popular IoC containers like Autofac and Ninject.

public class Greeter
{
    private readonly ILogger logger;

    public Greeter(ILogger logger)
    {
        this.logger = logger;
    }

    public string Greet(string name)
    {
        logger.Log($"Greeting {name}...");
        return $"Hello, {name}!";
    }
}

In the above example, the Greeter class has a dependency on the ILogger interface, which is automatically resolved and injected by Nancy.

Content Negotiation​

Nancy provides robust content negotiation capabilities, allowing applications to respond with different representations of the same resource based on the client's preferences. It supports a variety of content types, including JSON, XML, HTML, and more.

Get("/api/users/{id}", parameters => {
    var user = userRepository.GetUserById(parameters.id);
    Negotiate
        .WithModel(user)
        .WithMediaRangeModel("application/json", user.ToJson())
        .WithMediaRangeModel("application/xml", user.ToXml());
});

In the above example, the response format is determined based on the client's Accept header. If the client prefers JSON, the user object is serialized to JSON. If the client prefers XML, the user object is serialized to XML.

View Engines​

Nancy supports various view engines, such as Razor, DotLiquid, and SuperSimpleViewEngine, allowing developers to easily render dynamic views. View engines provide a way to separate the presentation logic from the application logic.

Get("/hello/{name}", parameters => {
    var name = parameters.name;
    return View["hello.cshtml", name];
});

In the above example, the hello.cshtml view template is rendered with the provided name parameter.

Examples of Nancy Framework​

Example 1: Hello World​

using Nancy;

public class HelloWorldModule : NancyModule
{
    public HelloWorldModule()
    {
        Get("/", _ => "Hello World!");
    }
}

In this example, a simple "Hello World" web application is created using Nancy. The HelloWorldModule class inherits from NancyModule and defines a single route that responds with the text "Hello World!".

Example 2: Todo List API​

using Nancy;
using System.Collections.Generic;

public class TodoModule : NancyModule
{
    private List<string> todos = new List<string>();

    public TodoModule()
    {
        Get("/todos", _ => todos);
        Post("/todos", parameters => {
            var todo = Request.Form["todo"];
            todos.Add(todo);
            return HttpStatusCode.OK;
        });
    }
}

In this example, a simple Todo List API is created using Nancy. The /todos route supports both GET and POST methods. GET returns the list of todos, and POST adds a new todo to the list.

Conclusion​

Nancy is a lightweight and flexible web framework for building web applications in .NET. It provides a simple and elegant API for routing, dependency injection, content negotiation, and view rendering. With its minimalistic approach, Nancy allows developers to focus on building their applications without unnecessary complexity.

Official website: Nancy