Forem: Dino Lozina

Write a URL Shortener in 26 Lines of Code with .NET Minimal APIs

Dino Lozina — Thu, 13 Jan 2022 13:16:45 +0000

I was looking forward to .NET minimal API framework for a very long time and now, it is finally out! Let’s dive into new version of .NET6 and answer the following questions:

What is .NET minimal API?
How to refactor existing URL shortener?
How to add dependency to service?
How to add endpoint to service?
Where are using statements?

🤔 1. Introducing .NET Minimal APIs

”Do you need all of this stuff just to shorten URL?”

This was a first reaction of a friend (who happens to be a Python programmer) when I showed him my first shortner example. "Yes" would have been a pretty accurate answer, but not the one that I’d be happy with.

There was a lot of boilerplate code compared to other frameworks.
One benefit is that the structure is already set up — very convenient when we have larger projects to tackle. On the other hand, not ideal when I need to create a small service as part of a microservices architecture.
Most SaaS providers are using microservice architecture for its scalability,smaller/faster deployments, and ease of understanding.

Take a look at the Flask API template:

In just 5 lines of code, we have our first endpoint! Single file, no other setup needed. All we need to focus on is the feature of this new service.

Now, let’s take a look at the .NET template. Out of the box we get Startup.cs, Program.cs, Controllers…a lot of boilerplate code. This could be unnecessary if the goal is to write one small service as part of a SaaS product or just a prototype.

Fortunately, .NET6 addresses this issue. Let's rewrite the previous example in .NET6 with a new template.

4 lines of code for our first endpoint and a single file. This is new .NET minimal API!

Back to my friend’s question - “Do you need all of this stuff just to shorten URL?”

No.
I can do better.

✂️ 2. Refactored URL shortener example

A while back, I wrote a post on how to create a URL shortener in .NET5), but I never imagined that I'd be able to rewrite it in 26 lines of code and a single file.

*Note: we actually have two files—we will get to the bottom of that in the fifth section, bear with me.

Refactored code:

You can find the previous URL shortener example in this github repository. There is nothing minimal about the codebase.

If we compare the old code to our minimal shortener, we will see the hidden complexity of the minimal API framework right away.

We start from scratch in the minimal API template and only introduce the dependencies we need. We can concentrate on the important stuff—the code for the requested feature.

Let's analyse the code and see what new things come with .NET6 that you could start implementing in your services.

⚙️ 3. Adding Dependencies

My service needs database, so I'm adding a dependency to LiteDB.

dotnet add package LiteDB

Usually, we would go to Startup.cs and set up our dependency. Since we don’t have one, the way to go is shown below on line 2. Same code, different position.

🔗 4. Adding an Endpoint

All the methods we need are in the app—or should I say framework?

MapGet(pattern, handler)
MapPost(pattern, handler)
MapPut(pattern, handler)
MapDelete(pattern, handler)

Check how to implement POST method and GET method in the example below.

The first parameter is route pattern, the second parameter is handler. The handler is delegate executed when endpoint is matched.

The Url object is record, also something new in .NET6. It could be a class as well, but I just wanted to shred couple of lines of code to get those 26 magic lines.

Data that our POST method (body of req) needs to contain is
defined by the record. (It is enough to send longURL, id will be set automatically by our db)

We have our database in the list of services that our app uses. The next step is to inject it into the endpoint. The delegate needs to have our database context to add data from the client to the database.

In the end, set up your service address and port.
And you are done!

app.Run("http://localhost:4000");

🙋 5. Where are using statements?

Global using statements is another feature I am happy with. Do you remember something like this on top of every file in your project?

using System;
using System.Reflection;
using System.Linq;
using System.Net.Http;
using System.Linq;

Implicit usings are hidden in auto generated file inside your obj folder. That file declares global using statements behind the scenes. If you go to project folder then go obj/Debug/net6.0, you will find a file titled “{ProjectName}.GlobalUsings.g.cs”.

Open this file, and see the content:

Since this is an autogenerated file, we can’t edit it here.
In our minimal shortener we have two packages (LiteDB, Hashids.net) that we depend upon, and we will actually need to place using statements in our Program.cs to use code from packages.

Instead, let's manually create a file that will hold our global using statements. This way, we keep our Program.cs free from all using statements.

It might be overkill in this particular example, but imagine adding more dependencies. It is a good option for keeping code clean.

🎊 So, is it possible? Of course! 🎊

Most of the time, we don’t need all the ceremony that we got with previous .NET webapi templates.

Now we have the option to start from scratch and add only stuff that we really need. Missing MVC Controllers? No problem.Add them later. Need Authentication? Same thing.

The template code has fewer files and a more intuitive setup for newcomers in the .NET world—this is probably one of the best benefits of this framework. I am really looking forward to seeing what future updates bring along.

If you enjoyed following along and building your own URL shortener in .NET6, keep an eye out for this blog!
In the next article, we will place this minimal URL Shortener in Docker and explore another essential piece of the tech stack.

How to schedule tasks in .NET? We've made it seem easy #2

Dino Lozina — Thu, 18 Nov 2021 08:25:29 +0000

Welcome to the second part of the series about "URL shortener in .NET". In the first post of this series we created simple URL shortener web service, and tested it manually with Postman. Check part one here or skip it if you only want to find out how to schedule services in .NET.

In part two, we want to expand functionality of our web service with some additional features, such as SMS reports.

This post aims to show you:

How to send SMS
How to easily add scheduler to our web service
How to send SMS periodically

Use my github to find a finished project and avoid the nuisance of writing the code yourself.

📱 First Step: Send SMS ✔️

For our SMS provider we will use Infobip. Please access our free trial self service account through this link. After grabbing our API key and URL you just need to implement client library in the project.

Library: (github)

dotnet add package Infobip.Api.Client

Then, place your user settings in appsettings.json, so that you can easily grab them through our web app.

Based on Infobip library, we will create method SendNotificationSms:

Let's go through SendNotificationSms(string smsNotificationMessage).

First, we set up the configuration we will send to SendSmsApi class.
Then create SmsTextualMessage by setting up Form, Destination and Text fields.
Finally, add created message to SmsAdvancedTextualRequest.

SendSmsMessage method from Infobip library will do the trick and send the message to our user:

var smsResponse = sendSmsApi.SendSmsMessage(smsRequest);

Now that the basic functionality is up and running, adding it to your scheduler shouldn't be a problem.

⏰ Second Step: Add scheduler ✔️

For this feature we will use Quartz.NET.
One could describe Quartz.NET as a full-featured, open-source job-scheduling system.

There are two important points you need to know; Job Scheduling and Job Execution.

1. Job Scheduling

Jobs are scheduled to run when a given trigger occurs, triggers support wide variety of scheduling options.

2. Job Execution

Jobs can be any .NET class that implements the simple IJob interface, leaving infinite possibilities for the work that jobs can perform.

Lets's add package to our project:

dotnet add package Quartz.Extensions.Hosting

Now, we have to configure and register our Quartz service. Use Program.cs for that. You can follow documentation https://www.quartz-scheduler.net/ on how to configure and register in detail.

In this code example, we try to keep Program.cs as short as possible, hence the extension method for our settings.

⏲️ Third Step: Send SMS periodically ✔️

Scheduler is all set up and now you need to add jobs. In our report feature we decided to send SMS messages daily, weekly and monthly.

Example project has three jobs defined in project Jobs folder.

Remember:

Jobs can be any .NET class that implements the simple IJob interface.

Example code below sends daily SMS report of how many URLs are shortened:

You may ask yourself: Where is the scheduled time in this code? How can I change it?

Well…that is the beauty of Quartz - it uses Cron expression which is easy to set up.
For example, we have moved scheduler setup to our application settings, so there are separate settings for every job in our application.

You can check out for various settings on cron triggers

In our example:

Cron expression: "0 0 8 ? * MON-SUN" -> Daily - MON-SUN on 08:00 CET for the previous day
Cron expression: "0 1 8 ? * MON" -> Weekly - MON on 08:01 CET for the past week
Cron expression: "0 2 8 * * MON#1" -> Monthly - first MON on the month for the past month

If you go back to Program.cs you will see how we grab and use this settings with our extension method.

Now our web service is ready to send scheduled reports to users.

Conclusion 🎉 🍾

It comes as no surprise that scheduling jobs in applications can be a really daunting work. Quartz makes it so much easier. Bare in mind that we just scratched the surface with our settings. There is a lot more stuff under the hood but probably this is enough for most of use cases.

The same thing can be said about our SMS notification feature. You don't need to write API request to Infobip platform. Just add library to your .NET project, set config, create your message objects and than send an SMS. It is also possible to expand this simple example and send reports with other
information channels, such as Email and Whatsapp.
Find other available options on Infobip Api.

Stay well,

Dino

How to write URL shortener in .NET5? We've made it seem easy #1

Dino Lozina — Thu, 11 Nov 2021 09:10:04 +0000

Welcome to our tutorial series, a place to be for those looking for a quick and efficient guide to writing URL shortener.

In this series we will try to show you how easy it is to write a service that shortens URLs with .NET5. On top of that, we will add an additional functionality - service will have to send an SMS when target URL is shortened and periodically send SMS reports.

Stick with me until the end and you will learn how to:

Create youtube like links for short URLs
Use embedded NoSQL database
Schedule web service, ex. send reports every day, week and/or month
Send SMS from our service

Just to give you heads up, this is by no means an extensive tutorial on how to build production grade shortening systems. For production grade systems we need to take into account scale and load. It would be nice to have some kind of analytics, but we have to start from somewhere, right?

Software engineering nowadays can be compared to playing with LEGO bricks. All the nice bricks are out there, we need to implement them in a smart way. We don't want to reinvent the wheel every time we start programming, so we're going to use a couple of packages to make all this magic happen.

First, we're going to need some SDK-s and tools:

For IDE we can use (https://code.visualstudio.com/)
We need .NET core SDK (https://dotnet.microsoft.com/download)
Postman (https://www.postman.com/downloads/)

On my github you will find the finished project so there's no need for you to write code yourself.

Once we have .NET framework in place we will just check if everything is working for us with (type in terminal):

dotnet --version

After the test we can create our template project:

dotnet new webapi -n "Shortener.Service" -lang "C#" -au none

*parameter -au none means there is no default authentication for our webapi

With this command we get template webapi project. Now that we have all things up and running let’s start with step by step guide.

🎮 First Step: Create controller methods ✔️

Remove default web api controller and create your own. For this simple example we will have one GET and one POST method.

Let’s dig into POST method. User will provide us with URL (simple UrlDataDto object) that needs to be shortened. We will store that URL we will store in LiteDB.

GET method needs a parameter shortUrl. If we have that shortUrl in our database, method will redirect us to “long” URL if request was made by browser. Request could also be made by “thin” client like Postman, so we will make sure that we return JSON with “long” URL. (In that case we don’t want to redirect)

💾 Second Step: Add database ✔️

As mentioned, we need DB to store our shortened URLs. For this small service we really don’t want to install DB or do something beforehand. Goal is just to “press play” and our app is ready to go.

dotnet add package LiteDB

This will give us small NoSql database, perfect for our proof of concept.

Now we need to link our application with DB:

⚙️ Third Step: Add services ✔️

As you can see, our controller is simple and whole business logic is in services. Let’s just check what we did in services.

First of all, let's create service that will write data to our DB.

Add to DB:

Get from DB:

We need logic that will shorten our URL. For this we can use cool package Hashids.net and get youtube like short ids. We can chose length and "salt" for our links. Check out hashids.net for short instructions.

For example, if we sent UrlDataDto:

{
  "url": "https://www.infobip.com/docs/api"
}

We get in response nice youtube-like short links:

{
  "url": "http://localhost:8000/V1oExr"
}

Let's add this feature:

dotnet add package Hashids.net

Method in service for encode:

As you can see, we will encode DB id and generate our short URL from that data. (We will use this service in POST method)

Method in service for decode:

Vice versa, on the other endpoint (our GET method) we will decode shortUrl to get id.

🧪 Fourth Step: Test with Postman ✔️

After dotnet build and dotnet run commands you are all set for manual test! Postman collections for you will find as part of the project, so that you can easily import.

POST:

GET:

That's all, folks! Or is it? 🎉 🍾

In part one of this series, we have created a simple URL shortener. We've showed you how to save data without installing database and generate short URLs with Hashids.net.

Application passed our manual test with Postman, and we have set up stage to implement notifications in our web service.

In part two of this series, we will learn how to:

Schedule tasks in .NET applications
Send SMS via Infobip platform

Api Broadcasting with .NET

Dino Lozina — Thu, 14 Oct 2021 07:42:41 +0000

How to notify all your client apps that server content has changed?

That requirement is perhaps a standard nowadays since we have various hungry devices (and minds also 😊) for new notifications. In this article I have tested .NET signalR since it looks like it is easy to deploy, handles connection management automatically and scales easily.

Goal is to write server-side code that can broadcast content changes to client as soon as the content changes. SignalR supports following WebSocekets, Server-Side Events and Long Pooling techniques for handling real-time communication. To communicate between clients and servers SignalR uses hubs. A hub is a high-level pipeline that allows a client and server to call methods on each other and we will write one of those methods.

On my github you will find finished project so that you do not need to write code yourself. We have Web API that knows how to do CRUD operations and client Blazor WebAssembly application that consumes data.

First Step: Define a hub ✔️

We write a custom class, and the most important thing is to inherit from Hub class.

LiveUpdatesHub.cs

using Microsoft.AspNetCore.SignalR;
using System.Threading.Tasks;

namespace PublicAddressBook.Api.Hubs
{
    public class LiveUpdatesHub : Hub
    {
        public async Task LiveUpdate()
        {
            await Clients.All.SendAsync("LiveUpdate");
        }
    }
}

Note: be sure to add using statement for SignalR

Second Step: Configure our newly created class (LiveUpdatesHub) ✔️

All the configuration for .NET 5 or Core applications is done in application Startup.cs. We will need to add endpoint over which we will broadcast data.

Startup.cs

public void ConfigureServices(IServiceCollection services)
        {
            services.AddSignalR();
            services.AddControllers();
            services.AddDbContext<PublicAddressBookContext>(options =>
                     options.UseNpgsql(Configuration.GetConnectionString("PublicAddressBookConnection")));

            services.AddScoped<IContacts, Contacts>();

...(check github for full code ex.)

        }

And also add service in ConfigureServicesMethod:

Startup.cs

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {

...(check github for full code ex.)

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapHub<LiveUpdatesHub>("/liveupdateshub");
                endpoints.MapControllers();
            });
        }

Third Step: Notify change ✔️

In context of this application, I want to notify or perhaps it is better to say broadcast data change. Data will change when our API receives create contact POST request. If the data is OK we will write data to DB. After that we just need to call our Hub method (“LiveUpdate”).

ContactsController.cs

[HttpPost]
public IActionResult CreateContact([FromBody] Contact contact)
{

 ... (check github for full code ex.)

    try
    {
          var createdContact = _contactsService.AddContact(contact);
          // Live Update for Client Apps
          _hub.Clients.All.SendAsync("LiveUpdate");

          return Created("contact", createdContact);
     }
     catch (Exception ex)
     {
          log.Error("PublicAddressBookApiError: ", ex);
          return StatusCode(StatusCodes.Status500InternalServerError);
     }
}

Note:Be sure to add hub service to controller constructor

Fourth Step: Consume changed data ✔️

Since we stayed in .NET world it is easy to consume "data change event" or should I say listen to changes on client side.
In our Blazor component in method OnInitializedAsync() we will make a new instance of hub HubConnectionBuilder() and register what we are listening for.

ContactOverview.razor.cs

namespace PublicAddressBook.Client.Pages
{

... (check github for full code ex.)

    public partial class ContactOverview
    {

        protected override async Task OnInitializedAsync()
        {
            hubConnection = new HubConnectionBuilder()
            .WithUrl(NavigationManager.ToAbsoluteUri(baseUrl + liveUpdateEndPoint))
            .Build();

            hubConnection.On("LiveUpdate", () =>
            {
                GetLiveNotificationData();
                StateHasChanged();
            });

            await hubConnection.StartAsync();

            await GetData();
        }

}

Note: On client side, be sure to add SignalR client package

Conclusion 🎉 🍾

As you can se from this example it is very easy to set up real-time updates with SignalR. On client side you are of course not limited to .NET client and on this link you can find examples for JavaScript and TypeScript. Also, I must mention that your hub method can have parameters, there is a nice chat example on fore mentioned link.

Stay well,

Dino