DEV Community: Diana Iminza

LogLens AI: A Local-First AI Assistant for Understanding .NET Errors

Diana Iminza — Wed, 14 Oct 2026 12:01:40 +0000

Have you ever opened an application log, found a long stack trace, and spent the next hour trying to figure out what actually went wrong?

As developers, we get used to reading exceptions. But understanding an error quickly is not always easy, especially when the logs come from a background worker, a third-party API, a message consumer, or a service running in production.

Sometimes the exception tells us exactly what happened. Other times, it only gives us the starting point for an investigation.

That got me thinking: What if developers could ask an AI assistant to explain an error without needing to send their logs to a hosted AI service?

That is the idea behind LogLens AI.

What I Built

LogLens AI is a small AI-powered debugging assistant designed for .NET developers.

The goal is simple: paste an exception or log excerpt, ask for an explanation, and receive a structured response that helps you investigate the problem.

The assistant is intended to provide:

Plain-English explanations: What the exception means.
Likely causes: Possible reasons the error occurred, based on the supplied evidence.
Debugging steps: What to inspect next.
Suggested fixes: Potential changes to investigate, rather than unverified guarantees.
Evidence and limitations: Which parts of the log support the explanation and what additional information might be needed.

For example, a developer could submit a NullReferenceException from a background service and ask the tool to explain the likely cause, identify what to inspect, and suggest a way to prevent the same failure.

The first version focuses on .NET exceptions and application logs rather than trying to become a general-purpose AI agent.

Demo

Code

GitHub repository: https://github.com/Dianaiminza/LogLensAI

How I Built It

I chose a small architecture that keeps the application understandable and easy to run locally.

The technology stack

C# and ASP.NET Core Minimal API for the backend.
HTML, CSS, and JavaScript for the initial interface.
Ollama for local model inference.
An open-weight language model compatible with the local inference setup.
xUnit for automated tests.
Docker for optional containerised setup.

The API receives the log excerpt, validates the request, applies basic sanitisation, and constructs a prompt asking the model to explain the error in a consistent format.

The model returns the analysis, which the interface displays to the developer.

Why use a local model?

Sending logs to an external service can be a concern when they contain internal hostnames, account identifiers, access tokens, or other sensitive information.

Running inference locally offers a way to keep the model interaction on the developer's machine. It does not eliminate every privacy or security risk, so the application also needs input validation, secret redaction, and careful handling of diagnostic data.

Why keep the first version small?

It would be tempting to introduce agents, multiple model providers, vector databases, and complex orchestration immediately.

But the first question is much simpler:

Can a developer provide an ordinary .NET exception and receive an explanation that genuinely helps them debug it?

That is the core workflow I want to build and test first.

Why Does Open Innovation Matter?

Open innovation matters because useful developer tools should not be limited to teams that can afford expensive subscriptions or proprietary infrastructure.

Open-weight models, open-source libraries, and community-maintained tools make it possible for individual developers to experiment, learn, and build practical applications using technology that is accessible to them.

For a project like LogLens AI, openness has several benefits:

Accessibility: Developers can experiment with local AI without making a hosted AI subscription a requirement.
Transparency: The source code can be inspected, tested, and improved by the community.
Adaptability: Developers can modify the prompts, parsing logic, and model configuration for their own workflows.
Community learning: Contributors can learn about ASP.NET Core, local inference, prompt design, testing, and responsible AI integration in one small project.

Open innovation is not just about making source code public. It is also about making the technology understandable, usable, and open to improvement.

The initial test cases will include:

A NullReferenceException.
An HTTP request failure.
A database connection exception.
An invalid or empty request.
A model service that is unavailable.
A log excerpt containing a test credential that should be redacted.

The aim is not to prove that AI can replace debugging. It is to see whether a small, local-first assistant can make the initial investigation faster and clearer.

What's Next?

The first milestone is a working local application with a simple interface, a functioning model integration, and automated tests.

After that, possible improvements include support for structured JSON logs, configurable redaction rules, exportable diagnostic reports, and Docker-based setup.

I would also like to hear from .NET developers about which errors they spend the most time investigating and what information they would want an AI debugging assistant to provide.

If you could automate one frustrating part of debugging a .NET application, what would it be?

Built for the DEV Community's Hacktoberfest Open-Source AI Challenge: Side Hustle!

Cybersecurity Is a Developer's Responsibility, Not Just the Security Team's

Diana Iminza — Tue, 13 Oct 2026 12:12:14 +0000

Cybersecurity is often treated as something that happens after an application has been built. Developers focus on functionality, deadlines, and user experience, while security is left to a separate team.

But what if some of the most important security decisions happen before an application is even deployed?

As a software developer and cybersecurity enthusiast, I've been thinking about how the small decisions we make while writing code can have a major impact on the security of the systems we build.

For Cybersecurity Awareness Month, I want to highlight a simple idea: building secure software starts with everyday development habits.

1. Never trust user input

Every application receives input from somewhere: a form, an API request, a mobile application, or another service.

The mistake is assuming that this input is always valid or trustworthy.

Depending on how it is handled, untrusted input can lead to SQL injection, cross-site scripting, or other vulnerabilities.

For example, avoid constructing SQL queries by concatenating user input into a query string. Use parameterized queries or a trusted ORM that safely handles query parameters.

Security begins by treating external input as untrusted and validating it at the appropriate boundaries.

2. Keep secrets out of your source code

API keys, database passwords, signing keys, and access tokens should never be committed to a public repository.

Even private repositories can be exposed through compromised accounts, misconfigured permissions, or accidental sharing.

A few habits make a difference:

Store application secrets in an appropriate secret manager or secure configuration mechanism.
Use environment-specific configuration.
Scan repositories for accidentally committed credentials.
Revoke and rotate exposed secrets immediately.

One important lesson: deleting a secret from the latest commit does not necessarily remove it from Git history. Treat an exposed credential as compromised.

3. Authentication is not authorization

Authentication answers the question: Who are you?

Authorization answers: What are you allowed to do?

A user may successfully log in but still have no right to view another customer's transaction, change another person's account details, or perform an administrative action.

Applications must enforce authorization on the server for every relevant operation. Hiding a button in the interface is not a security control.

This is particularly important in financial applications, where an authorization failure could expose sensitive data or enable unauthorized transactions.

4. Protect your APIs

Modern applications depend on APIs to exchange data between mobile clients, web applications, and backend services.

A secure API should consider:

Strong authentication and correct token validation.
Object-level authorization.
Rate limiting and abuse prevention.
Safe error messages.
Request validation and replay protection where appropriate.
Logging and monitoring without exposing credentials or sensitive personal data.

Having an access token does not automatically make an API request safe. The backend must still verify that the caller is entitled to perform the requested operation.

5. Make security part of your workflow

Security does not have to be a final checklist before deployment.

It can be incorporated into everyday engineering through code reviews, automated tests, dependency scanning, static analysis, secret scanning, and threat modelling.

Before merging a change, ask:

Could this expose sensitive information?
Can another user access a resource they do not own?
Are errors revealing internal implementation details?
Have I introduced an unsafe dependency or configuration?
What happens if someone sends an unexpected request?

These questions will not eliminate every vulnerability, but they help make security a normal part of engineering rather than an afterthought.

Final thoughts

Cybersecurity is a shared responsibility, and developers are in a strong position to make a difference.

We do not need to know everything about security before we start making better decisions. We can begin by understanding common vulnerabilities, learning secure coding practices, and testing our assumptions.

This Cybersecurity Awareness Month, I'm challenging myself to keep learning, build more secure applications, and share practical lessons with the developer community.

What is one security practice you believe every developer should adopt? I'd love to hear your thoughts.

It Worked on My Machine. Docker Asked, “Which Machine?”

Diana Iminza — Tue, 13 Oct 2026 11:03:03 +0000

If you've been building applications with C#, you've probably experienced this at least once.

Your API runs perfectly on your laptop. Your database connection works. Your background worker processes messages. Everything looks good.

Then you deploy it to another environment.

Suddenly, something breaks.

Maybe the server has a different runtime. Maybe an environment variable is missing. Maybe a dependency behaves differently. Or maybe the application expects a service that isn't running.

And now you're debugging the environment instead of your code.

This is one of the problems Docker helps solve.

Think of Your Application as a Delivery Package

When you publish a .NET application, you usually focus on the application itself.

You compile the code, produce the build output, configure the server, install the required runtime when necessary, set environment variables, and make sure external services are available.

That's a lot of moving parts.

Docker encourages you to describe the application's runtime environment alongside the application.

Instead of handing someone just your application and a list of setup instructions, you build an image that packages the application with its required runtime components and dependencies.

The goal is simple: make the application easier to run consistently across different environments.

Let's Make It Practical

Suppose you have an ASP.NET Core API.

On your machine, you run:

dotnet run

Everything works.

Now you want another developer to run the same API without manually reproducing your setup.

You create a Dockerfile:

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src

COPY . .
RUN dotnet publish MyApi.csproj \
    -c Release \
    -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app

COPY --from=build /app/publish .

ENTRYPOINT ["dotnet", "MyApi.dll"]

Build the image:

docker build -t my-api .

Run it:

docker run --rm -p 8080:8080 my-api

Assuming the application is configured to listen on port 8080, your API is now accessible through the mapped host port.

You've described how to build the application package and how to start it. Someone else with a compatible Docker environment can use the same image rather than manually installing your application's runtime dependencies.

For a real project, you'd also configure environment-specific settings, secrets, networking, and persistent storage where needed.

But Here's What Docker Doesn't Magically Fix

This is where I think developers sometimes misunderstand containerisation.

Docker doesn't automatically make bad code good.

It won't fix a database query that takes ten seconds. It won't prevent duplicate payment processing. It won't make a failing external API reliable. And it won't secure an application simply because it runs inside a container.

If your application has a race condition, you can still have that race condition inside Docker.

If your worker processes the same transaction twice, containerising it won't solve the underlying idempotency problem.

Docker gives you a more consistent way to package and run software. Application correctness, resilience, and security still require deliberate engineering.

That distinction matters, especially when you're building APIs, payment services, or background workers.

Where Docker Gets Really Useful

The real benefit becomes more obvious when your application grows beyond a single API.

Imagine a .NET payment system containing:

An ASP.NET Core API that receives requests.
A background worker that processes queued transactions.
A PostgreSQL database that stores records.
A message broker that distributes events.

You can use Docker Compose to define the services and how they connect.

Your local environment becomes something you can describe in a file, share with your team, and recreate when needed.

That doesn't mean every production system should run exactly like your local Compose environment. Production still needs proper secrets management, monitoring, backups, access controls, and deployment practices.

But having a reproducible starting point makes development and troubleshooting much easier.

My Biggest Takeaway

I used to think of deployment as the final step after writing the code.

Now, I think of the runtime environment as part of the application engineering process.

The code matters, but so does the environment in which that code executes.

Docker helps bring those two concerns closer together.

And perhaps that's the most useful way to approach learning it: don't start by memorising commands. Start with an application you already understand, package it, run it in isolation, and see what changes when you move it between environments.

You'll quickly discover which parts of your application were truly portable and which parts were relying on your machine without you realising it.

Question for fellow .NET developers:

What's the most frustrating “works on my machine” bug you've encountered, and did Docker solve it—or just reveal a different problem?

6 Types of Constructor in C#

Diana Iminza — Mon, 15 Sep 2025 10:40:15 +0000

What is a Constructor?
A constructor is a special method in a class or struct that gets called automatically when an instance of the object is created. It initializes the object and sets up its initial state.

Basic syntax:

public class Car
{
    public string Model;

    // Constructor
    public Car()
    {
        Model = "Audi";
    }
}

Types of constructors available in C#.

Default Constructor

A default constructor is one that takes no parameters. If you don't define any constructor, C# provides a default constructor automatically.

Example:

public class Person
{
    public string Name;

    // Default constructor
    public Person()
    {
        Name = "Test";
    }
}

Use Case:

Initialize default values when the object is instantiated.

Parameterized Constructor

A parameterized constructor allows you to _pass parameters _when creating an object. This helps initialize an object with custom values.

Example:

public class Person
{
    public string Name;
    public int Age;

    // Parameterized constructor
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

Use Case:

Provides flexibility to initialize objects with different values.

Copy Constructor

A copy constructor creates a new object by copying data from an existing object of the same class.

Example:

public class Product
{
    public string Name;
    public double Price;

    // Copy constructor
    public Product(Product p)
    {
        this.Name = p.Name;
        this.Price = p.Price;
    }
}

Use Case:

Useful in cloning objects.

Static Constructor

A static constructor is used to initialize static data members _of a class or to perform actions that only need to happen once.
Automatically _called once, before the first instance is created or any static members are accessed.

Example:

public class Logger
{
    static Logger()
    {
        Console.WriteLine("Logger Initialized");
    }
}

Use Case:

Initialize static fields, set up logging, read configuration files, etc.

📌 Key Notes:

No parameters
No access modifiers
Executes once before the first object or static member is accessed

Private Constructor

A private constructor restricts the instantiation of a class from outside. It is commonly used in singleton patterns or_ static classes_.

Example:

public class Configuration
{
    private Configuration()
    {
        // Prevent external instantiation
    }
}

Use Case:

Prevent object creation; enforce controlled access via static members.

Constructor Overloading

C# allows constructor overloading, which means a class can have multiple constructors with different parameter lists.

Example:

public class Rectangle
{
    public int Width;
    public int Height;

    public Rectangle()
    {
        Width = 10;
        Height = 20;
    }

    public Rectangle(int width, int height)
    {
        Width = width;
        Height = height;
    }
}

Use Case:

Provide flexibility in object creation.

Happy coding! 👨‍💻👩‍💻

Caching in .NET Applications

Diana Iminza — Sun, 02 Mar 2025 09:53:31 +0000

Caching is a technique for storing frequently accessed data in a fast storage medium, reducing the need to retrieve it from a slower data source. In .NET applications, as in other systems, caching improves performance, minimizes latency, and reduces consumption (cost).

Why Use Caching in .NET?
Caching can significantly improve your application’s performance in the following ways:

- Reduced Latency:Data retrieval from memory is faster than querying a database or calling an API.
- Lower Database Load:By caching the results of frequent queries, you can reduce the load on your database or other data sources.
- Cost Efficiency:For applications that interact with external services or APIs, caching responses can help minimize costs associated with API calls.

In this article, we’ll use a simple example to demonstrate how caching can be implemented and how it can improve performance.

Types of Caching in .NET

- In-Memory Caching: Data is stored in the memory of the application server. This is ideal for single-instance applications and offers extremely fast access times. It uses IMemoryCache in .NET.
The MemoryCache _class in .NET is part of the _Microsoft.Extensions.Caching.Memory namespace.

- Distributed Caching:Distributed caching allows the cache to be shared across multiple servers. This is particularly beneficial in a microservices architecture where the application is deployed across multiple servers. Redis and SQL Server are popular choices for distributed caching in .NET Core. Uses IDistributedCache in .NET.

- Response Caching: This type involves caching the response of a web request. It’s particularly useful for web APIs or web pages where the content doesn’t change frequently. Cache HTTP responses to reduce the load on the backend.

Implementing Caching in ASP.NET Core
ASP.NET Core provides built-in support for in-memory caching and distributed caching using services like IMemoryCache and IDistributedCache. These caching mechanisms can be easily configured in Startup.cs or Program.cs.

Add the necessary NuGet package for caching:
dotnet add package Microsoft.Extensions.Caching.Memory

Example: Caching in ASP.NET Core

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMemoryCache();  // In-memory caching
        services.AddDistributedRedisCache(options =>
        {
            options.Configuration = "localhost";  // Redis server configuration
            options.InstanceName = "Test:";
        });
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapGet("/", async context =>
            {
                var cache = context.RequestServices.GetRequiredService<IMemoryCache>();
                string user = cache.Get<string>("user123");
                if (user == null)
                {
                    user = "John Doe"; // Simulating fetching data
                    cache.Set("user123", user);
                }

                await context.Response.WriteAsync($"User: {user}");
            });
        });
    }
}

Response Caching
Response caching can be implemented using middleware in the Program.cs file. You can configure the caching behavior using the ResponseCache attribute on your action methods.

// Configure 
builder.services.AddResponseCaching();
...
//Use
app.UseResponseCaching();

//In you controller use this atribute 
[HttpGet]
[ResponseCache(Duration = 60)]
public IActionResult GetDataAsync()
{
    // code here
}

Conclusion
Caching in .NET can significantly improve the performance of applications by storing frequently used data in memory. The most commonly used caching techniques include in-memory caching and distributed caching (e.g., Redis). By using the appropriate caching strategy and expiration policies, you can optimize your application’s response times and reduce unnecessary load on databases or external APIs.

In summary, caching is a vital tool for building scalable and high-performance applications in .NET, and .NET provides various libraries and techniques to implement caching efficiently.

Happy coding!

LINQ First and FirstOrDefault Methods in C#

Diana Iminza — Mon, 06 Jan 2025 08:18:48 +0000

In C#, First() and FirstOrDefault() are two commonly used LINQ extension methods that allow you to query collections, such as arrays, lists, and other IEnumerable types, to retrieve the first element that matches a specified condition. While these methods might seem similar at first glance, they differ in terms of behavior, especially when the collection is empty or when no element matches the condition.

What is First()?
First() is a LINQ method that returns the first element in a collection that satisfies a given condition. If the collection is empty or no element matches the condition, First() throws an exception of type InvalidOperationException.

What is FirstOrDefault()?
FirstOrDefault() is very similar to First(), but with one key difference: it returns a default value when no element matches the condition or if the collection is empty. The default value depends on the type of the element in the collection. For reference types (like classes), the default value is null, and for value types (like integers), it’s the default value for that type (e.g., 0 for int).

When to Use First() and FirstOrDefault()?

Use First() when you are sure that the collection will not be empty and that at least one element will satisfy the condition. This method is useful when the absence of elements matching the condition is considered an error in your application.

Example: If you're querying a database and expecting exactly one result, you may use First() to fetch that record.

Use FirstOrDefault() when the absence of a matching element is valid and you want to avoid exceptions. This is often used in scenarios where the collection might be empty, or no elements meet the condition, and you want to handle these cases gracefully.

Example: When fetching a user by ID or username, you might use FirstOrDefault() because it’s possible the user might not exist, and you can handle the null result in your code.

Scenario: Searching for an Employee by ID
Imagine we have a list of employees, and we want to search for an employee by their ID. The employee list might be empty, or there may not be any employee with the given ID. We will explore how First() and FirstOrDefault() behave in such a case.

Employee Class:
public class Employee { public int Id { get; set; } public string Name { get; set; } }

List of Employees:
List<Employee> employees = new List<Employee> { new Employee { Id = 1, Name = "John Doe" }, new Employee { Id = 2, Name = "Jane Smith" }, new Employee { Id = 3, Name = "Mike Johnson" } };
Example 1: Using First()
Let’s say we want to find an employee with ID 4. Since there is no employee with that ID in the list, using First() will throw an exception.
try { var employee = employees.First(e => e.Id == 4); Console.WriteLine($"Employee Found: {employee.Name}"); } catch (InvalidOperationException ex) { Console.WriteLine($"Error: {ex.Message}"); // Output: "Sequence contains no elements" }
In this case, since no employee has an ID of 4, First() throws an InvalidOperationException, indicating that no element matches the condition.

Example 2: Using FirstOrDefault()
Now let’s see how FirstOrDefault() behaves when trying to find an employee with ID 4.

var employee = employees.FirstOrDefault(e => e.Id == 4);

if (employee != null)
{
    Console.WriteLine($"Employee Found: {employee.Name}");
}
else
{
    Console.WriteLine("No employee found with ID 4");  // Output: "No employee found with ID 4"
}

In this example, FirstOrDefault() returns null because no employee with ID 4 exists in the list. Instead of throwing an exception, we can handle the case gracefully by checking if employee is null and displaying a message to the user.

Example 3: Empty List Scenario
Let’s consider a situation where the employee list is empty:

List<Employee> emptyList = new List<Employee>();

try
{
    var employee = emptyList.First(e => e.Id == 1);  // This will throw an exception
    Console.WriteLine($"Employee Found: {employee.Name}");
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"Error: {ex.Message}");  // Output: "Sequence contains no elements"
}

Now, let’s use FirstOrDefault() with the same empty list:

var employee = emptyList.FirstOrDefault(e => e.Id == 1);

if (employee != null)
{
    Console.WriteLine($"Employee Found: {employee.Name}");
}
else
{
    Console.WriteLine("No employee found");  // Output: "No employee found"
}

Key Takeaways

First() will throw an exception if the collection is empty or if no element satisfies the condition. This is useful when you want to ensure that the element must exist.
FirstOrDefault() will return the default value (null for reference types) if no element matches or if the collection is empty. This allows for safer handling when the absence of a matching element is expected or valid.

By using FirstOrDefault() in scenarios where the absence of an element is acceptable, you can avoid potential crashes in your application due to unhandled exceptions.

By understanding these differences, you can write more predictable and error-resistant code, especially when working with dynamic or uncertain data sources.

Happy coding!

Building an Event Scheduler in .NET Using Google Calendar API

Diana Iminza — Tue, 08 Oct 2024 13:40:57 +0000

Prerequisites

Before diving in, ensure you have the following:

Visual Studio: A recent version for developing your .NET application.
.NET SDK: Make sure you have the latest version installed.
Google Account: Required for accessing the Google Tasks API.
Google Cloud Project:Set up in the Google Cloud Console.

Step 1: Setting Up Your Google Cloud Project

Create a New Project:

Navigate to the Google Cloud Console.
Click on Select a project, then New Project.
Name your project and click Create.

Enable the Google Tasks API:

In the project dashboard, go to Library.
Search for "Google Calendar API" and enable it.

Create Credentials:

Go to the Credentials section and click on Create Credentials.
Choose OAuth client ID.
Configure the consent screen with the required fields.
Set the application type to Web application.
Add authorized redirect URIs (e.g., http://localhost:5000/signin-google).
Save your credentials and note the Client ID and Client Secret.

Step 2: Creating a .NET Application

Create a New Project:

Open Visual Studio and create a new ASP.NET Core Web Application.
Choose the Web Application (Model-View-Controller) template.

Install Required NuGet Packages: Open the Package Manager Console and run the following command:
Install-Package Google.Apis.Calendar.v3 Install-Package Google.Apis.Auth
Create Event Model:

public class CalendarEvent { public string Summary { get; set; } public string Location { get; set; } public string Description { get; set; } public DateTime Start { get; set; } public DateTime End { get; set; } }
Create Google Calendar Service

Create _ICalendarService _Interface:

public interface ICalendarService { void CreateEvent(CalendarEvent calendarEvent); }

Create an implementation of this interface:

using Google.Apis.Calendar.v3;
using Google.Apis.Calendar.v3.Data;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Services;
using Google.Apis.Util.Store;
using System;
using System.IO;
using System.Threading;

public class CalendarService : ICalendarService
{
    private readonly CalendarService _calendarService;

    public CalendarService()
    {
        _calendarService = InitializeService();
    }

    private CalendarService InitializeService()
    {
        UserCredential credential;

        using (var stream = new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
        {
            string credPath = "token.json";
            credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                GoogleClientSecrets.Load(stream).Secrets,
                new[] { CalendarService.Scope.Calendar },
                "user",
                CancellationToken.None,
                new FileDataStore(credPath, true)).Result;
        }

        return new CalendarService(new BaseClientService.Initializer()
        {
            HttpClientInitializer = credential,
            ApplicationName = "Event Scheduler",
        });
    }

    public void CreateEvent(CalendarEvent calendarEvent)
    {
        var newEvent = new Event()
        {
            Summary = calendarEvent.Summary,
            Location = calendarEvent.Location,
            Description = calendarEvent.Description,
            Start = new EventDateTime()
            {
                DateTime = calendarEvent.Start,
                TimeZone = "America/Los_Angeles",
            },
            End = new EventDateTime()
            {
                DateTime = calendarEvent.End,
                TimeZone = "America/Los_Angeles",
            },
        };

        var calendarId = "primary";
        _calendarService.Events.Insert(newEvent, calendarId).Execute();
    }
}

Add Services

public void ConfigureServices(IServiceCollection services) { services.AddControllersWithViews(); services.AddScoped<ICalendarService, CalendarService>(); services.Configure<GoogleApiSettings>(builder.Configuration.GetSection(nameof(GoogleApiSettings))); }

Configure AppSettings.json

"GoogleApiSettings": { "ClientId": "your client id", "ClientSecret": "your client secret", "Scope": [ "https://www.googleapis.com/auth/calendar" ], "ApplicationName": "Google Canlendar Api", "User": "user", "CalendarId": "primary" }

Create CalendarController:

using Microsoft.AspNetCore.Mvc;

public class CalendarController : Controller
{
    private readonly ICalendarService _calendarService;

    public CalendarController(ICalendarService calendarService)
    {
        _calendarService = calendarService;
    }

    [HttpPost]
    public IActionResult CreateEvent(CalendarEvent newEvent)
    {
        _calendarService.CreateEvent(newEvent);
        return RedirectToAction("Index");
    }
}

Conclusion

Integrating Google Calendar API into your .NET application enables users to manage events seamlessly.

With the powerful combination of .NET and Google Calendar API, the possibilities for building robust event management solutions are virtually limitless. Happy coding!

Managing Background Jobs with Hangfire in .NET

Diana Iminza — Fri, 04 Oct 2024 14:06:20 +0000

What is Hangfire?

Hangfire is an open-source library that allows you to perform background processing in .NET applications. It enables you to create, manage, and monitor jobs efficiently, whether they are one-time tasks or recurring jobs. With Hangfire, you can offload work from the main application thread, ensuring that your application remains responsive.

Getting Started with Hangfire

Installation

To get started, you’ll need to install the Hangfire NuGet package. You can do this via the NuGet Package Manager Console:

dotnet add package Hangfire
Also add sql server package in your project:
dotnet add package Microsoft.Data.SqlClient

Configuration

Once installed, you’ll need to configure Hangfire in your application. This involves setting up Hangfire services and the dashboard, which allows you to monitor your jobs.

In your Startup.cs, add the following:
Make sure to replace "YourConnectionString" with your actual SQL Server connection string.

using Hangfire;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Configure Hangfire to use SQL Server
        services.AddHangfire(x => x.UseSqlServerStorage("Server=your_server;Database=HangfireDB;Trusted_Connection=True;"));
        services.AddHangfireServer();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseRouting();

        // Enable the Hangfire dashboard
        app.UseHangfireDashboard();
        app.UseHangfireServer();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

Creating Background Jobs

Creating background jobs is straightforward with Hangfire. Here’s an example of how to enqueue a simple job that runs immediately:

public void RunHangFireJob()
{
    BackgroundJob.Enqueue(() => Console.WriteLine("Hello, world!"));
}

This method will be executed in the background as soon as possible.

Recurring Jobs

Hangfire also allows you to schedule recurring jobs. For instance, if you want a job to run every hour, you can use the following code:

public void RunHangfireRecurringJob()
{
    RecurringJob.AddOrUpdate(
        "my-recurring-job",
        () => Console.WriteLine("This job runs every hour"),
        Cron.Hourly);
}

Create a Background Job

Create a new controller to enqueue background jobs. Here’s a simple example:

using Hangfire;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class JobsController : ControllerBase
{
    [HttpPost("enqueue")]
    public IActionResult EnqueueJob()
    {
        // Enqueue a background job
        BackgroundJob.Enqueue(() => Console.WriteLine("Background job executed!"));
        return Ok("Job enqueued!");
    }

    [HttpPost("recurring")]
    public IActionResult ScheduleRecurringJob()
    {
        // Schedule a recurring job
        RecurringJob.AddOrUpdate(
            "my-recurring-job",
            () => Console.WriteLine("This job runs every minute!"),
            Cron.Minutely);

        return Ok("Recurring job scheduled!");
    }
}

Monitoring Jobs

Hangfire comes with a built-in dashboard that provides a user-friendly interface to monitor your jobs. Run your application. You should be able to navigate to http://localhost:5000/hangfire to access the Hangfire dashboard.From here, you can view job status, retry failed jobs, and much more.

Benefits of Using Hangfire

Ease of Use: Quick integration into your existing applications.
Flexibility: Support for various job types—fire-and-forget, delayed, and recurring jobs.
Monitoring: A comprehensive dashboard for managing jobs.
Persistent Storage: Jobs can be stored in various backends, including SQL Server and Redis.

Conclusion

Hangfire is a powerful tool for managing background tasks in .NET applications. By allowing you to offload tasks from the main thread, Hangfire helps keep your applications responsive and improves user experience. Whether you need to handle one-time tasks or schedule recurring jobs, Hangfire simplifies the process.

Give Hangfire a try in your next .NET project and experience the ease of background processing!

Introduction to Programming: A Beginner's Journey into the World of Code

Diana Iminza — Fri, 23 Aug 2024 09:27:27 +0000

Chapter 1: Introduction to Programming

What is Programming?

Programming is the art of telling a computer what to do through a set of instructions. These instructions are written in a language that the computer can understand, known as a programming language. When you write a program, you’re essentially giving the computer a series of tasks to execute.

Example: Hello, World!
The "Hello, World!" program is a classic example of a simple program in many languages:

Python

print("Hello, World!")

JavaScript

console.log("Hello, World!");

Java

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

TypeScript

console.log("Hello, World!");

Kotlin

fun main() {
    println("Hello, World!")
}

<?php
echo "Hello, World!";
?>

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Why Learn Programming?
Programming is a foundational skill in today's digital world. Here's why you should consider learning it:

Problem-Solving: It enhances your ability to break down problems logically and solve them efficiently.
Career Opportunities: Programmers are in high demand across multiple industries, offering lucrative career prospects.
Creativity: You can build anything from websites and apps to games and simulations.
Understanding Technology: Programming knowledge deepens your understanding of how software and hardware work together.
Automation: You can automate repetitive tasks, improving productivity.

Overview of Popular Programming Languages
There are numerous programming languages, each suited for different tasks. Here's a more detailed look:

Python: Versatile and beginner-friendly, used in web development (Django, Flask), data science (Pandas, NumPy), and AI/ML (TensorFlow, PyTorch).
JavaScript: Essential for web development, both frontend (React, Angular) and backend (Node.js).
Java: Widely used in enterprise applications, Android development, and large-scale systems.
C#: Popular in game development (Unity), desktop applications, and enterprise software.
Ruby: Known for its simplicity, used in web development (Ruby on Rails).
C++: High-performance language used in game development, systems programming, and applications requiring speed.
PHP: Commonly used in web development, particularly for server-side scripting.

Sending Emails in .NET Using FluentEmail

Diana Iminza — Fri, 16 Aug 2024 10:49:44 +0000

Why FluentEmail?
FluentEmail simplifies the process of sending emails by providing a clean and fluent API. It supports various email sending providers, including SMTP, SendGrid, and Mailgun. With FluentEmail, you can quickly set up and send emails without getting bogged down by boilerplate code.

Getting Started
Step 1: Create a New .NET Console Application
First, create a new .NET console application if you don't already have one:
dotnet new console -n FluentEmailDemo cd FluentEmailDemo
Step 2: Install FluentEmail NuGet Packages
Next, install the necessary FluentEmail packages. For this example, we'll use the SMTP sender:
dotnet add package FluentEmail.Core dotnet add package FluentEmail.Smtp
Step 3: Configure FluentEmail
In your Program.cs file, configure FluentEmail with your SMTP settings. Replace the placeholder values with your actual SMTP server details.
Set environment variables in your development environment:
export EMAIL_USERNAME="your-email@example.com" export EMAIL_PASSWORD="your-email-password"

using System;
using System.Net;
using System.Net.Mail;
using FluentEmail.Core;
using FluentEmail.Smtp;

namespace FluentEmailDemo
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var sender = new SmtpSender(() => new SmtpClient("smtp.your-email-provider.com")
{
    UseDefaultCredentials = false,
    Credentials = new NetworkCredential(
        Environment.GetEnvironmentVariable("EMAIL_USERNAME"),
        Environment.GetEnvironmentVariable("EMAIL_PASSWORD")),
    EnableSsl = true,
    Port = 587
});

            Email.DefaultSender = sender;

            var email = await Email
                .From("your-email@example.com")
                .To("recipient@example.com", "Recipient Name")
                .Subject("Test Email")
                .Body("This is a test email sent using FluentEmail.", false)
                .SendAsync();

            if (email.Successful)
            {
                Console.WriteLine("Email sent successfully!");
            }
            else
            {
                Console.WriteLine("Failed to send email. Errors: " + string.Join(", ", email.ErrorMessages));
            }
        }
    }
}

Step 4: Run the Application
Run the application to send the email:
dotnet run
Conclusion
FluentEmail provides a streamlined way to handle email sending in .NET applications. With its fluent API and support for multiple email providers, it takes the hassle out of email communication. Whether you're sending simple notifications or complex email campaigns, FluentEmail has you covered.

By following this guide, you should now be able to set up and use FluentEmail in your .NET projects. Happy coding!

Building a Capital City App With Next.js and Netlify

Diana Iminza — Thu, 25 Jul 2024 14:09:28 +0000

Introduction
Today we will be learning how to build a capital city app using Next.js and Netlify. In today's fast-paced digital world, creating interactive and dynamic web applications is crucial for engaging users and providing them with a seamless experience. Next.js, a popular React framework, allows developers to build powerful server-side rendered (SSR) applications effortlessly. When combined with Netlify, a modern web development platform, you can deploy your applications with ease and take advantage of its robust features like continuous deployment, serverless functions, and global CDN. In this article, we'll explore how to build a Capital City App using Next.js and deploy it on Netlify.

What we’re using

Next.js
Netlify
TypeScript
Tailwind CSS

Prerequisites
Before we dive in, ensure you have the following installed:

Node.js (v14 or later)
npm or yarn
Git

Setting Up the Project

First, let's create a new Next.js project. Open your terminal and run the following command:

npx create-next-app capital-city-app

Navigate to the project directory:

cd capital-city-app

Creating the Capital City App

Setting Up the API For our Capital City App, we'll use a free API that provides data about countries and their capitals. One such API is the REST Countries API. Create a file named api.js in the lib directory to fetch data from the API:

export async function getCountries() {
    const res = await fetch('https://restcountries.com/v3.1/all');
    if (!res.ok) {
      throw new Error('Failed to fetch data')
    }
    const data = await res.json();
    return data;
  }

Creating the Components Let's create a CountryCard component to display individual country details. Create a file named CountryCard.js in the components directory:

import React from 'react';

const CountryCard = ({ country }) => {
  return (
    <div className="card">
      <h2>{country.name.common}</h2>
      <p>Capital: {country.capital}</p>
      <p>Region: {country.region}</p>
      <img src={country.flags.svg} alt={`${country.name.common} flag`} width="100" />
    </div>
  );
}

export default CountryCard;

Fetching and Displaying Data In your pages/index.js file, fetch the country data and display it using the CountryCard component:

import { getCountries } from '../app/lib/api';
import CountryCard from '../components/CountryCard';

export async function getStaticProps() {
  const countries = await getCountries();
  return {
    props: {
    countries,
    },
  };
}

const Home = ({ countries }) => {
  return (
    <div>
      <h1>Capital City App</h1>
      <div className="grid">
        {countries.map((country) => (
          <CountryCard key={country.cca3} country={country} />
        ))}
      </div>
      <style jsx>{`
        .grid {
          display: grid;
          grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
          gap: 20px;
        }
        .card {
          border: 1px solid #ccc;
          padding: 20px;
          border-radius: 10px;
          text-align: center;
        }
      `}</style>
    </div>
  );
};

export default Home;

Deploying on Netlify

1. Setting Up the Repository

Initialize a git repository in your project:
git init git add . git commit -m "Initial commit"

2. Deploying to Netlify

Create a New Site on Netlify: Go to Netlify and log in. Click on "New site from Git".
Connect to Your Git Repository: Choose your Git provider (GitHub, GitLab, Bitbucket) and select your repository.
Configure Your Build Settings:

Build Command: next build
Publish Directory: .next

Deploy the Site: Click "Deploy site". Netlify will automatically build and deploy your site.

3. Setting Up Continuous Deployment

Whenever you push changes to your repository, Netlify will automatically trigger a new build and deploy the updated version of your app.

Conclusion

Congratulations! You have successfully built and deployed a Capital City App using Next.js and Netlify. This app fetches data from the REST Countries API and displays it in a user-friendly manner. With Next.js's server-side rendering and Netlify's powerful deployment features, you can create and deploy dynamic web applications efficiently.

Next.js and Netlify make a powerful combination for modern web development, allowing you to focus on building great features while handling the complexities of deployment and scaling for you. Happy coding!

Builder Pattern in C#

Diana Iminza — Thu, 04 Jul 2024 10:05:10 +0000

Introduction

The Builder Pattern is a creational design pattern that allows you to construct complex objects by specifying their type and content. The Builder Pattern separates the construction of an object from its representation, enabling the same construction process to create different representations.

When to Use the Builder Pattern

When an object needs to be constructed with many parameters or complex initialization processes.
When you want to build an immutable object that should be initialized with all required properties.
When you need different representations of an object, but the construction process remains the same.

Structure of the Builder Pattern
The Builder Pattern consists of four main components:

Product: The complex object that is being constructed.
Builder Interface: Defines all possible ways to build the product.
Concrete Builder: Implements the builder interface and constructs the product.
Director: Constructs the object using the Builder interface.

Implementation in C#

Let's dive into an example to understand how to implement the Builder Pattern in C#.

Step 1: Define the Product

The product is the complex object that we want to build.
The product is the Mentorship Program which links students to mentors.

Step 2: Create the Builder Interface

The builder interface specifies the steps required to build the Mentorship Program.

Step 3: Implement the Concrete Builder

The concrete builder implements the builder interface and provides specific implementations for each building step.

namespace BuilderPattern.Services.Implementations
{
    public class MentorshipProgramBuilder : IMentorshipProgramBuilder
    {
        private MentorshipProgram _program;

        public MentorshipProgramBuilder()
        {
            _program = new MentorshipProgram();
        }

        public void SetProgramName(string name)
        {
            _program.ProgramName = name;
        }

        public void SetDates(DateTime start, DateTime end)
        {
            _program.StartDate = start;
            _program.EndDate = end;
        }

        public void AddStudent(string student)
        {
            _program.Students.Add(student);
        }

        public void AddMentor(string mentor)
        {
            _program.Mentors.Add(mentor);
        }

        public void PairStudentWithMentor(string student, string mentor)
        {
            _program.StudentMentorPairs[student] = mentor;
        }

        public MentorshipProgram GetProgram()
        {
            return _program;
        }
    }

}

Step 4: Create the Director

The director class is responsible for constructing the object using the builder interface.

Step 5: Putting It All Together

Here's how you can use the Builder Pattern to construct a Mentorship Program object.

Benefits of the Builder Pattern

Modularity: Each component of the MentorshipProgram is built in a modular way, allowing for clear separation of concerns.
Flexibility: New students or mentors can be added, and existing pairs can be modified without changing the overall construction logic.
Scalability: The pattern supports scalability by allowing complex setups to be managed easily, accommodating future expansion of the mentorship program.
Clearer Code: The code is more readable and easier to understand, especially when dealing with complex objects.
Reusability: The same construction process can create different representations of the product.

By using the Builder Pattern, we can efficiently manage the construction of complex objects like a mentorship program, ensuring our code remains clean, maintainable, and scalable.

Conclusion

The Builder Pattern is a powerful tool in C# for constructing complex objects. By separating the construction process from the representation, it provides flexibility, clarity, and reusability in your code. Whether you are dealing with an object that requires many initialization parameters or different representations, the Builder Pattern is worth considering.

Happy coding!