URL shortening

Here's a step-by-step guide with a sample implementation.

Step 1: Create a new .NET Core Web API Project

Open Visual Studio or your preferred code editor and create a new .NET Core Web API project.

Step 2: Install Required Packages

You'll need the Entity Framework Core package to work with a database and a package for generating random strings. Install these packages using NuGet Package Manager or the .NET CLI:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package System.Data.SqlClient
dotnet add package System.Data.Common
dotnet add package System.Data.Common.Safety
dotnet add package System.Data.SqlClient.Safety

Step 3: Create a Model

Create a model to represent the URL mappings. In this example, we'll use Entity Framework Core for data access.

// Models/UrlMapping.cs
using System.ComponentModel.DataAnnotations;

public class UrlMapping
{
    [Key]
    public int Id { get; set; }

    [Required]
    public string LongUrl { get; set; }

    [Required]
    public string ShortUrl { get; set; }
}

Step 4: Set up the Database Context

Create a database context class to manage the URL mappings in the database.

// Data/UrlShorteningContext.cs
using Microsoft.EntityFrameworkCore;

public class UrlShorteningContext : DbContext
{
    public UrlShorteningContext(DbContextOptions options)
        : base(options)
    {
    }

    public DbSet UrlMappings { get; set; }
}

Step 5: Configure Database Connection

In your appsettings.json or appsettings.Development.json file, add the connection string for your database:

{
  "ConnectionStrings": {
    "DefaultConnection": "your_connection_string_here"
  },
  // ...
}

Step 6: Configure Entity Framework

In the Startup.cs file, configure Entity Framework to use the database connection.

// Startup.cs
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
// ...

public void ConfigureServices(IServiceCollection services)
{
    // ...
    services.AddDbContext(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    // ...
}

Step 7: Create Shortening Logic

Now, create a service that handles URL shortening logic. Here's a simple implementation using random string generation:

// Services/UrlShorteningService.cs
using System;
using System.Linq;
using Microsoft.EntityFrameworkCore;

public class UrlShorteningService
{
    private readonly UrlShorteningContext _context;
    private const string Characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    private const int ShortUrlLength = 6;

    public UrlShorteningService(UrlShorteningContext context)
    {
        _context = context;
    }

    public string ShortenUrl(string longUrl)
    {
        var existingMapping = _context.UrlMappings.FirstOrDefault(x => x.LongUrl == longUrl);
        if (existingMapping != null)
        {
            return existingMapping.ShortUrl;
        }

        var random = new Random();
        var shortUrl = new string(Enumerable.Repeat(Characters, ShortUrlLength)
            .Select(s => s[random.Next(s.Length)]).ToArray());

        _context.UrlMappings.Add(new UrlMapping { LongUrl = longUrl, ShortUrl = shortUrl });
        _context.SaveChanges();

        return shortUrl;
    }

    public string GetLongUrl(string shortUrl)
    {
        var mapping = _context.UrlMappings.FirstOrDefault(x => x.ShortUrl == shortUrl);
        return mapping?.LongUrl;
    }
}

Step 8: Create API Controllers

Create API controllers to expose the URL shortening functionality.

// Controllers/UrlShorteningController.cs
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class UrlShorteningController : ControllerBase
{
    private readonly UrlShorteningService _urlShorteningService;

    public UrlShorteningController(UrlShorteningService urlShorteningService)
    {
        _urlShorteningService = urlShorteningService;
    }

    [HttpPost("shorten")]
    public IActionResult ShortenUrl([FromBody] string longUrl)
    {
        var shortUrl = _urlShorteningService.ShortenUrl(longUrl);
        return Ok(shortUrl);
    }

    [HttpGet("expand/{shortUrl}")]
    public IActionResult ExpandUrl(string shortUrl)
    {
        var longUrl = _urlShorteningService.GetLongUrl(shortUrl);
        if (longUrl == null)
        {
            return NotFound();
        }
        return Ok(longUrl);
    }
}

Step 9: Run Migrations and Start the Application

Run the following commands to create and apply migrations:

dotnet ef migrations add InitialCreate
dotnet ef database update

Finally, run your .NET Core application:

dotnet run

Your URL shortening service should now be up and running, exposing two endpoints: /api/urlshortening/shorten for shortening URLs and /api/urlshortening/expand/{shortUrl} for expanding short URLs into their original form.

You can test the API using a tool like Postman or curl.

Remember that this is a simple example, and you may want to add more features and error handling to make it production-ready. Additionally, consider securing your API and validating URLs before shortening them.