DEV Community: YASH MAISURIYA

Demystifying NuGet Packages: A Comprehensive Guide🚀

YASH MAISURIYA — Mon, 02 Jun 2025 16:27:35 +0000

Introduction 📦

NuGet packages are essential for modern .NET development, providing a convenient way to share and reuse code. They offer numerous benefits, including increased code reusability, simplified dependency management, and faster development cycles. 🚀

What are NuGet Packages? ❓

A NuGet package is a single ZIP file with the .nupkg extension that contains compiled code (DLLs), libraries, and other related files, along with a manifest file called .nuspec that contains package metadata like the package name, version, description, and dependencies.📁

NuGet packages are typically hosted on the NuGet Gallery (nuget.org)🌐, a central repository for .NET libraries. However, you can also host NuGet packages on other platforms like Azure Artifacts or MyGet☁️.

How to Create a NuGet Package🛠️

Here's how to create a NuGet package:

Create a .NET Library Project: Start by creating a new .NET library project in Visual Studio or using the .NET CLI (dotnet new classlib).🧱

Add a .nuspec File (or use .csproj): A .nuspec file is an XML manifest that contains metadata about the package. Alternatively, you can include the package metadata directly in the .csproj file. Here's an example of a simple .nuspec file:📦

<?xml version="1.0"?>
<package >
  <metadata>
    <id>EasyLogger</id>
    <version>1.0.0</version>
    <authors>Yash</authors>
    <description>A simple logging library.</description>
    <dependencies>
    </dependencies>
  </metadata>
</package>

Build the Project: Build the library project to generate the DLL files.🧰
Use the nuget pack Command: Open a command prompt in the project directory and run the nuget pack command to create the .nupkg file. If using the .csproj file for package metadata, the command is dotnet pack.💼

Here's an example of a simple logger class that can be packaged into a NuGet package:

using System;
using System.Diagnostics;
using System.IO;

namespace EasyLogger
{
    public static class Logger
    {
        private const string DefaultFilePath = "log.txt";

        public static void LogInfo(string message, LogTarget target = LogTarget.All, string filePath = DefaultFilePath)
            => Log("INFO", message, target, filePath);

        public static void LogWarning(string message, LogTarget target = LogTarget.All, string filePath = DefaultFilePath)
            => Log("WARNING", message, target, filePath);

        public static void LogError(string message, LogTarget target = LogTarget.All, string filePath = DefaultFilePath)
            => Log("ERROR", message, target, filePath);

        private static void Log(string level, string message, LogTarget target, string filePath)
        {
            string logMessage = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} [{level}] {message}";

            if (target.HasFlag(LogTarget.Console))
                Console.WriteLine(logMessage);

            if (target.HasFlag(LogTarget.Debug))
                Debug.WriteLine(logMessage);

            if (target.HasFlag(LogTarget.File))
                File.AppendAllText(filePath, logMessage + Environment.NewLine);
        }
    }
    [Flags]
    public enum LogTarget
    {
        None = 0,
        Console = 1,
        Debug = 2,
        File = 4,
        All = Console | Debug | File
    }
}

How to Publish a NuGet Package 🚀📤

To publish a NuGet package to the NuGet Gallery:

Create an Account on NuGet.org: Go to nuget.org and create a new account.👤
Obtain an API Key: After creating an account, go to your account settings and generate an API key. This key is used to authenticate when publishing packages.🔑
Use the nuget push Command: Use the nuget push command to upload the .nupkg file to the NuGet Gallery.
```
nuget push EasyLogger.1.0.0.nupkg -Source https://api.nuget.org/v3/index.json -ApiKey YOUR_API_KEY
```
Replace YOUR_API_KEY with your actual API key. If using dotnet pack, the command is dotnet nuget push.

How to Use a NuGet Package📥📦

To use a NuGet package in your .NET project:

Using NuGet Package Manager (Visual Studio): In Visual Studio, right-click on your project in the Solution Explorer, select "Manage NuGet Packages...", and search for the package you want to install.
Using the .NET CLI: Use the dotnet add package command in the .NET CLI.
```
dotnet add package EasyLogger
```
Use the Package in Code: After installing the package, you can use it in your code by adding the appropriate using statements and referencing the classes and methods provided by the package.✍️

Here's an example of how to use the EasyLogger package in a separate TestLogger project:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using EasyLogger;
using System.IO;

namespace TestLogger
{

    public class Class1
    {
        static void Main(string[] args)
        {
            string downloadsPath = Path.Combine(
              Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
              "Downloads",
              "mylog.txt");
            Logger.LogError("This is an info message.", LogTarget.File, downloadsPath);
        }

    }
}

Conclusion✅

NuGet packages are a powerful tool for sharing and reusing code in .NET development. By creating and publishing your own packages, you can contribute to the .NET ecosystem and help other developers build better applications faster. 💡💻🌍

🔗 GitHub Repository: https://github.com/YashMaisuirya13/EasyLogger.git
📦 Feel free to check out the source code, contribute, or raise issues!

🧱 Building a Todo List API with .NET Core Minimal APIs 🚀 A Simple & Powerful Guide

YASH MAISURIYA — Tue, 20 May 2025 17:11:12 +0000

🚀 .NET Core's Minimal APIs offer a streamlined approach to building HTTP APIs with reduced boilerplate. This post walks you through creating a Todo list API from scratch, showcasing the simplicity and power of Minimal APIs.

Prerequisites

.NET Core SDK (latest version recommended)
A code editor (VS Code, JetBrains Rider, etc.)
Basic understanding of C# and RESTful API concepts
Visual Studio 2022 or later (for using Endpoints Explorer)

Project Setup

Create a new Web API project:

dotnet new webapi -o MinimalTodoApi
cd MinimalTodoApi

Install Entity Framework Core packages:

We'll use EF Core for data persistence. Install the necessary packages:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer  # Or your preferred database provider
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.Tools

Defining the Todo Model

Create a Models directory and add a Todo.cs file:

namespace MinimalTodoApi.Models;

public class Todo
{
    // Unique identifier for the Todo item
    public Guid Id { get; set; }

    // Name or description of the Todo item
    public string? Name { get; set; }

    // Indicates whether the Todo item is complete
    public bool IsComplete { get; set; }
}

This simple model defines the structure of our Todo items.

Setting up the Database Context

Create a Data directory and add TodoDb.cs:

using Microsoft.EntityFrameworkCore;
using MinimalTodoApi.Models;

namespace MinimalTodoApi.Data;

// Represents the database context for the Todo application
public class TodoDb : DbContext
{
    // Constructor that accepts DbContextOptions
    public TodoDb(DbContextOptions<TodoDb> options) : base(options) { }

    // Represents the collection of Todo items in the database
    public DbSet<Todo> Todos { get; set; }
}

This class sets up our database context using Entity Framework Core.

Configuring the Minimal API Endpoints (Program.cs)

Now, let's define our API endpoints within Program.cs:

using Microsoft.EntityFrameworkCore;
using MinimalTodoApi.Data;
using MinimalTodoApi.Models;

var builder = WebApplication.CreateBuilder(args);

// Add the database context to the services container.  This allows the database to be injected into the API endpoints.
builder.Services.AddDbContext<TodoDb>(options
    => options.UseSqlServer(builder.Configuration.GetConnectionString("MinimalTodo"))
    );

var app = builder.Build();

// Configure the API endpoints

// Get all todo items
app.MapGet("/todos", async (TodoDb db) =>
    await db.Todos.ToListAsync());

// Get completed todo items
app.MapGet("/todos/complete", async (TodoDb db) =>
    await db.Todos.Where(t => t.IsComplete).ToListAsync());

// Get a specific todo item by ID
app.MapGet("/todos/{id}", async (Guid id, TodoDb db) =>
    await db.Todos.FindAsync(id)
        is Todo todo
            ? Results.Ok(todo)
            : Results.NotFound());

// Create a new todo item
app.MapPost("/todos", async (Todo todo, TodoDb db) =>
{
    db.Todos.Add(todo);
    await db.SaveChangesAsync();

    return Results.Created($"/todos/{todo.Id}", todo);
});

// Update an existing todo item
app.MapPut("/todos/{id}", async (Guid id, Todo inputTodo, TodoDb db) =>
{
    var todo = await db.Todos.FindAsync(id);
    if (todo is null) return Results.NotFound();

    todo.Name = inputTodo.Name;
    todo.IsComplete = inputTodo.IsComplete;
    await db.SaveChangesAsync();
    return Results.NoContent();
});

// Delete a todo item
app.MapDelete("/todos/{id}", async (Guid id, TodoDb db) =>
{
    if (await db.Todos.FindAsync(id) is Todo todo)
    {
        db.Todos.Remove(todo);
        await db.SaveChangesAsync();
        return Results.NoContent();
    }
    return Results.NotFound();
});

app.Run();

Key improvements and explanations:

Clear separation of concerns: Models in Models, database context in Data.
Concise endpoint definitions: Minimal APIs make routing and logic clear.
Dependency Injection: The TodoDb context is injected directly into the endpoint handlers.
Asynchronous operations: Using async and await for non-blocking database calls.

Database Configuration

Update appsettings.json:

Configure your database connection string. For example, using SQL Server:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "ConnectionStrings": {
    "MinimalTodo": "Server=(localdb)\\mssqllocaldb;Database=MinimalTodo;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "AllowedHosts": "*"
}

Create and apply migrations:

dotnet ef migrations add InitialCreate
dotnet ef database update

Running the API

dotnet run

Your Todo API is now running!

Testing the API with Endpoints Explorer (Visual Studio)

Visual Studio provides a built-in tool to explore and test your API endpoints:

Open Endpoints Explorer: In Visual Studio, go to View > Other Windows > Endpoints Explorer.
Locate your API endpoints: The Endpoints Explorer will display a list of all available API endpoints in your project. You should see the /todos endpoints listed.
Test the endpoints: You can right-click on an endpoint and select "Generate Request" to create a sample HTTP request. Modify the request as needed (e.g., add a request body for POST/PUT requests) and then click "Send Request" to test the endpoint. The response will be displayed in a separate window.

Conclusion

.NET Core Minimal APIs provide a powerful and elegant way to build APIs with minimal code. This Todo list example demonstrates the core concepts and provides a foundation for building more complex applications. Embrace the simplicity and efficiency of Minimal APIs in your next .NET project!

🔗 Useful Links
📘 Official Docs: Minimal APIs in ASP.NET Core
📦 GitHub Sample: Todo API with Minimal APIs

🚀 Dockerizing and Setting Up CI/CD for a .NET API with GitLab

YASH MAISURIYA — Thu, 24 Apr 2025 16:16:34 +0000

In this guide, we'll walk through the steps to containerize a .NET API using Docker and set up a CI/CD pipeline with GitLab. This setup enables automatic building, testing, and deployment of your application, ensuring a smoother development lifecycle.

✅ Prerequisites
Before getting started, make sure you have the following:

A .NET API project (.NET 8 or compatible)
A GitLab account with a repository
Docker installed on your local machine

🐳 Dockerizing the .NET API

Create a Dockerfile in the root of your project directory. This file defines how to build your Docker image.

# Base image for running the app
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

# Build image
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["blog.backend.api/blog.backend.api.csproj", "blog.backend.api/"]
RUN dotnet restore "blog.backend.api/blog.backend.api.csproj"
COPY . .
WORKDIR "/src/blog.backend.api"
RUN dotnet build "blog.backend.api.csproj" -c Release -o /app/build

# Publish image
FROM build AS publish
RUN dotnet publish "blog.backend.api.csproj" -c Release -o /app/publish /p:UseAppHost=false

# Final image
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "blog.backend.api.dll"]

⚙️ Setting Up the GitLab CI/CD Pipeline

Create a .gitlab-ci.yml file at the root of your repository:

image: docker:latest

services:
  - docker:dind

stages:
  - build
  - test
  - deploy

variables:
  DOCKER_IMAGE: registry.gitlab.com/yash-project/blogApplicationAPI
  DOCKER_TAG: latest

build:
  stage: build
  script:
    - docker build -f Dockerfile -t $DOCKER_IMAGE:$DOCKER_TAG .
    - echo "$CI_REGISTRY_PASSWORD" | docker login -u "$CI_REGISTRY_USER" --password-stdin $CI_REGISTRY
    - docker push $DOCKER_IMAGE:$DOCKER_TAG

test:
  stage: test
  image: mcr.microsoft.com/dotnet/sdk:8.0
  script:
    - dotnet test

deploy:
  stage: deploy
  script:
    - echo "Deploying using Docker Compose..."
    - docker-compose up -d
  only:
    - main

This pipeline includes three stages:

Build: Builds and pushes the Docker image to GitLab's container registry.
Test: Runs your unit/integration tests.
Deploy: Spins up the container using Docker Compose.

📦 Docker Compose Deployment
Create a docker-compose.yml file:

version: "3.9"

services:
  blog-backend-api:
    image: registry.gitlab.com/yash-project/blogApplicationAPI:latest
    ports:
      - "80:80"

This simple setup pulls the latest image and runs your API on port 80.

🎯 Conclusion
By combining Docker with GitLab CI/CD, you now have a robust and automated workflow for building, testing, and deploying your .NET API. This approach streamlines development and ensures consistency across environments.

🚀 Building a Custom Windows Installer with Inno Setup for WPF Applications 💻✨

YASH MAISURIYA — Sat, 12 Apr 2025 08:17:39 +0000

After completing my WPF application, it was time to wrap it up in a clean, user-friendly installer. Like many developers, I initially turned to Visual Studio’s Setup Wizard (Setup Project). While it gets the job done for basic packaging, I quickly ran into its limitations — especially when it came to customization.

Here’s a quick overview of why I made the switch, what I needed, and how Inno Setup gave me the flexibility I was looking for.

🤔 Why I Left the Setup Wizard Behind
Initially, I used the built-in Setup Wizard provided by Visual Studio. It’s a drag-and-drop experience that’s great for simple installers, but here's what I couldn’t do with it:

❌ No option to create a desktop shortcut
❌ No way to auto-launch the application after installation
❌ No custom branding or installation logic
❌ Limited control over registry entries and version checks

I needed more — something that would allow me to create a polished, professional installer. That’s when I discovered Inno Setup.

✅ What I Achieved with Inno Setup:

✅ Created desktop & Start Menu shortcuts
✅ Launched app after installation
✅ Added registry keys for license/trial handling
✅ Branded the installer with a custom icon and app name
✅ Controlled version checks and clean uninstall support

🔧 Brief Explanation of the Installer Script
This Inno Setup script creates a custom Windows installer for testApplication. Here's a breakdown of its key components:

[Setup]: Defines the application name, version, output file, privileges, and installer behavior (like compression and icon).
[Languages]: Adds support for English language messages.
[Files]: Includes:
- The main .exe, .dll, and .config files.
- SQLite-specific files like SQLite.Interop.dll.
- Additional resources like images and default songs.
- Temporary files like EULA and Terms text.
[Icons]: Adds Start Menu and Desktop shortcuts (controlled by user selection).
[Run]: Optionally runs the application after installation.
[Code]:
- Adds custom wizard pages for Terms & Conditions, License Agreement, and Install Options.
- Provides checkboxes for:
  - Accepting license terms.
  - Creating desktop shortcuts.
  - Running the app post-install.
- Validates if the license checkbox is checked before proceeding.

📁 Full Script on GitHub Gist:
https://github.com/YashMaisuirya13/InnoScriptWpf.git

💡Pro Tips
🛠️ Use Inno Script Studio or ISTool for a more visual experience when editing scripts.
📁 {app} is a helpful macro that points to the installation directory.
🧠 Use the [Code] section for advanced logic like checking existing versions or validating registry keys.
🧪 Always test your installer in a clean VM or sandbox environment.

With Inno Setup, I was finally able to deliver an installer that matched the polish and professionalism of the application itself.

Let me know if you’d like help building your own installer!