How to build a URL Shortener with C# .NET and Redis

The System.CommandLine libraries provide common functionality for building CLI applications. You can define your arguments and commands in C# and the library will execute your commands, and generate help text, command completion, and more.

Open the UrlShortener.Cli/Program.cs file, and replace the code with the following C#:

using System.CommandLine;
using StackExchange.Redis;
using UrlShortener.Data;

var destinationOption = new Option<string>(
    new[] {"--destination-url", "-d"},
    description: "The URL that the shortened URL will forward to."
);
destinationOption.IsRequired = true;
destinationOption.AddValidator(result =>
{
    var destination = result.Tokens[0].Value;
    if (ShortUrlValidator.ValidateDestination(destination, out var validationResults) == false)
    {
        result.ErrorMessage = string.Join(", ", validationResults);
    }
});

var pathOption = new Option<string>(
    new[] {"--path", "-p"},
    description: "The path used for the shortened URL."
);
pathOption.IsRequired = true;
pathOption.AddValidator(result =>
{
    var path = result.Tokens[0].Value;
    if (ShortUrlValidator.ValidatePath(path, out var validationResults) == false)
    {
        result.ErrorMessage = string.Join(", ", validationResults);
    }
});

var connectionStringOption = new Option<string?>(
    new[] {"--connection-string", "-c"},
    description: "Connection string to connect to the Redis Database where URLs are stored. " +
                 "Alternatively, you can set the 'URL_SHORTENER_CONNECTION_STRING'."
);
var envConnectionString = Environment.GetEnvironmentVariable("URL_SHORTENER_CONNECTION_STRING");
if (string.IsNullOrEmpty(envConnectionString))
{
    connectionStringOption.IsRequired = true;
}

This code defines the options that you can pass into the CLI application:

• destinationOption can be passed in using -d or --destination-url and is required.
• pathOption can be passed in using -p or --path and is also required.
• connectionStringOption can be passed in using -c or --connection-string. Alternatively, you can set the URL_SHORTENER_CONNECTION_STRING environment variable which is preferred over passing sensitive strings as an argument. If the URL_SHORTENER_CONNECTION_STRING environment is not present, then the connectionStringOption is required.

The destinationOption and pathOption validate the argument by passing in the argument value to their respective ShortUrlValidator methods. The validation results are then concatenated and set to result.ErrorMessage which will be displayed as errors to the user.

Now that the options are defined, you can create commands that receive the options.
Add the following code after your existing code:

var rootCommand = new RootCommand("Manage the shortened URLs.");

async Task<ConnectionMultiplexer> GetRedisConnection(string? connectionString)
{
    var redisConnection = await ConnectionMultiplexer.ConnectAsync(
        connectionString ??
        envConnectionString ??
        throw new Exception("Missing connection string.")
    );
    return redisConnection;
}

var createCommand = new Command("create", "Create a shortened URL")
{
    destinationOption,
    pathOption,
    connectionStringOption
};

createCommand.SetHandler(async (destination, path, connectionString) =>
{
    var shortUrlRepository = new ShortUrlRepository(await GetRedisConnection(connectionString));
    try
    {
        await shortUrlRepository.Create(new ShortUrl(destination, path));
        Console.WriteLine("Shortened URL created.");
    }
    catch (Exception e)
    {
        Console.Error.WriteLine(e.Message);
    }
}, destinationOption, pathOption, connectionStringOption);

rootCommand.AddCommand(createCommand);

The rootCommand is the command that is invoked when you invoke the CLI application without passing any subcommands. The create command takes in the destinationOption, pathOption, and connectionStringOption. The lambda passed into the SetHandler method receives the values for the options and will be executed when the command is run from the CLI.

Since the connectionStringOption may not be required, the connectionString parameter may be null. The GetRedisConnection method checks if it is null, and if so, returns the value from the environment variables. If that is also null, it'll throw an exception.

The command handler will create a new ShortUrlRepository passing in the connection string, and use the Create method to create a new shortened URL.

Now, add the following code which will add the update, delete, get, and list commands:

var updateCommand = new Command("update", "Update a shortened URL")
{
    destinationOption,
    pathOption,
    connectionStringOption
};

updateCommand.SetHandler(async (destination, path, connectionString) =>
{
    var shortUrlRepository = new ShortUrlRepository(await GetRedisConnection(connectionString));
    try
    {
        await shortUrlRepository.Update(new ShortUrl(destination, path));
        Console.WriteLine("Shortened URL updated.");
    }
    catch (Exception e)
    {
        Console.Error.WriteLine(e.Message);
    }
}, destinationOption, pathOption, connectionStringOption);

rootCommand.AddCommand(updateCommand);

var deleteCommand = new Command("delete", "Delete a shortened URL")
{
    pathOption,
    connectionStringOption
};

deleteCommand.SetHandler(async (path, connectionString) =>
{
    var shortUrlRepository = new ShortUrlRepository(await GetRedisConnection(connectionString));
    try
    {
        await shortUrlRepository.Delete(path);
        Console.WriteLine("Shortened URL deleted.");
    }
    catch (Exception e)
    {
        Console.Error.WriteLine(e.Message);
    }
}, pathOption, connectionStringOption);

rootCommand.AddCommand(deleteCommand);

var getCommand = new Command("get", "Get a shortened URL")
{
    pathOption,
    connectionStringOption
};

getCommand.SetHandler(async (path, connectionString) =>
{
    var shortUrlRepository = new ShortUrlRepository(await GetRedisConnection(connectionString));
    try
    {
        var shortUrl = await shortUrlRepository.Get(path);
        if (shortUrl == null)
            Console.Error.WriteLine($"Shortened URL for path '{path}' not found.");
        else
            Console.WriteLine($"Destination URL: {shortUrl.Destination}, Path: {path}");
    }
    catch (Exception e)
    {
        Console.Error.WriteLine(e.Message);
    }
}, pathOption, connectionStringOption);

rootCommand.AddCommand(getCommand);

var listCommand = new Command("list", "List shortened URLs")
{
    connectionStringOption
};

listCommand.SetHandler(async (connectionString) =>
{
    var shortUrlRepository = new ShortUrlRepository(await GetRedisConnection(connectionString));
    try
    {
        var shortUrls = await shortUrlRepository.GetAll();
        foreach (var shortUrl in shortUrls)
        {
            Console.WriteLine($"Destination URL: {shortUrl.Destination}, Path: {shortUrl.Path}");
        }
    }
    catch (Exception e)
    {
        Console.Error.WriteLine(e.Message);
    }
}, connectionStringOption);

rootCommand.AddCommand(listCommand);

Note how some commands take less options than others.

Lastly, add the following line of code:

return rootCommand.InvokeAsync(args).Result;

This line is responsible for running the commands and passing in the args string array.

Go back to your terminal and configure the URL_SHORTENER_CONNECTION_STRING environment variable:

If you use PowerShell:

$Env:URL_SHORTENER_CONNECTION_STRING = '[YOUR_CONNECTION_STRING]'

If you use CMD:

set URL_SHORTENER_CONNECTION_STRING=[YOUR_CONNECTION_STRING]

If you use Unix based shells such as Bash or Zsh:

export URL_SHORTENER_CONNECTION_STRING=[YOUR_CONNECTION_STRING]

Replace [YOUR_CONNECTION_STRING] with the connection string pointing to your Redis server.

Now you can run the project and will see helpful information about the available commands:

dotnet run --project UrlShortener.Cli

The output looks like this:

Required command was not provided.

Description:
  Manage the shortened URLs.

Usage:
  UrlShortener.Cli [command] [options]

Options:
  --version       Show version information
  -?, -h, --help  Show help and usage information

Commands:
  create  Create a shortened URL
  update  Update a shortened URL
  delete  Delete a shortened URL
  get     Get a shortened URL
  list    List shortened URLs

To get help information about specific commands, specify the command and add the --help argument:

dotnet run --project UrlShortener.Cli -- create --help

The output looks like this:

Description:
  Create a shortened URL

Usage:
  UrlShortener.Cli create [options]

Options:
  -d, --destination-url <destination-url>      The URL that the shortened URL will forward to.
  (REQUIRED)
  -p, --path <path> (REQUIRED)                 The path used for the shortened URL.
  -c, --connection-string <connection-string>  Connection string to connect to the Redis Database
                                               where URLs are stored. Alternatively, you can set
                                               the 'URL_SHORTENER_CONNECTION_STRING'.
  -?, -h, --help                               Show help and usage information

Next, try the following commands:

dotnet run --project UrlShortener.Cli -- create -d https://www.youtube.com/watch?v=dQw4w9WgXcQ -p rr
dotnet run --project UrlShortener.Cli -- create -d https://www.twilio.com -p tw
dotnet run --project UrlShortener.Cli -- create -d https://sendgrid.com -p sg
dotnet run --project UrlShortener.Cli -- create -d https://swimburger.net -p sb
dotnet run --project UrlShortener.Cli -- get -p sb
dotnet run --project UrlShortener.Cli -- update -d https://swimburger.net/blog -p sb
dotnet run --project UrlShortener.Cli -- list

Alternatively, you could publish the project and interact directly with the executable:

dotnet publish UrlShortener.Cli -o publish
cd publish
./UrlShortener.Cli list 

Great job! You built the CRUD as a CLI application, now let's build the Forwarder Application.

Build the ASP.NET Core Forwarder Application #

In your terminal, head back to the solution folder and then create a new ASP.NET Core Minimal API project:

cd ..
dotnet new web -o UrlShortener.Forwarder

Just like with the CRUD CLI project, add a reference in the Forwarder project to the data project, and add the StackExchange.Redis NuGet package:

dotnet add UrlShortener.Forwarder reference UrlShortener.Data
dotnet add UrlShortener.Forwarder package StackExchange.Redis

Now, open UrlShortener.Forwarder/Program.cs and replace the contents with the following code:

using StackExchange.Redis;
using UrlShortener.Data;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("ShortenedUrlsDb")
            ?? throw new Exception("Missing 'ShortenedUrlsDb' connection string");
var redisConnection = await ConnectionMultiplexer.ConnectAsync(connectionString);
builder.Services.AddSingleton(redisConnection);
builder.Services.AddTransient<ShortUrlRepository>();

var app = builder.Build();

app.MapGet("/{path}", async (
    string path,
    ShortUrlRepository shortUrlRepository
) =>
{
    if(ShortUrlValidator.ValidatePath(path, out _))
        return Results.BadRequest();

    var shortUrl = await shortUrlRepository.Get(path);
    if (shortUrl == null || string.IsNullOrEmpty(shortUrl.Destination))
        return Results.NotFound();

    return Results.Redirect(shortUrl.Destination);
});

app.Run();

Let's look at lines 6 to 10 first. The program will retrieve the UrlsDb Redis connection string from the configuration, and if null, throw an exception. Then, a connection to the Redis server is made which is added to the Dependency Injection (DI) container as a singleton.

Next, the ShortUrlRepository is added as a transient service to the DI container. Since ShortUrlRepository accepts a ConnectionMultiplexer object via its constructor, the DI container is able to construct the ShortUrlRepository for you passing in the singleton ConnectionMultiplexer.

Next, let's look at lines 14 to 27. A new HTTP GET endpoint is added with the route /{path}. This endpoint will be invoked by any HTTP request with a single level path. Without a path, ASP.NET Core will return an HTTP status code of 404 Not Found, and so will requests with subdirectory paths.

When the endpoint is invoked, the path of the URL is passed into the path parameter of the lambda. The second lambda parameter, an instance of ShortUrlRepository, is injected by the DI container.
The path is then validated using ShortUrlValidator.ValidatePath. If the path is not valid, an HTTP status code of 400 Bad Request is returned.

If it is valid, the shortened URL is retrieved using the ShortUrlRepository.Get method. If no shortened URL is found, shortUrl will be null. If the shortUrl is null, or when it is not null but the ShortUrl.Destination is null or empty, then an HTTP status code 404 Not Found is returned. Otherwise, the endpoint responds with HTTP status code 307 Temporary Redirect, redirecting to the ShortUrl.Destination.

Now that your code is ready, you'll need to configure the ShortenedUrlsDb connection string. Run the following commands to enable user-secrets, and then configure your connection string as a user-secret:

dotnet user-secrets --project UrlShortener.Forwarder init
dotnet user-secrets --project UrlShortener.Forwarder set ConnectionStrings:ShortenedUrlsDb [YOUR_CONNECTION_STRING]

Replace [YOUR_CONNECTION_STRING] with the connection string pointing to your Redis server.

Finally, run the Forwarder application:

dotnet run --project UrlShortener.Forwarder

The output of this command will show you the URLs of your application. Open one of the URLs and try some of the shortened URLs you created earlier, like /rr, /sb, /tw, and /sg.

Next steps #

You've developed a CLI application to manage shortened URLs and a web application that forwards the shortened URLs to the destination URLs. However, to make the URL as short as possible, you need to also buy a domain that is short and host your URL shortener at that domain. For example, Twilio uses twil.io as a short domain, which is much shorter than www.twilio.com. This is also a good example of how the name of your brand can still be represented in your short domain name.

There are some other ways you could improve the solution:

• You could make the path optional when creating and updating a shortened URL, and instead randomly generate the path.
• You could store a time to live (TTL) for every shortened URL and remove the shortened URL when the TTL expires.
• You could track how many times a shortened URL is used for analytics purposes. You could store this data in the Redis database, or track it as an event in Segment.
• You could add an API that is consumable from other applications. For example, an SMS application could dynamically generate shortened URLs via the API for the long URLs they are trying to send to users.
• You could create a Graphical User Interface (GUI) to manage the shortened URL data instead of a CLI application.