Forem: Alisson Podgurski

Intelligent Automation with RPA and AI: Capturing and Summarizing Emails with Selenium and ChatGPT

Alisson Podgurski — Sun, 08 Sep 2024 15:28:18 +0000

Have you ever imagined a robot doing the repetitive task of checking your emails, generating summaries, and automatically highlighting pending tasks? Well, that reality is not far off. With the power of Robotic Process Automation (RPA) combined with the artificial intelligence of ChatGPT, you can create systems that save time and energy on daily tasks, allowing you to focus on what really matters.

In this article, we will explore how to build an intelligent RPA system that automates the capture and summary of emails using Selenium and the OpenAI API. This tutorial will not only show you how to put the theory into practice, but will also serve as inspiration for you to apply automation and AI in other areas of your work and life.

What We Will Build
The goal is simple: create a robot capable of:

Automatically accessing your email account (Gmail).
Capturing the most recent emails directly from your inbox.
Sending these emails to ChatGPT to generate a summary of important points and list any pending tasks.
Saving the summary to a text file for quick reference.

With these tools, you will have a powerful and intelligent automation system that does the heavy lifting for you. Let's get started!

1. Creating the .NET Project

First, let's create a project in .NET. .NET provides a solid and rich foundation for developing robust applications, while Selenium allows us to control the browser and access emails, and ChatGPT will bring intelligence to automatically summarize the content of emails.

Steps:

Open the terminal or command prompt and create a new console project:

dotnet new console -n EmailRPA

Navigate to the project folder:

cd EmailRPA

Add the necessary libraries, such as Selenium WebDriver and OpenAI:

dotnet add package Selenium.WebDriver
dotnet add package Selenium.Chrome.WebDriver
dotnet add package OpenAI

With these initial configurations, we are ready to start implementing our email automation system!

2. Structuring the Automation System

To keep the code clean and organized, we will follow some best practices and divide the functionality into specific classes. This not only improves code maintainability but also makes it easier to expand and integrate with other systems in the future.

Project Structure:

EmailRPA/
│
├── Program.cs
├── Services/
│ ├── EmailLoginService.cs
│ ├── EmailCaptureService.cs
│ ├── EmailSummaryService.cs
│ └── FileStorageService.cs
├── Models/
│ └── Email.cs

EmailLoginService: Logs into Gmail.
EmailCaptureService: Captures emails from the inbox.
EmailSummaryService: Sends emails to ChatGPT to generate summaries.
FileStorageService: Saves the generated summary to a text file.
Program.cs: Integrates all these parts.

3. Implementing the Functionality

3.1. Email Model
First, let's create a model to represent the captured emails. It will store the subject and content of the emails.

// Models/Email.cs
namespace EmailRPA.Models
{
    public class Email
    {
        public string Subject { get; set; }
        public string Snippet { get; set; }
    }
}

3.2. Gmail Login Service
To automate the Gmail login process, we use Selenium to navigate to the login page, fill in the email and password, and proceed to the inbox.

// Services/EmailLoginService.cs
using OpenQA.Selenium;
using System.Threading.Tasks;

namespace EmailRPA.Services
{
    public class EmailLoginService
    {
        private readonly IWebDriver _webDriver;

        public EmailLoginService(IWebDriver webDriver)
        {
            _webDriver = webDriver;
        }

        public async Task<bool> LoginToGmailAsync(string email, string password)
        {
            _webDriver.Navigate().GoToUrl("https://accounts.google.com/signin/v2/identifier?service=mail");

            var emailField = _webDriver.FindElement(By.Id("identifierId"));
            emailField.SendKeys(email);
            _webDriver.FindElement(By.Id("identifierNext")).Click();

            await Task.Delay(6000);

            var passwordField = _webDriver.FindElement(By.Name("Passwd"));
            passwordField.SendKeys(password);
            _webDriver.FindElement(By.Id("passwordNext")).Click();

            await Task.Delay(5000);

            return _webDriver.Url.Contains("mail.google.com");
        }
    }
}

3.3. Capturing Emails
Now, let's capture the emails from the inbox. This class extracts the subject and content of the most recent emails.

// Services/EmailCaptureService.cs
using OpenQA.Selenium;
using EmailRPA.Models;
using System.Collections.Generic;
using System.Linq;

namespace EmailRPA.Services
{
    public class EmailCaptureService
    {
        private readonly IWebDriver _webDriver;

        public EmailCaptureService(IWebDriver webDriver)
        {
            _webDriver = webDriver;
        }

        public List<Email> CaptureRecentEmails(int emailCount = 5)
        {
            var emails = new List<Email>();
            var emailElements = _webDriver.FindElements(By.XPath("//tr[@class='zA zE']"));

            foreach (var emailElement in emailElements.Take(emailCount))
            {
                var subject = emailElement.FindElement(By.CssSelector(".bog")).Text;
                var snippet = emailElement.FindElement(By.CssSelector(".y2")).Text;

                emails.Add(new Email
                {
                    Subject = subject,
                    Snippet = snippet
                });
            }

            return emails;
        }
    }
}

3.4. Email Summarization with ChatGPT
Here’s where ChatGPT comes into play. This class sends the captured emails to GPT and returns a summary.

// Services/EmailSummaryService.cs
using OpenAI.Chat;
using EmailRPA.Models;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace EmailRPA.Services
{
    public class EmailSummaryService
    {
        private readonly ChatClient _chatClient;

        public EmailSummaryService(string openAIApiKey)
        {
            _chatClient = new ChatClient(new OpenAI.Client("gpt-4", openAIApiKey));
        }

        public async Task<string> SummarizeEmailsAsync(List<Email> emails)
        {
            var emailData = string.Join("\n\n", emails.Select(e => $"{e.Subject}: {e.Snippet}"));

            var prompt = $"Here are some recent emails:\n\n{emailData}\nPlease summarize the key points and list any pending actions.";
            var completion = await _chatClient.CompleteChatAsync(prompt);

            return completion.Value.ToString();
        }
    }
}

3.5. Saving the Summary to a File
Finally, we need to save the generated summary to a text file for future reference.

// Services/FileStorageService.cs
using System.IO;

namespace EmailRPA.Services
{
    public class FileStorageService
    {
        public void SaveToFile(string content, string filePath)
        {
            File.WriteAllText(filePath, content);
            System.Console.WriteLine($"Summary saved at: {filePath}");
        }
    }
}

4. Integrating Everything in Program.cs

Now that we have all the services set up, let’s integrate them into our main entry point.

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using EmailRPA.Services;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string email = "your-email@gmail.com";
        string password = "your-password";
        string openAIApiKey = "your-openai-api-key";
        string filePath = "SummaryEmails.txt";

        using (IWebDriver webDriver = new ChromeDriver())
        {
            var loginService = new EmailLoginService(webDriver);
            var captureService = new EmailCaptureService(webDriver);
            var summaryService = new EmailSummaryService(openAIApiKey);
            var fileStorageService = new FileStorageService();

            // Login to Gmail
            var loginSuccess = await loginService.LoginToGmailAsync(email, password);
            if (!loginSuccess)
            {
                System.Console.WriteLine("Login failed. Check your credentials.");
                return;
            }

            // Capture recent emails
            var emails = captureService.CaptureRecentEmails(10);

            // Summarize emails via ChatGPT
            var summary = await summaryService.SummarizeEmailsAsync(emails);

            // Save the summary to a file
            fileStorageService.SaveToFile(summary, filePath);
        }
    }
}

5. The Power of Automation and AI in Your Hands

Congratulations! You now have in your hands a system that combines intelligent automation and artificial intelligence to simplify the task of reading emails and extracting important information. This project can be expanded into various areas, from automated reporting to creating alerts about critical subjects in your emails.

With RPA and AI, you can transform manual and repetitive tasks into automatic and intelligent processes, increasing your productivity and reducing the time spent on routine tasks.

To get the full code access my github: EmailRPASystem

Crafting a Powerful API Performance CLI: Approach with .NET Core and System.CommandLine

Alisson Podgurski — Sat, 24 Aug 2024 01:32:35 +0000

Hey there, fellow developers! Ever felt the need to quickly test the performance of your APIs, but wished you had a nifty little tool right at your fingertips? Well, you're in luck! Today, we’re going to build a Command-Line Interface (CLI) tool using .NET Core that does just that. Not only will it help you test your API performance, but it’ll also let you compare different test runs to see if your recent changes made things better or, well, not so much.

Step 1: Setting Up the Project

First things first, let’s get our environment ready.

Create a New Project

Fire up your terminal and create a new .NET Core console project. This will be the foundation of our CLI tool.

dotnet new console -n ApiPerformanceTool
cd ApiPerformanceTool

Add the Necessary Dependencies We’ll need a couple of packages to make our CLI smooth and user-friendly:

dotnet add package System.CommandLine
dotnet add package System.Net.Http
dotnet add package System.CommandLine.NamingConventionBinder

These packages will help us handle command-line arguments and make HTTP requests to your API.

Step 2: Crafting the Core Functionality

Now, let’s get to the good stuff—building the core features of our CLI tool. We’re going to break down our functionality into small, single-responsibility classes (thank you, SOLID principles!).

Setting Up the Root Command
We’ll start by setting up the root command for our CLI. This will be the entry point where we define our test and compare commands.

using System.CommandLine;
using System.CommandLine.Invocation;

namespace ApiPerformanceTool
{
    class Program
    {
        static async Task<int> Main(string[] args)
        {
            var rootCommand = new RootCommand
            {
                CommandFactory.CreateTestCommand(),
                CommandFactory.CreateCompareCommand()
            };

            return await rootCommand.InvokeAsync(args);
        }
    }
}

Here, we’re using a CommandFactory to keep things organized. It’s a neat trick to separate command creation into its own class.

Creating the Test Command
Let’s dive into creating the test command. This command will hit your API with a bunch of requests and measure how long it takes to respond.

public static class CommandFactory
{
    public static Command CreateTestCommand()
    {
        var command = new Command("test", "Tests the performance of an API endpoint")
        {
            new Argument<string>("url", "The URL of the API endpoint to test"),
            new Option<int>("--concurrent", () => 10, "Number of concurrent requests"),
            new Option<string>("--output", "File to save the performance report")
        };

        command.Handler = CommandHandler.Create<string, int, string>(async (url, concurrent, output) =>
        {
            var tester = new ApiTester(new HttpClient());
            var result = await tester.TestPerformanceAsync(url, concurrent);

            Console.WriteLine($"Average response time: {result.AverageResponseTime} ms");
            Console.WriteLine($"95th percentile: {result.Percentile95} ms");

            if (!string.IsNullOrEmpty(output))
            {
                var reportWriter = new ReportWriter();
                await reportWriter.SaveAsync(output, result);
            }
        });

        return command;
    }
}

What’s happening here?

We’re setting up the test command to accept the API URL, the number of concurrent requests, and an optional output file path.
The handler then uses an ApiTester to hit the API and measure response times.

Building the API Tester

The ApiTester class is where the magic happens—it sends the requests and calculates the average response time and the 95th percentile.

public class ApiTester
{
    private readonly HttpClient _httpClient;

    public ApiTester(HttpClient httpClient)
    {
        _httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
    }

    public async Task<TestResult> TestPerformanceAsync(string url, int concurrent)
    {
        var tasks = new List<Task<TimeSpan>>();

        for (int i = 0; i < concurrent; i++)
        {
            tasks.Add(SendRequestAsync(url));
        }

        var results = await Task.WhenAll(tasks);
        return new TestResult
        {
            AverageResponseTime = results.Average(ts => ts.TotalMilliseconds),
            Percentile95 = results.OrderBy(ts => ts.TotalMilliseconds).ElementAt((int)(results.Length * 0.95)).TotalMilliseconds
        };
    }

    private async Task<TimeSpan> SendRequestAsync(string url)
    {
        var stopwatch = Stopwatch.StartNew();
        await _httpClient.GetAsync(url);
        stopwatch.Stop();
        return stopwatch.Elapsed;
    }
}

Let’s break it down:

The ApiTester sends concurrent number of requests to the API.
It calculates the average response time and the 95th percentile, which are key metrics for performance testing.

Saving the Report

Once we’ve gathered the results, we might want to save them for later. The ReportWriter class handles that.

public class ReportWriter
{
    public async Task SaveAsync(string filePath, TestResult result)
    {
        var lines = new List<string>
        {
            $"Average time: {result.AverageResponseTime} ms",
            $"95th percentile: {result.Percentile95} ms"
        };
        await File.WriteAllLinesAsync(filePath, lines);
    }
}

Simple and to the point, the ReportWriter saves our test results to a file.

Creating the Compare Command
Now let’s tackle the compare command. This is where we’ll compare the results of two different test runs.

public static Command CreateCompareCommand()
{
    var command = new Command("compare", "Compares two performance reports")
    {
        new Argument<string>("file1", "First report file"),
        new Argument<string>("file2", "Second report file")
    };

    command.Handler = CommandHandler.Create<string, string>((file1, file2) =>
    {
        var reportLoader = new ReportLoader();
        var report1 = reportLoader.Load(file1);
        var report2 = reportLoader.Load(file2);

        var comparer = new ReportComparer();
        var comparisonResult = comparer.Compare(report1, report2);

        Console.WriteLine(comparisonResult);
    });

    return command;
}

Here’s what’s happening:

The compare command reads two report files and uses a ReportComparer to see how they stack up against each other.

Loading and Comparing Reports

Let’s see how we load and compare these reports.

public class ReportLoader
{
    public TestResult Load(string filePath)
    {
        var lines = File.ReadAllLines(filePath);

        double average = double.Parse(lines.First(line => line.StartsWith("Average time:")).Split(':')[1].Trim().Replace("ms", ""));
        double p95 = double.Parse(lines.First(line => line.StartsWith("95th percentile:")).Split(':')[1].Trim().Replace("ms", ""));

        return new TestResult
        {
            AverageResponseTime = average,
            Percentile95 = p95
        };
    }
}

public class ReportComparer
{
    public string Compare(TestResult report1, TestResult report2)
    {
        var averageDiff = report2.AverageResponseTime - report1.AverageResponseTime;
        var p95Diff = report2.Percentile95 - report1.Percentile95;

        return $"Comparison:\n" +
               $"Average time difference: {averageDiff} ms\n" +
               $"{(averageDiff < 0 ? "The second test was faster on average." : averageDiff > 0 ? "The second test was slower on average." : "The average response times were the same.")}\n" +
               $"95th percentile difference: {p95Diff} ms\n" +
               $"{(p95Diff < 0 ? "The second test had a better (lower) 95th percentile." : p95Diff > 0 ? "The second test had a worse (higher) 95th percentile." : "The 95th percentile times were the same.")}";
    }
}

In summary:

ReportLoader pulls the performance metrics from a file.
ReportComparer compares the metrics and provides a human-readable summary of how the two reports differ.

Step 3: Running the Tool

Now that our CLI tool is complete, it’s time to put it to the test!

Testing API Performance

To run a performance test on your API, use the test command:

dotnet run -- test https://api.example.com/endpoint --concurrent 100 --output report1.txt

This sends 100 concurrent requests to https://api.example.com/endpoint and saves the results to report1.txt.

Comparing Two Reports

After running tests at different times, compare the results using the compare command:

dotnet run -- compare report1.txt report2.txt

This command will tell you whether your changes made the API faster or slower, and by how much.

Conclusion

And there you have it! A clean, SOLID, and fully functional CLI tool for analyzing API performance. By breaking down the functionality into small, focused classes, we’ve made our tool not only easy to use but also easy to maintain and extend.

Feel free to add more features, like supporting different HTTP methods or output formats. The sky’s the limit!

So go ahead, give it a whirl, and keep those APIs running fast and smooth. Happy coding! 🎉

If you want to access the example of this code, just click here: Code

Transforming Complexity into Simplicity: The Power of .NET Aspire

Alisson Podgurski — Sat, 10 Aug 2024 01:40:04 +0000

Introduction

These days, everyone’s racing to create apps that are fast, scalable, and reliable. But let’s face it, with all the different technologies and services out there, things can get pretty complicated. That’s where .NET Aspire comes in—a platform from Microsoft that promises to turn all that complexity into something much simpler and easier to manage, especially if you’re working with Azure. Let’s dive into how .NET Aspire can really make a developer’s life easier.

What is .NET Aspire?

Think of .NET Aspire as your development life saver. It’s a platform designed to help you build and manage corporate apps in the cloud, leveraging all the great stuff Azure has to offer. It brings together various tools, APIs, and components in one place, making it easier to handle everything from development to deployment and monitoring.

Components and Integration

.NET Aspire comes with several pieces that fit together perfectly to make your life easier. Some of these are:

Aspire Hosting: This guy manages the execution of multiple projects within your application, taking care of dependencies, service communication, and service discovery. It simplifies the orchestration of different services, making sure everything runs smoothly and efficiently, no matter how complex your application gets.
Aspire Service Defaults: It sets up reusable standard configurations across your application, ensuring that everything follows best practices. This means that all your services share the same resilience, telemetry, and service discovery settings, reducing the chance of errors and inconsistencies.
Aspire Dashboard: This is your control center, where you monitor everything happening in your app, like logs, metrics, and traces. The dashboard gives you real-time insights into the health and performance of your application, helping you quickly identify and fix any issues that come up.
Aspire Components: These are pre-built packages that integrate seamlessly into your cloud environment. Whether you need service discovery, caching, or telemetry, Aspire Components are designed to work right out of the box, saving you the hassle of setting up and configuring everything manually. They come with built-in defaults that ensure high availability and performance, and you can easily customize them to fit your specific needs.
Service Resilience: .NET Aspire includes built-in support for service resilience, ensuring your application can handle failures gracefully. This includes automatic retries, circuit breakers, and timeouts, which are configured by default but can be fine-tuned to meet your needs. These features are crucial for maintaining the reliability and uptime of your services, especially in a cloud environment where failures are inevitable.
OpenTelemetry Integration: .NET Aspire comes with built-in support for OpenTelemetry, a standard for collecting telemetry data (like metrics, traces, and logs) across your distributed systems. This makes it easier to monitor your application's performance and troubleshoot issues, as you have a unified view of how your services are interacting with each other.
Centralized Configuration Management: Managing configurations across multiple environments can be a nightmare. .NET Aspire simplifies this by providing centralized configuration management, allowing you to define and manage configurations for all your services in one place. This ensures consistency and reduces the risk of misconfigurations that could lead to downtime or performance issues.
Integrated CI/CD Pipelines: .NET Aspire also supports continuous integration and continuous deployment (CI/CD) out of the box. It integrates with popular CI/CD tools like Azure DevOps and GitHub Actions, allowing you to automate your build, test, and deployment processes. This means you can deploy new features faster and with more confidence, knowing that your application is thoroughly tested and validated at each stage of the pipeline.
Security Features: Security is built into .NET Aspire from the ground up. It supports integration with Azure Key Vault for managing secrets and certificates, ensuring that sensitive information is stored securely. Additionally, .NET Aspire includes tools for setting up and managing authentication and authorization, so you can easily control who has access to your application and its resources.

All these components work together seamlessly, allowing you to focus on what really matters: developing your business logic without worrying about the infrastructure.

Advantages of .NET Aspire

1. Simplifying Cloud Development

If you’ve ever tried setting up a bunch of cloud services, you know it’s no walk in the park. .NET Aspire fixes that by giving you a standardized environment where everything is set up to work together. You don’t waste time on technical details and can instead focus on building the features that really matter.

Practical Example:

Imagine you need to build an order management system with a Blazor front-end, an ASP.NET Core API, and a Redis cache. Normally, setting that up would be a huge headache. But with .NET Aspire, you can do it in minutes using pre-configured templates that come with everything you need.

2. Advanced Observability and Monitoring
Knowing what’s happening inside your app is crucial, especially in production. .NET Aspire takes this seriously, with integrated monitoring tools that give you a complete view of what’s going on. You can see logs, track requests, and analyze metrics, all in one place.

Practical Example:

If your app is running slow and you have no idea why, just open the Aspire Dashboard. You’ll be able to see exactly where the problem is—whether it’s a slow database or an unresponsive service. This makes troubleshooting much easier.

3. Consistency and Reliability
There’s nothing worse than having a project where every part was built differently. .NET Aspire helps prevent this by applying consistent standards across your entire application. This ensures everything works reliably and that errors are minimized.

Practical Example:

Suppose you’re developing several microservices that need to talk to each other. .NET Aspire makes sure they all follow the same retry policies, timeouts, and other critical settings, no matter who developed them. This guarantees everything works as expected, with no nasty surprises.

4. Operational Efficiency
Automating repetitive tasks is one of the best ways to save time in development. With .NET Aspire, many of these tasks are automated, like setting up containers, deploying new versions, and managing logs and metrics. Less time spent on these means more time for you to focus on what really matters.

Practical Example:

Let’s say you need to deploy a new version of your service to production. With .NET Aspire, you can automate the entire process, ensuring all steps are carried out consistently and without manual intervention.

5. Flexibility and Scalability
Another big win with .NET Aspire is flexibility. It works with both cloud-agnostic technologies and Azure-specific services like Azure Blob Storage and Cosmos DB. This gives you the freedom to choose the best tools for each situation without worrying about integration issues.

Practical Example:

Let’s say your company is growing, and you need to scale your application to support more users. With .NET Aspire, you can easily add new services and configure scalability without having to rework your existing architecture too much, ensuring a smooth and efficient transition.

Disadvantages of .NET Aspire

1. Dependence on Azure Platform
.NET Aspire is designed to work closely with Azure, meaning that companies using other cloud platforms may encounter limitations or integration difficulties. This could be a disadvantage for organizations that prefer or already use other cloud providers, such as AWS or Google Cloud, and do not want to be locked into Azure.

Practical Example:

Imagine a company that has historically built its infrastructure on AWS, using services like S3 for storage and RDS for databases. If they decide to adopt .NET Aspire for a new project, they might find themselves needing to migrate existing services to Azure equivalents like Azure Blob Storage and Azure SQL Database. This migration can be costly and time-consuming. Moreover, if they have workflows and automation tightly integrated with AWS, they would need to invest additional resources to reconfigure these for Azure, potentially leading to vendor lock-in and reducing their flexibility to switch back to AWS or to use a combination of AWS and Azure.

2. Limited Flexibility in Multi-Cloud Environments
If an organization operates in a multi-cloud environment, where applications are distributed across different cloud providers, .NET Aspire may not offer the necessary flexibility to easily manage these environments. The reliance on Azure-specific tools and services can make it challenging to integrate or efficiently manage resources spread across different cloud platforms.

Practical Example:

Consider an organization that operates a large-scale application with different components running across multiple cloud providers—AWS for some services, Google Cloud for others, and Azure for specific tasks. They use AWS Lambda for serverless functions, Google Cloud’s BigQuery for data analysis, and Azure for hosting critical web services. If they introduce .NET Aspire to manage the Azure-hosted services, they may struggle to integrate or manage the parts of their application hosted on AWS and Google Cloud. The centralized tools and management features of .NET Aspire might not extend easily to services outside Azure, forcing the organization to manage these components separately and leading to inefficiencies or the need for custom integration solutions.

3. Support and Documentation
While .NET Aspire is an emerging technology with great potential, the available community and documentation may not be as extensive as for more mature technologies. This can mean that developers face challenges in solving complex problems or implementing specific features, especially if official documentation is still under development.

Practical Example:

A small startup decides to use .NET Aspire for their new SaaS application. As they start building out complex features, they run into a technical issue with service discovery that isn’t covered in the existing documentation. Unlike more established platforms like ASP.NET Core or Kubernetes, which have large communities and extensive documentation, the startup struggles to find answers online. They might spend valuable development time troubleshooting on their own or trying to reach out to Microsoft support, which could slow down their development cycle and delay their product launch.

4. Overhead Risk
Implementing .NET Aspire can add an additional layer of overhead in managing infrastructure, especially in smaller projects that may not require all the complexity offered by the platform. For small teams or projects with simpler requirements, the robust tools and functionalities of .NET Aspire might be overkill, resulting in unnecessary overhead.

Practical Example:

A small development team is working on a straightforward internal tool that requires minimal scaling and simple functionalities. They decide to use .NET Aspire for its robust features and out-of-the-box integrations. However, as they progress, they realize that managing the infrastructure, setting up the orchestration for even basic services, and dealing with the additional configurations required by .NET Aspire adds unnecessary complexity. The team finds themselves spending more time on infrastructure management than on developing the tool itself. This overhead not only delays the project but also consumes resources that could have been better spent on other tasks, leading them to consider switching to a simpler solution like a basic ASP.NET Core app or even a non-cloud-based application.

Use Cases and Practical Examples

To show how .NET Aspire can make a difference, let’s imagine an e-commerce application that needs to handle thousands of transactions per minute. With .NET Aspire, you can quickly set up everything from the API to process orders, the Blazor front-end, and the Redis cache to boost performance. The Aspire Dashboard gives you a clear view of everything that’s happening, helping you fix any issues that pop up.

Plus, .NET Aspire ensures that any new microservices you create follow the same best practices, making your entire system more consistent and reliable.

Conclusion

.NET Aspire is a powerful tool that turns the complexity of software development into something simple and manageable. It helps you speed up innovation, improve operational efficiency, and ensure your applications are robust and scalable. If you’re looking for a way to simplify cloud development and focus on what really matters, .NET Aspire is the way to go.

In a world where digital transformation is more important than ever, .NET Aspire gives you the tools to stand out and achieve long-term success.

If you're curious, follow the link to Microsoft's official documentation

.NET Aspire documentation

Bibliography:

Gawlinski, Chris. "Accelerating Project Success with .NET Aspire." Prognetics Blog, April 11, 2024.
Cordon, Glen. Microsoft's Strategic Approach to Simplifying Cloud-Native Development. Microsoft Developer Blog, March 2024.
Welter, Szymon. "Insights into .NET Aspire from a Developer’s Perspective." Prognetics Blog, April 2024.
Microsoft. "Get Started with .NET Aspire." Microsoft Learn, 2024.
Gawlinski, Chris. The Promising Potential and The Future of .NET Aspire. Prognetics Blog, April 2024.

Detecting Anomalies with .NET and ML.NET: A Practical Guide

Alisson Podgurski — Fri, 02 Aug 2024 22:44:10 +0000

Introduction

Ever wondered how to find a needle in a haystack or detect when your data decides to throw a party? Anomaly detection can help you spot those unexpected patterns that might indicate system failures, financial fraud, or even just a misbehaving sensor. In this article, we’ll explore how to use ML.NET to integrate anomaly detection into your .NET applications. Let's dive in and make sure your data behaves!

What is Anomaly Detection?

Anomaly detection is the practice of identifying data that doesn't behave like the rest of its peers. Imagine finding a cat at a dog show – that's an anomaly. Whether you're monitoring systems, securing financial transactions, or ensuring quality control, spotting these outliers is crucial.

ML.NET and Anomaly Detection

ML.NET is a machine learning library developed by Microsoft that allows you to integrate AI models directly into .NET applications. With ML.NET, you can create, train, and use machine learning models without leaving the .NET environment. Think of it as having a trusty assistant to help you keep your data in check.

Setting Up the Environment

First, let’s set up the necessary environment to create our anomaly detection project.

Step 1: Install the .NET SDK
Make sure you have the .NET SDK installed. If you don’t have it yet, download it here. Trust us, it’s easier than assembling IKEA furniture.

Step 2: Create a New Project
Open Visual Studio or use the .NET CLI to create a new console project:

dotnet new console -n MLNetDemo
cd MLNetDemo

Step 3: Add the Necessary Packages
Add the ML.NET and ML.NET TimeSeries packages to your project:

dotnet add package Microsoft.ML
dotnet add package Microsoft.ML.TimeSeries

Implementing Anomaly Detection

Let's create a practical example of anomaly detection in sensor data. Don’t worry, we won’t leave you hanging!

Step 4: Create the Data Classes
Define the SensorData and AnomalyPrediction classes to represent the input data and the predictions.

public class SensorData
{
    [LoadColumn(0)]
    public DateTime Time { get; set; }

    [LoadColumn(1)]
    public float Value { get; set; }
}

public class AnomalyPrediction
{
    [VectorType(3)]
    public double[] Prediction { get; set; }
}

Explanation:

SensorData:

This class represents the input data containing the time (Time) and sensor value (Value). Think of it as the guest list for your data party.

AnomalyPrediction:

This class represents the anomaly prediction returned by the model. The Prediction property is a vector of three elements containing information about the anomaly detection. It’s like your bouncer at the party, deciding who’s out of place.

Step 5: Implement the Main Code
Create the Program.cs file with the following code:

using Microsoft.ML;

class Program
{
    static void Main(string[] args)
    {
        var context = new MLContext();

        // Simulated data for demonstration purposes
        var data = new List<SensorData>
        {
            new SensorData { Time = DateTime.Parse("2024-03-08 00:00"), Value = 1.0f },
            new SensorData { Time = DateTime.Parse("2024-03-08 01:00"), Value = 1.1f },
            new SensorData { Time = DateTime.Parse("2024-03-08 02:00"), Value = 1.0f },
            new SensorData { Time = DateTime.Parse("2024-03-08 03:00"), Value = 1.2f },
            new SensorData { Time = DateTime.Parse("2024-03-08 04:00"), Value = 1.1f },
            new SensorData { Time = DateTime.Parse("2024-03-08 05:00"), Value = 5.0f }, // Anomaly
            new SensorData { Time = DateTime.Parse("2024-03-08 06:00"), Value = 1.1f },
            new SensorData { Time = DateTime.Parse("2024-03-08 07:00"), Value = 1.0f },
            new SensorData { Time = DateTime.Parse("2024-03-08 08:00"), Value = 1.2f },
            new SensorData { Time = DateTime.Parse("2024-03-08 09:00"), Value = 1.0f }
        };

        var dataView = context.Data.LoadFromEnumerable(data);

        var pipeline = context.Transforms.DetectSpikeBySsa(
            outputColumnName: nameof(AnomalyPrediction.Prediction),
            inputColumnName: nameof(SensorData.Value),
            confidence: 95.0,
            pvalueHistoryLength: data.Count / 2,
            trainingWindowSize: data.Count,
            seasonalityWindowSize: data.Count / 4);

        var model = pipeline.Fit(dataView);
        var transformedData = model.Transform(dataView);

        var predictions = context.Data.CreateEnumerable<AnomalyPrediction>(transformedData, reuseRowObject: false).ToList();

        Console.WriteLine("Time\t\tValue\tAnomaly");
        for (int i = 0; i < predictions.Count; i++)
        {
            var sensorData = data[i];
            var prediction = predictions[i];
            var isAnomaly = prediction.Prediction[0] == 1;
            Console.WriteLine($"{sensorData.Time}\t{sensorData.Value}\t{isAnomaly}");
        }
    }
}

Explanation:

Creating the ML Context:

var context = new MLContext();

Creates a new ML.NET context, which is necessary for all ML.NET operations. It’s like our command center for ML tasks.

Creating Simulated Data:

var data = new List<SensorData>
{
    new SensorData { Time = DateTime.Parse("2023-01-01 00:00"), Value = 1.0f },
    new SensorData { Time = DateTime.Parse("2023-01-01 01:00"), Value = 1.1f },
    // ...
};

Simulates some sensor data that includes an anomalous value. It’s like our data party where one guest decided to go wild!

Loading the Data:

var dataView = context.Data.LoadFromEnumerable(data);

Converts the list of data into an IDataView, which is the data format used by ML.NET. Think of it as rolling out the red carpet for our data.

Configuring the Transformation Pipeline:

var pipeline = context.Transforms.DetectSpikeBySsa(
    outputColumnName: nameof(AnomalyPrediction.Prediction),
    inputColumnName: nameof(SensorData.Value),
    confidence: 95.0,
    pvalueHistoryLength: data.Count / 2,
    trainingWindowSize: data.Count,
    seasonalityWindowSize: data.Count / 4);

Configures the transformation pipeline to detect spike anomalies using the DetectSpikeBySsa method.
confidence: Confidence level for anomaly detection.
pvalueHistoryLength: Length of the p-value history for detection.
trainingWindowSize: Training window size.
seasonalityWindowSize: Seasonality window size.

Training the Model:

var model = pipeline.Fit(dataView);

Trains the model using the provided data. It’s like teaching our bouncer what an unruly guest looks like.

Transforming the Data:

var transformedData = model.Transform(dataView);

Applies the trained model to the data to make predictions.

Extracting Predictions:

var predictions = context.Data.CreateEnumerable<AnomalyPrediction>(transformedData, reuseRowObject: false).ToList();

Converts the predictions into a list for analysis. Time to see who gets kicked out of the party!

Displaying the Results:

Console.WriteLine("Time\t\tValue\tAnomaly");
for (int i = 0; i < predictions.Count; i++)
{
    var sensorData = data[i];
    var prediction = predictions[i];
    var isAnomaly = prediction.Prediction[0] == 1;
    Console.WriteLine($"{sensorData.Time}\t{sensorData.Value}\t{isAnomaly}");
}

Iterates over the predictions and displays whether there is an anomaly for each data point.

Conclusion

With ML.NET, integrating artificial intelligence into your .NET applications becomes simple and accessible. Anomaly detection is a powerful tool for identifying unusual patterns in your data, helping to prevent failures, fraud, and more. We hope this guide has shown you how to start using ML.NET for anomaly detection in time series data. Give it a try ;)

To get the project running, just download it from my repository by clicking here

Ensuring Quality and Reliability with xUnit: Best Practices for Automated Testing in .NET Core

Alisson Podgurski — Sat, 27 Jul 2024 14:48:32 +0000

Introduction

Imagine building a house without checking if the doors close properly, the windows open as they should, or the electricity works. It sounds like a disaster waiting to happen, right? The same goes for software development. Automated testing is like a quality inspection that ensures everything is functioning perfectly before we deliver our "digital building." In this article, we will explore how xUnit can help us test our .NET Core code, ensuring everything is in order and working as expected.

Why test?

Automated testing is our line of defense against bugs, and it's amazing for several reasons:

Early bug detection:We find problems before they become giant monsters.
Living documentation: Keep an up-to-date record of system behavior (no boring paperwork!).
Safe refactoring: We can change the code without fear of breaking everything.
Trust and stability: We know our software works, and we can sleep easy.

What is xUnit?

xUnit is like a testing superhero in the .NET world. It is simple, efficient and powerful. Let's see how to configure and use this hero in our .NET Core project.

Configuring the environment

To get started, we need to invite our xUnit hero to the party. Let's add some packages to our testing project:

Add xunit and xunit.runner.visualstudio NuGet package:

dotnet add package xunit
dotnet add package xunit.runner.visualstudio

Add the reference to the main project in your test project:

dotnet add reference ../seu-projeto/SeuProjeto.csproj

Writing tests with xUnit

Let's create an example using an order management system, where we will test the business logic of an OrderService class that calculates the order total with discounts. Who doesn't love a good discount, right?

Order Class

public class Order
{
    public List<OrderItem> Items { get; set; }
    public decimal Discount { get; set; }

    public Order()
    {
        Items = new List<OrderItem>();
    }
}

public class OrderItem
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}

Classe OrderService

public class OrderService
{
    public decimal CalculateTotal(Order order)
    {
        if (order == null) throw new ArgumentNullException(nameof(order));
        if (order.Items == null || !order.Items.Any()) throw new ArgumentException("Order must have items.");

        var subtotal = order.Items.Sum(item => item.Price * item.Quantity);
        var discountAmount = subtotal * (order.Discount / 100);
        var total = subtotal - discountAmount;

        return total;
    }
}

Tests with xUnit

Testing OrderService

using Xunit;

public class OrderServiceTests
{
    [Fact]
    public void CalculateTotal_ShouldReturnCorrectTotal_WithoutDiscount()
    {
        // Arrange
        var order = new Order();
        order.Items.Add(new OrderItem { Name = "Item1", Price = 10, Quantity = 2 }); // Total 20
        order.Items.Add(new OrderItem { Name = "Item2", Price = 5, Quantity = 1 });  // Total 5
        var orderService = new OrderService();

        // Act
        var total = orderService.CalculateTotal(order);

        // Assert
        Assert.Equal(25, total);
    }

    [Fact]
    public void CalculateTotal_ShouldReturnCorrectTotal_WithDiscount()
    {
        // Arrange
        var order = new Order();
        order.Items.Add(new OrderItem { Name = "Item1", Price = 10, Quantity = 2 }); // Total 20
        order.Items.Add(new OrderItem { Name = "Item2", Price = 5, Quantity = 1 });  // Total 5
        order.Discount = 10; // 10% discount
        var orderService = new OrderService();

        // Act
        var total = orderService.CalculateTotal(order);

        // Assert
        Assert.Equal(22.5m, total);
    }

    [Fact]
    public void CalculateTotal_ShouldThrowArgumentNullException_IfOrderIsNull()
    {
        // Arrange
        var orderService = new OrderService();

        // Act & Assert
        Assert.Throws<ArgumentNullException>(() => orderService.CalculateTotal(null));
    }

    [Fact]
    public void CalculateTotal_ShouldThrowArgumentException_IfOrderHasNoItems()
    {
        // Arrange
        var order = new Order();
        var orderService = new OrderService();

        // Act & Assert
        Assert.Throws<ArgumentException>(() => orderService.CalculateTotal(order));
    }
}

Best Practices

Descriptive Test Method Names

Name your tests as if you are telling a story. Who doesn't love a good story?

[Fact]
public void CalculateTotal_ShouldReturnCorrectTotal_WithoutDiscount()
{
    // Arrange
    var order = new Order();
    order.Items.Add(new OrderItem { Name = "Item1", Price = 10, Quantity = 2 });
    order.Items.Add(new OrderItem { Name = "Item2", Price = 5, Quantity = 1 });
    var orderService = new OrderService();

    // Act
    var total = orderService.CalculateTotal(order);

    // Assert
    Assert.Equal(25, total);
}

AAA (Arrange, Act, Assert)

This is the magic formula for tests: prepare things, do the magic, and see if it worked.

The AAA (Arrange, Act, Assert) pattern is a recommended practice for writing unit tests that enhances readability, maintainability, and understanding of the tests. Below, I detail the reasons for using this pattern and how it applies to the provided example:

Clarity and Organization
Arrange: In this phase, you set up all the necessary dependencies and inputs for the test. This can include creating objects, setting states, and initializing services or mock objects.

Act: Here, you perform the action or method you want to test. It's the "magic act" where the main functionality being tested is invoked.

Assert: Finally, you verify that the outcome of the action is as expected. This is done using assertions that compare the actual result with the expected result.

Separation of Concerns
Each phase of AAA is clearly delineated, separating the test setup, execution of the test logic, and verification of the results. This makes the tests more readable and helps in identifying issues more easily.

Easier Maintenance
The clarity and organization provided by the AAA pattern make the test code easier to maintain. New developers or code reviewers can quickly understand what is being tested and how, enabling more efficient collaboration.

Efficient Diagnosis
When a test fails, it is easier to diagnose the cause. If a failure occurs in the arrange phase, you know there is an issue with the setup. If it fails in the execution, the problem is with the method under test. And if the assertion fails, there is an issue with the logic or the expected outcome.

See the example below:

[Fact]
public void CalculateTotal_ShouldReturnCorrectTotal_WithoutDiscount()
{
    // Arrange
    var order = new Order();
    order.Items.Add(new OrderItem { Name = "Item1", Price = 10, Quantity = 2 });
    order.Items.Add(new OrderItem { Name = "Item2", Price = 5, Quantity = 1 });
    var orderService = new OrderService();

    // Act
    var total = orderService.CalculateTotal(order);

    // Assert
    Assert.Equal(25, total);
}

Arrange: Creating an Order object and adding items with name, price, and quantity.
Instantiating the OrderService that will be used to calculate the total.

Act: Calling the CalculateTotal method on the OrderService with the configured order.

Assert: Verifying that the calculated total is equal to 25, which is the expected sum of the item prices in the order.

Practical Advantages

More Readable Tests: Tests following the AAA pattern are easier to read and understand, allowing new developers or code reviewers to quickly grasp the test's intent.

Easier Debugging: By clearly separating each phase, it becomes easier to debug the test and identify in which phase the failure occurred.

Modularity and Reusability: With separate setup and execution phases, parts of the test code can be reused in different scenarios, increasing modularity.

Independent Tests

Tests are like small children: they need to be independent of each other to avoid making a mess.

[Fact]
public void CalculateTotal_ShouldReturnCorrectTotal_WithoutDiscount()
{
    // Arrange
    var order = new Order();
    order.Items.Add(new OrderItem { Name = "Item1", Price = 10, Quantity = 2 });
    order.Items.Add(new OrderItem { Name = "Item2", Price = 5, Quantity = 1 });
    var orderService = new OrderService();

    // Act
    var total = orderService.CalculateTotal(order);

    // Assert
    Assert.Equal(25, total);
}

[Fact]
public void CalculateTotal_ShouldReturnCorrectTotal_WithDiscount()
{
    // Arrange
    var order = new Order();
    order.Items.Add(new OrderItem { Name = "Item1", Price = 10, Quantity = 2 });
    order.Items.Add(new OrderItem { Name = "Item2", Price = 5, Quantity = 1 });
    order.Discount = 10;
    var orderService = new OrderService();

    // Act
    var total = orderService.CalculateTotal(order);

    // Assert
    Assert.Equal(22.5m, total);
}

Using Theory and InlineData

Test multiple cases with a single shot. Two birds with one stone.

[Theory]
[InlineData(10, 2, 5, 1, 0, 25)]
[InlineData(10, 2, 5, 1, 10, 22.5)]
[InlineData(20, 1, 30, 1, 50, 25)]
public void CalculateTotal_ShouldReturnCorrectTotal_MultipleCases(decimal price1, int qty1, decimal price2, int qty2, decimal discount, decimal expected)
{
    // Arrange
    var order = new Order();
    order.Items.Add(new OrderItem { Name = "Item1", Price = price1, Quantity = qty1 });
    order.Items.Add(new OrderItem { Name = "Item2", Price = price2, Quantity = qty2 });
    order.Discount = discount;
    var orderService = new OrderService();

    // Act
    var total = orderService.CalculateTotal(order);

    // Assert
    Assert.Equal(expected, total);
}

Mocking Dependencies

Use mocks to pretend to be someone important. It's like theater, but for code.

public interface IDiscountService
{
    decimal GetDiscount(Order order);
}

public class OrderService
{
    private readonly IDiscountService _discountService;

    public OrderService(IDiscountService discountService)
    {
        _discountService = discountService;
    }

    public decimal CalculateTotal(Order order)
    {
        if (order == null) throw new ArgumentNullException(nameof(order));
        if (order.Items == null || !order.Items.Any()) throw new ArgumentException("Order must have items.");

        var subtotal = order.Items.Sum(item => item.Price * item.Quantity);
        var discount = _discountService.GetDiscount(order);
        var total = subtotal - discount;

        return total;
    }
}

public class OrderServiceTests
{
    [Fact]
    public void CalculateTotal_ShouldReturnCorrectTotal_WithMockDiscount()
    {
        // Arrange
        var mockDiscountService = new Mock<IDiscountService>();
        mockDiscountService.Setup(service => service.GetDiscount(It.IsAny<Order>())).Returns(5);

        var order = new Order();
        order.Items.Add(new OrderItem { Name = "Item1", Price = 10, Quantity = 2 });
        var orderService = new OrderService(mockDiscountService.Object);

        // Act
        var total = orderService.CalculateTotal(order);

        // Assert
        Assert.Equal(15, total);
    }
}

Integration Tests

Besides unit tests, write integration tests to ensure different parts of the system work correctly together. Like a band, all instruments need to be in tune.

public class OrderIntegrationTests
{
    [Fact]
    public async Task CalculateTotalEndpoint_ShouldReturnCorrectTotal()
    {
        // Arrange
        var client = new HttpClient();
        var order = new
        {
            Items = new[]
            {
                new { Name = "Item1", Price = 10m, Quantity = 2 },
                new { Name = "Item2", Price = 5m, Quantity = 1 }
            },
            Discount = 10
        };

        // Act
        var response = await client.PostAsJsonAsync("https://localhost:5001/api/order/calculate", order);

        // Assert
        response.EnsureSuccessStatusCode();
        var result = await response.Content.ReadAsStringAsync();
        Assert.Equal("22.5", result);
    }
}

Testing Exceptions

Ensure exceptions are thrown correctly in invalid scenarios. Because errors happen, and we need to be prepared.

[Fact]
public void CalculateTotal_ShouldThrowArgumentNullException_IfOrderIsNull()
{
    // Arrange
    var orderService = new OrderService();

    // Act & Assert
    Assert.Throws<ArgumentNullException>(() => orderService.CalculateTotal(null));
}

Testing Asynchronous Code

Make sure to test asynchronous methods properly. After all, no one likes to wait, not even your code.

public class OrderService
{
    public async Task<decimal> CalculateTotalAsync(Order order)
    {
        if (order == null) throw new ArgumentNullException(nameof(order));
        if (order.Items == null || !order.Items.Any()) throw new ArgumentException("Order must have items.");

        await Task.Delay(100); // Simulating async work

        var subtotal = order.Items.Sum(item => item.Price * item.Quantity);
        var discountAmount = subtotal * (order.Discount / 100);
        var total = subtotal - discountAmount;

        return total;
    }
}

public class OrderServiceAsyncTests
{
    [Fact]
    public async Task CalculateTotalAsync_ShouldReturnCorrectTotal_WithoutDiscount()
    {
        // Arrange
        var order = new Order();
        order.Items.Add(new OrderItem { Name = "Item1", Price = 10, Quantity = 2 });
        order.Items.Add(new OrderItem { Name = "Item2", Price = 5, Quantity = 1 });
        var orderService = new OrderService();

        // Act
        var total = await orderService.CalculateTotalAsync(order);

        // Assert
        Assert.Equal(25, total);
    }
}

Using Fixtures

Use IClassFixture to share setup and state between multiple tests. Like a host preparing everything for the guests.

public class OrderServiceFixture : IDisposable
{
    public OrderService OrderService { get; private set; }

    public OrderServiceFixture()
    {
        OrderService = new OrderService();
    }

    public void Dispose()
    {
        // Cleanup
    }
}

public class OrderServiceTests : IClassFixture<OrderServiceFixture>
{
    private readonly OrderServiceFixture _fixture;

    public OrderServiceTests(OrderServiceFixture fixture)
    {
        _fixture = fixture;
    }

    [Fact]
    public void CalculateTotal_ShouldReturnCorrectTotal_WithoutDiscount()
    {
        // Arrange
        var order = new Order();
        order.Items.Add(new OrderItem { Name = "Item1", Price = 10, Quantity = 2 });
        order.Items.Add(new OrderItem { Name = "Item2", Price = 5, Quantity = 1 });

        // Act
        var total = _fixture.OrderService.CalculateTotal(order);

        // Assert
        Assert.Equal(25, total);
    }
}

Conclusion

Automated tests are essential to ensure that our software works perfectly. By using xUnit in .NET Core projects, we can create clear and efficient tests, following best practices that guarantee code maintainability and scalability. While the topic of automated testing is vast and could fill volumes, this article aims to highlight the most critical aspects to help you develop high-quality tests in your application. Incorporating these principles and techniques into your workflow will bring long-term benefits, increasing the reliability and robustness of your software.

Using C# source code generators to automate development tasks

Alisson Podgurski — Sun, 21 Jul 2024 20:20:24 +0000

Source Generators are a powerful feature introduced in C# 9 and .NET 5 that allow you to inspect user code and generate new C# code files during compilation. They are particularly useful for automating repetitive tasks and improving development efficiency. In this article, we'll explore how to create a Source Generator that automatically generates enumerators (enums) and integrate it into a .NET console project.

What are Source Generators?

Source Generators are components that allow you to add code to your project during the compilation phase. They are run by the compiler and can generate new C# code files based on analysis of existing code. This can include boilerplate code generation, automatic validations, and more. The main advantage of Source Generators is that they help reduce the amount of repetitive code that developers need to write and maintain.

Benefits of Source Generators

Boilerplate Code Automation: Source Generators can automatically create the necessary repetitive code, such as properties, methods, or even entire classes, based on defined patterns. Less time to write repetitive code, more time to drink that special coffee.
Performance Improvement: As the code is generated at compile time, there is no overhead at run time, which can result in improved performance. Your code might even win an efficiency award.
Easier Maintenance: Reducing manual code reduces the chance of errors and makes code maintenance easier. Less bugs, more smiles.
Flexibility: They allow you to define consistent standards and practices across the entire codebase, ensuring a cleaner, more efficient architecture. Who doesn't like a well-organized codebase?

Practical Example: Enum Generator

In this example, we will create two projects:

EnumGenerator - The code generator project that creates enums.
EnumGeneratorDemoApp - The main project that consumes the generated enums.

Project Structure
The directory structure will be as follows:

EnumGeneratorDemo/ ├── EnumGenerator/ │ ├── EnumGenerator.csproj │ ├── EnumGenerator.cs │ └── obj/ ├── EnumGeneratorDemoApp/ │ ├── EnumGeneratorDemoApp.csproj │ ├── Program.cs │ └── obj/ └── EnumGeneratorDemo.sln

Step-by-Step Creation and Configuration

1. Creation of the Directory Structure

Create a directory for the project:

mkdir EnumGeneratorDemo
cd EnumGeneratorDemo

Create directories for the code generator and application:

mkdir EnumGenerator
mkdir EnumGeneratorDemoApp

2. Creation of the EnumGenerator Project

Navigate to the EnumGenerator directory and create a class library project:

cd EnumGenerator dotnet new classlib -n EnumGenerator

Add the required dependencies in the EnumGenerator.csproj file:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.10.0" />
  </ItemGroup>

</Project>

Create the EnumGenerator.cs file with the following content:

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Text;
using System.Linq;
using System.Text;

namespace EnumGenerator
{
    [Generator]
    public class EnumGenerator : ISourceGenerator
    {
        public void Initialize(GeneratorInitializationContext context)
        {
            System.Diagnostics.Debug.WriteLine("EnumGenerator initialized");
        }

        public void Execute(GeneratorExecutionContext context)
        {
            System.Diagnostics.Debug.WriteLine("EnumGenerator is running!");

            var enums = new[]
            {
                new { Name = "OrderStatus", Values = new[] { "Pending", "Processing", "Shipped", "Delivered", "Cancelled" } },
                new { Name = "UserRole", Values = new[] { "Admin", "User", "Guest" } }
            };

            foreach (var enumDef in enums)
            {
                var source = GenerateEnumSource(enumDef.Name, enumDef.Values);
                context.AddSource($"{enumDef.Name}.g.cs", SourceText.From(source, Encoding.UTF8));
                System.Diagnostics.Debug.WriteLine($"Generated {enumDef.Name}.g.cs");
            }
        }

        private string GenerateEnumSource(string enumName, string[] values)
        {
            var enumValues = string.Join(",\n    ", values);
            return $@"
namespace EnumGeneratorDemoApp.Enums
{{
    public enum {enumName}
    {{
        {enumValues}
    }}
}}
";
        }
    }
}

3. Creation of the EnumGeneratorDemoApp Project

Navigate to the EnumGeneratorDemoApp directory and create a console application project:

cd ../EnumGeneratorDemoApp
dotnet new console -n EnumGeneratorDemoApp

Add the reference to the EnumGenerator project in the EnumGeneratorDemoApp.csproj file:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\EnumGenerator\EnumGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
  </ItemGroup>

</Project>

Create the Program.cs file with the following content:

using EnumGeneratorDemoApp.Enums;
using System;

namespace EnumGeneratorDemoApp
{
    class Program
    {
        static void Main(string[] args)
        {
            var order = new Order
            {
                Id = Guid.NewGuid(),
                Status = OrderStatus.Pending
            };

            var user = new User
            {
                Id = Guid.NewGuid(),
                Role = UserRole.Admin
            };

            Console.WriteLine($"Order ID: {order.Id}, Status: {order.Status}");
            Console.WriteLine($"User ID: {user.Id}, Role: {user.Role}");
        }
    }

    public class Order
    {
        public Guid Id { get; set; }
        public OrderStatus Status { get; set; }
    }

    public class User
    {
        public Guid Id { get; set; }
        public UserRole Role { get; set; }
    }
}

4. Solution Creation and Adding Projects

Navigate back to the EnumGeneratorDemo directory and create a solution:

cd ..
dotnet new sln -n EnumGeneratorDemo
dotnet sln add EnumGenerator/EnumGenerator.csproj
dotnet sln add EnumGeneratorDemoApp/EnumGeneratorDemoApp.csproj

5. Compilation and Execution

Compile the EnumGenerator project first:

cd EnumGenerator
dotnet build

Build the EnumGeneratorDemoApp main project:

cd ../EnumGeneratorDemoApp
dotnet build

Run the main project:

dotnet run

6. Verification of Generated Files

Manually check if the .g.cs files were generated in the obj folder of the EnumGeneratorDemoApp project:

cd EnumGeneratorDemoApp/obj/Debug/net8.0/generated/EnumGeneratorDemoApp/

Conclusion

In this article, we explore how Source Generators can revolutionize the way you write and maintain code in C#. With our practical example, we saw how to create and configure an enum generator that automates the creation of enumerators during compilation, reducing the need to write repetitive code manually.

Source Generators offer a series of benefits, from improving performance to ease of maintenance and code standardization. By automating repetitive and tedious tasks, you free up more time to focus on the really important and creative parts of software development.

Additionally, the flexibility of Source Generators allows you to implement consistent standards and practices across your entire codebase, promoting a cleaner, more efficient architecture. Imagine a world where you don't have to worry about generating boilerplate code and can focus on developing innovative and robust solutions.

To complement your exploration of Source Generators, I recommend visiting the amis92/csharp-source-generators repository, which contains several examples and libraries that can help with development.

If you haven't tried Source Generators yet, now is the time. They not only increase your productivity but also improve the quality of your code. And as we've seen, setup and usage is simple and straightforward, especially with the power of .NET tools and libraries.

To check out the full example code discussed in this article, visit my Alisson Podgurski GitHub. I'll add the example further so you can explore and test it on your own.

So explore Source Generators and see how they can transform your workflow. Your codebase and your sanity will thank you!

Automating Task Organization with the openai-dotnet Library

Alisson Podgurski — Sat, 13 Jul 2024 15:22:44 +0000

Introduction

Productivity is a goal we all strive for, especially in a world where the to-do list seems never-ending. Fortunately, technology is here to help! In this article, we'll explore how to integrate GPT Chat with the openai-dotnet library to create a productivity assistant that organizes your tasks, prioritizes what's most important, and even offers personalized tips to improve your efficiency.

What is the openai-dotnet Library?

The openai-dotnet library is an amazing tool that allows developers to easily integrate GPT language models into their .NET applications. It's like having a super-intelligent virtual assistant by your side, ready to help in any situation.

Creating the Productivity Assistant

Let's start by creating a productivity assistant that does everything except wash the dishes. Here is the code we used:

using OpenAI.Chat;

public class TaskOrganizer
{
    private readonly ChatClient _chatClient;

    public TaskOrganizer(string apiKey)
    {
        _chatClient = new(model: "gpt-4o", apiKey);
    }

    public async Task<string> OrganizeTasksAsync(string taskList)
    {
        var prompt = $"Organize the following tasks by category and importance:\n\n{taskList}";
        var completion = await _chatClient.CompleteChatAsync(prompt);
        return completion.Value.ToString();
    }

    public async Task<string> PrioritizeTasksAsync(string organizedTasks)
    {
        var prompt = $"Based on the following organized tasks, suggest a priority list:\n\n{organizedTasks}";
        var completion = await _chatClient.CompleteChatAsync(prompt);
        return completion.Value.ToString();
    }

    public async Task<string> GetProductivityTipsAsync(string taskDetails)
    {
        var prompt = $"Based on the following task details, provide personalized productivity tips:\n\n{taskDetails}";
        var completion = await _chatClient.CompleteChatAsync(prompt);
        return completion.Value.ToString();
    }
}

Program Implementation

Now, let's configure the main program to use our TaskOrganizer class:

Don't forget to create your appsettings.json

{
  "OpenAI": {
    "ApiKey": "<your-key>"
  }
}

After that:

using Microsoft.Extensions.Configuration;

class Program
{
    public static async Task Main(string[] args)
    {
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .Build();

        var apiKey = configuration["OpenAI:ApiKey"];
        var assistant = new ProductivityAssistant(apiKey);
        await assistant.Run();
    }
}

public class ProductivityAssistant
{
    private readonly TaskOrganizer _taskOrganizer;

    public ProductivityAssistant(string apiKey)
    {
        _taskOrganizer = new TaskOrganizer(apiKey);
    }

    public async Task Run()
    {
        string taskList = "1. Complete project report\n2. Attend team meeting\n3. Respond to client emails\n4. Plan next week's schedule";
        string organizedTasks = await _taskOrganizer.OrganizeTasksAsync(taskList);
        Console.WriteLine($"Organized Tasks: {organizedTasks}\n\n");

        string priorityList = await _taskOrganizer.PrioritizeTasksAsync(organizedTasks);
        Console.WriteLine($"Priority List: {priorityList}\n\n");

        string taskDetails = "1. Complete project report - High importance, deadline tomorrow\n2. Attend team meeting - Medium importance, scheduled for 3 PM\n3. Respond to client emails - High importance, response needed by end of day\n4. Plan next week's schedule - Low importance, can be done anytime";
        string productivityTips = await _taskOrganizer.GetProductivityTipsAsync(taskDetails);
        Console.WriteLine($"Productivity Tips: {productivityTips}\n\n");
    }
}

Conclusion

Integrating GPT Chat with the openai-dotnet library is like having an intelligent personal assistant that helps you organize your tasks, prioritize what really matters and even offers tips to increase productivity. This approach not only keeps tasks in order, but also provides valuable insights to improve personal and team efficiency.

Try this integration in your own projects and discover how artificial intelligence can transform the way you manage your time and tasks. After all, who wouldn't like a little magic in their daily work?

Additional Notes

Make sure you have your OpenAI API key configured correctly in the appsettings.json file.
Experiment with adjusting the prompts to get different results that better suit your specific needs.
Stay tuned for updates to the openai-dotnet library to take advantage of new features and improvements.

Example Code

To see the full code for the example discussed in this article, visit the repository on GitHub.

Understanding the Differences between Overriding and Overloading in C#

Alisson Podgurski — Sun, 07 Jul 2024 15:51:28 +0000

In C#, two concepts that are often confused by beginner developers are overriding and overloading. Both involve the manipulation of methods, but their applications and purposes are different. Let's explore each one to better understand their differences.

Overloading

Overloading is the ability to define multiple methods with the same name but with different signatures within the same class. A method's signature consists of its name and the types of its parameters. Overloading is used to increase the flexibility and readability of the code, allowing the same method to be called in different ways.

Imagine you are a chef. You can cook a fried egg in various ways: with bacon, with cheese, or even with both. The result is always a delicious egg, but the way of preparing it is different. This is overloading!

Unique Example of Overloading:

public class Chef
{
    // Method to cook a simple fried egg
    public void CookEgg()
    {
        Console.WriteLine("Cooking a simple fried egg.");
    }

    // Method to cook a fried egg with bacon
    public void CookEgg(string bacon)
    {
        Console.WriteLine("Cooking a fried egg with bacon.");
    }

    // Method to cook a fried egg with bacon and cheese
    public void CookEgg(string bacon, string cheese)
    {
        Console.WriteLine("Cooking a fried egg with bacon and cheese.");
    }
}

In the example above, we have three CookEgg methods in the Chef class, each with a different signature. The C# compiler knows which method to call based on the parameters provided during the call.

Overriding

Overriding occurs when a derived class alters the behavior of a method inherited from a base class. To override a method, it must be declared as virtual in the base class and override in the derived class. This allows the derived class to provide its own implementation of the method.

Imagine you are an inventor who creates robots. Your grandfather invented a robot that only walks. Your father improved the robot so it can also run. Now, you want the robot to be able to fly as well. Each generation is "overriding" the move method of the previous generation with its own implementation.

Unique Example of Overriding:

public class Robot
{
    // Virtual method that can be overridden
    public virtual void Move()
    {
        Console.WriteLine("The robot is walking.");
    }
}

public class RunningRobot : Robot
{
    // Overriding the Move method in the derived RunningRobot class
    public override void Move()
    {
        Console.WriteLine("The robot is running.");
    }
}

public class FlyingRobot : RunningRobot
{
    // Overriding the Move method in the derived FlyingRobot class
    public override void Move()
    {
        Console.WriteLine("The robot is flying.");
    }
}

In the example above, the Robot class has a virtual method Move. The RunningRobot class inherits from Robot and overrides the Move method to provide a specific implementation for running. The FlyingRobot class inherits from RunningRobot and overrides the Move method again to allow the robot to fly. Thus, we have an evolution of the robot's behavior over generations.

Key Differences

Purpose:

Overloading: Allows creating methods with the same name but with different signatures to increase the flexibility of method calls.
Overriding: Allows a derived class to provide a new implementation of a method inherited from a base class.

Signatures:

Overloading: Overloaded methods must have different signatures (different types or number of parameters).
Overriding: The overridden method must have the same signature as the method in the base class.

Modifiers:

Overloading: Does not require special modifiers.
Overriding: Requires the virtual modifier in the base class and the override modifier in the derived class.

Conclusion

Understanding the difference between overloading and overriding is essential for writing efficient and flexible C# code. Overloading allows methods with the same name to be used in different ways, while overriding allows derived classes to customize or replace the behavior of inherited methods. Both are powerful tools in object-oriented programming and help create more reusable and organized code.

Remember: when overloading, think of flexibility, like a chef cooking in various ways. When overriding, think of evolution, like an inventor improving their creations with each generation.