Forem: Ravi Vishwakarma

EmailSpamChecker class for .NET Framework 4.7

Ravi Vishwakarma — Wed, 18 Jun 2025 16:53:15 +0000

Here’s a complete and reusable EmailSpamChecker class for .NET Framework 4.7, which performs:

Syntax validation
Blacklisted domain check
MX record verification (requires DnsClient NuGet)
Scoring logic for spam suspicion
Customizable domain block list

Step 1: Install DnsClient NuGet Package

From NuGet Package Manager Console:

Install-Package DnsClient

Step 2: EmailSpamChecker Class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Mail;
using System.Text.RegularExpressions;
using DnsClient;

public class EmailSpamChecker
{
    private static readonly string[] _blacklistedDomains = new[]
    {
        "mailinator.com", "10minutemail.com", "guerrillamail.com",
        "tempmail.com", "desy.xyz", "yopmail.com", "trashmail.com"
    };

    private static readonly string[] _suspiciousTlds = new[]
    {
        ".xyz", ".tk", ".gq", ".ml", ".cf"
    };

    public class SpamCheckResult
    {
        public bool IsValid { get; set; }
        public int SpamScore { get; set; }
        public List<string> Issues { get; set; } = new List<string>();
    }

    public static SpamCheckResult CheckEmail(string email)
    {
        var result = new SpamCheckResult();

        // Check basic syntax
        if (!IsValidSyntax(email))
        {
            result.Issues.Add("Invalid email syntax.");
            result.SpamScore += 2;
            result.IsValid = false;
            return result;
        }

        string domain = email.Split('@')[1].ToLower();

        // Check blacklist
        if (_blacklistedDomains.Contains(domain))
        {
            result.Issues.Add("Domain is blacklisted.");
            result.SpamScore += 3;
        }

        // Check suspicious TLD
        if (_suspiciousTlds.Any(tld => domain.EndsWith(tld)))
        {
            result.Issues.Add("Suspicious top-level domain.");
            result.SpamScore += 1;
        }

        // Check if it looks random (e.g., xas21@abc.xyz)
        if (IsRandomLooking(email))
        {
            result.Issues.Add("Username looks auto-generated or random.");
            result.SpamScore += 1;
        }

        // Check MX record
        if (!HasValidMxRecord(domain))
        {
            result.Issues.Add("Domain has no MX record (may not receive emails).");
            result.SpamScore += 2;
        }

        result.IsValid = result.SpamScore < 3;
        return result;
    }

    private static bool IsValidSyntax(string email)
    {
        try
        {
            var addr = new MailAddress(email);
            return addr.Address == email;
        }
        catch
        {
            return false;
        }
    }

    private static bool HasValidMxRecord(string domain)
    {
        try
        {
            var lookup = new LookupClient();
            var result = lookup.Query(domain, QueryType.MX);
            return result.Answers.MxRecords().Any();
        }
        catch
        {
            return false;
        }
    }

    private static bool IsRandomLooking(string email)
    {
        string user = email.Split('@')[0];

        // Count digits and special chars
        int digitCount = user.Count(char.IsDigit);
        int symbolCount = user.Count(c => !char.IsLetterOrDigit(c));

        // Very short or too random
        return user.Length < 5 || digitCount + symbolCount > 4;
    }
}

Usage Example

string inputEmail = "xyz@desy.xyz";
var result = EmailSpamChecker.CheckEmail(inputEmail);

if (!result.IsValid)
{
    Console.WriteLine("Potential spam or invalid email:");
    foreach (var issue in result.Issues)
        Console.WriteLine($"- {issue}");
}
else
{
    Console.WriteLine("Email looks clean.");
}

Output Example

Potential spam or invalid email:

Domain is blacklisted.
Suspicious top-level domain.
Domain has no MX record (may not receive emails).

Thanks
Keep Coding.

Clean Architecture in .net application step by step

Ravi Vishwakarma — Sat, 12 Apr 2025 13:54:40 +0000

Clean Architecture is a software design philosophy introduced by Robert C. Martin (Uncle Bob). Its goal is to create systems that are:

Independent of frameworks
Testable
Independent of UI or database
Flexible and maintainable

Key Principles

Separation of Concerns: Each layer of the application has a specific responsibility and doesn't mix with others.
Dependency Rule: Code dependencies must point inward, from outer layers (UI, DB) to inner layers (Use Cases, Entities). Inner layers know nothing about the outer layers.
Inversion of Control: High-level policies (business rules) shouldn't depend on low-level details (DB, APIs). Instead, interfaces should be used to invert control.
Independence:
- Framework Independent: Can change from ASP.NET to another without affecting core logic.
- Database Independent: Can switch from SQL Server to MongoDB.
- UI Independent: Can change from Web to Mobile easily.

The Layers

Domain Layer (Entities)
- Contains core business rules
- Framework and UI agnostic
- Pure business objects (e.g., User, Order)
Application Layer (Use Cases)
- Contains application-specific logic
- Coordinates the flow of data
- Interfaces with repositories
- E.g., CreateUser, GetOrders
Interface Adapters Layer
- Adapts data between use cases and frameworks
- Includes Controllers, Gateways, ViewModels
- Implements interfaces from Application Layer
Frameworks & Drivers
- External tools and frameworks (e.g., ASP.NET Core, EF Core)
- Dependency injection and infrastructure
- Least stable and most replaceable

Flow of Control

UI (Controller) → Use Case → Domain Logic → Output/Result

Controllers receive the input (e.g., HTTP request)
Pass data to the Use Case
Use Case performs business logic using the Domain
Returns results (e.g., DTOs or ViewModels)

⚖️ Advantages

High Testability – Business logic can be tested without UI or DB.
Easy to Maintain – Changes in UI/DB won’t affect core logic.
Scalability– Modular design helps teams work independently.
Reusability– Domain and Use Cases are reusable in different apps.

⚠️ Common Mistakes

Violating the dependency rule (e.g., use case calling Entity Framework directly)
Mixing business logic with framework code
Skipping interfaces (tight coupling)

🧱 Project Structure

Solution: CleanArchitectureDemo.sln
Projects:
├── CleanArchitectureDemo.Domain // Entities
├── CleanArchitectureDemo.Application // Use Cases
├── CleanArchitectureDemo.Infrastructure // DB / Repositories
├── CleanArchitectureDemo.API // Web API (Controllers)

🔧 Create Projects

dotnet new sln -n CleanArchitectureDemo

dotnet new classlib -n CleanArchitectureDemo.Domain
dotnet new classlib -n CleanArchitectureDemo.Application
dotnet new classlib -n CleanArchitectureDemo.Infrastructure
dotnet new webapi   -n CleanArchitectureDemo.API

Add them to the solution:

dotnet sln add CleanArchitectureDemo.Domain
dotnet sln add CleanArchitectureDemo.Application
dotnet sln add CleanArchitectureDemo.Infrastructure
dotnet sln add CleanArchitectureDemo.API

Add project references:

dotnet add CleanArchitectureDemo.Application reference CleanArchitectureDemo.Domain
dotnet add CleanArchitectureDemo.Infrastructure reference CleanArchitectureDemo.Application
dotnet add CleanArchitectureDemo.API reference CleanArchitectureDemo.Application
dotnet add CleanArchitectureDemo.API reference CleanArchitectureDemo.Infrastructure

📁 Layer Implementations

1. Domain/Entities/User.cs

namespace CleanArchitectureDemo.Domain.Entities
{
    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
    }
}

2. Application/Interfaces/IUserRepository.cs

using CleanArchitectureDemo.Domain.Entities;
using System.Collections.Generic;

namespace CleanArchitectureDemo.Application.Interfaces
{
    public interface IUserRepository
    {
        IEnumerable<User> GetAll();
        User GetById(int id);
    }
}

3. Application/UseCases/UserService.cs

using CleanArchitectureDemo.Application.Interfaces;
using CleanArchitectureDemo.Domain.Entities;
using System.Collections.Generic;

namespace CleanArchitectureDemo.Application.UseCases
{
    public class UserService
    {
        private readonly IUserRepository _userRepository;

        public UserService(IUserRepository userRepository)
        {
            _userRepository = userRepository;
        }

        public IEnumerable<User> GetUsers() => _userRepository.GetAll();

        public User GetUser(int id) => _userRepository.GetById(id);
    }
}

4. Infrastructure/Repositories/InMemoryUserRepository.cs

using CleanArchitectureDemo.Application.Interfaces;
using CleanArchitectureDemo.Domain.Entities;
using System.Collections.Generic;
using System.Linq;

namespace CleanArchitectureDemo.Infrastructure.Repositories
{
    public class InMemoryUserRepository : IUserRepository
    {
        private readonly List<User> _users = new()
        {
            new User { Id = 1, Name = "Alice", Email = "alice@example.com" },
            new User { Id = 2, Name = "Bob", Email = "bob@example.com" }
        };

        public IEnumerable<User> GetAll() => _users;

        public User GetById(int id) => _users.FirstOrDefault(u => u.Id == id);
    }
}

5. API/Controllers/UserController.cs

using Microsoft.AspNetCore.Mvc;
using CleanArchitectureDemo.Application.UseCases;
using CleanArchitectureDemo.Domain.Entities;
using System.Collections.Generic;

namespace CleanArchitectureDemo.API.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class UserController : ControllerBase
    {
        private readonly UserService _userService;

        public UserController(UserService userService)
        {
            _userService = userService;
        }

        [HttpGet]
        public IEnumerable<User> Get() => _userService.GetUsers();

        [HttpGet("{id}")]
        public ActionResult<User> Get(int id)
        {
            var user = _userService.GetUser(id);
            if (user == null)
                return NotFound();
            return user;
        }
    }
}

6. API/Program.cs – Register Dependencies

using CleanArchitectureDemo.Application.Interfaces;
using CleanArchitectureDemo.Application.UseCases;
using CleanArchitectureDemo.Infrastructure.Repositories;

var builder = WebApplication.CreateBuilder(args);

// Dependency Injection
builder.Services.AddScoped<IUserRepository, InMemoryUserRepository>();
builder.Services.AddScoped<UserService>();

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

app.UseSwagger();
app.UseSwaggerUI();

app.MapControllers();
app.Run();

Thanks
Keep Coding.

Reduce the page execution time

Ravi Vishwakarma — Sun, 06 Apr 2025 18:32:50 +0000

Alright, you're aiming for top-notch Core Web Vitals — crisp, smooth, fast-loading webpages that make Lighthouse go “WOW” and Google rank you like royalty 👑. Let’s break down the best practices to write HTML, CSS, JS, fonts, etc. that give you green scores across all Web Vitals:

HTML: Keep it Clean, Semantic & Lightweight

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>Your Awesome Page</title>

  <!-- Preconnects for performance -->
  <link rel="preconnect" href="https://fonts.googleapis.com" />
  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />

  <!-- Inline Critical CSS -->
  <style>
    /* Only critical styles here (for above-the-fold content) */
    body {
      font-family: 'Inter', sans-serif;
      margin: 0;
      padding: 0;
      background: #fff;
      color: #333;
    }
    h1 {
      font-size: 2rem;
      text-align: center;
      margin-top: 2rem;
    }
  </style>

  <!-- Load fonts properly -->
  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;700&display=swap" rel="stylesheet" />

  <!-- Defer non-critical CSS -->
  <link rel="stylesheet" href="styles.css" media="print" onload="this.media='all'" />
  <noscript><link rel="stylesheet" href="styles.css" /></noscript>

  <!-- Important: Avoid large JS in <head> -->
</head>
<body>

  <h1>Hello, Web Vitals!</h1>
  <button id="btn">Click Me</button>

  <!-- Minimal Critical JS (inlined) -->
  <script>
    document.addEventListener('DOMContentLoaded', () => {
      document.getElementById('btn').addEventListener('click', () => {
        alert('Hi there!');
      });
    });
  </script>

  <!-- Async/defer all non-critical JS -->
  <script src="main.js" defer></script>
</body>
</html>

CSS: Optimize, Minify & Use Only What’s Needed

Extract Critical CSS and inline it (manually or with tools like critical)
Load the rest asynchronously (media="print" trick)
Avoid unused styles (Lighthouse can show you these)
Use :where() or :is() instead of long selector chains (faster parsing)

JavaScript: Split, Defer, and Delay

Inline only critical JS
Use defer for everything else
Use code splitting (in frameworks like React, Vue, etc.)
Avoid large JS bundles — aim for <150KB (gzipped) for initial load
Lazy-load expensive features like charts, sliders, chat widgets

Fonts: Load Fast and Avoid Layout Shifts

Use font-display: swap (default with Google Fonts)
Preconnect to fonts.googleapis.com and fonts.gstatic.com
Prefer system fonts for super-fast load (optional)

@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;700&display=swap');

OR use:

font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;

Images: Compress, Lazy Load, Responsive

<img src="banner.jpg" loading="lazy" alt="Banner" width="600" height="400" />

Use loading="lazy"
Add width and height attributes to prevent CLS (layout shift)
Prefer WebP or AVIF
Use srcsetfor responsive images if needed

Core Web Vitals Targets (What You’re Chasing)
Metric Goal
LCP (Largest Contentful Paint) < 2.5s
FID (First Input Delay) < 100ms
CLS (Cumulative Layout Shift) < 0.1
TTI (Time to Interactive) As fast as possible

Thank You,
Keep coding

Understanding Strong Password Regex in C#: From Basic to Advanced

Ravi Vishwakarma — Mon, 03 Feb 2025 13:09:57 +0000

Introduction

In today’s digital age, ensuring password security is a critical aspect of software development. One way to enforce security standards is by using regular expressions (Regex) to validate passwords. In this article, we will explore different levels of password complexity, ranging from basic to advanced, using C#.

1. Basic Password Validation

A basic password validation rule simply enforces a minimum length. The following Regex pattern ensures that a password is at least 8 characters long:

string basicRegex = "^.{8,}$";

Explanation:

^ and $ mark the start and end of the string.
.{8,} ensures the password has at least 8 characters of any type.

While this rule prevents extremely short passwords, it does not enforce complexity.

2. Intermediate Password Validation

To increase security, we can require passwords to contain at least one letter and one digit:

string intermediateRegex = "^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$";

Explanation:

(?=.*[A-Za-z]) ensures at least one letter (uppercase or lowercase).
(?=.*\d) ensures at least one digit.
[A-Za-z\d]{8,} allows only letters and digits, with a minimum of 8 characters.

This regex prevents purely numeric or alphabetical passwords but still lacks special character enforcement.

3. Advanced Password Validation (Strong Passwords)

A strong password should meet the following criteria:

At least 8 characters long.
Contains at least one lowercase letter.
Contains at least one uppercase letter.
Contains at least one digit.
Contains at least one special character from a predefined set (e.g., @$!%*?&).

Regex for Strong Passwords:

string advancedRegex = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$";

string extendedAdvancedRegex = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&^#()[\]{}|\\/\-+_.:;=,~`])[^\s<>]{8,}$";

Explanation:

(?=.*[a-z]) ensures at least one lowercase letter.
(?=.*[A-Z]) ensures at least one uppercase letter.
(?=.*\d) ensures at least one digit.
(?=.*[@$!%*?&]) ensures at least one special character.
(?=.*[@$!%*?&^#()[\]{}|\\/\-+_.:;=,~]) ensures at least one special character from an extended set.
[^\s<>]{8,} ensures a minimum length of 8 characters while restricting whitespace and certain unsafe characters.

This pattern significantly enhances password security and meets most modern security standards.

4. Implementing Password Validation in C#

Below is a simple C# program that validates passwords using Regex:

using System;
using System.Text.RegularExpressions;

public class PasswordValidator
{
    public static bool IsValidPassword(string password, string pattern)
    {
        return Regex.IsMatch(password, pattern);
    }

    public static void Main()
    {
        string password = "StrongP@ss1";

        // Use one of the regex patterns defined above
        string pattern = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&^#()[\]{}|\\/\-+_.:;=,~`])[^\s<>]{8,}$";

        if (IsValidPassword(password, pattern))
            Console.WriteLine("Password is valid!");
        else
            Console.WriteLine("Password does not meet the requirements.");
    }
}

Conclusion

Implementing password validation using Regex in C# ensures strong security policies for user authentication. By progressively enforcing length, character variety, and complexity, we can significantly reduce vulnerabilities related to weak passwords.

For enterprise-level applications, additional security measures such as multi-factor authentication (MFA) and rate-limiting login attempts should also be implemented alongside Regex-based password validation.

Connect with Me!
Thanks for reading! If you found this helpful, consider following me for more content like this.

🌟 LinkedIn
💻 GitHub

Your support motivates me to keep sharing valuable insights. Stay tuned for more! 🚀

Thanks for Reading.

AddMVC() vs AddControllersWithViews() vs AddControllers() vs AddRazorPages() | ASP.Net Core

Ravi Vishwakarma — Tue, 28 Jan 2025 02:42:18 +0000

In ASP.NET Core, the methods AddMvc(), AddControllersWithViews(), AddControllers(), and AddRazorPages() are used to configure services for various application architectures. Each of these methods serves a specific purpose depending on the type of application you are building.

AddMvc()

Purpose: Configures the app to use the complete ASP.NET Core MVC framework, including support for controllers, views, Razor Pages, and API features.

Status: This method is obsolete in recent ASP.NET Core versions (3.0 and later). It's replaced by more granular methods like AddControllersWithViews() or AddRazorPages().

Use Case: Used in older versions (before ASP.NET Core 3.0) to set up both MVC and Razor Pages in a single step.

AddControllersWithViews()

Purpose: Configures the app to support controllers and views (for MVC-style web apps). Does not include Razor Pages.

Use Case: Ideal for traditional MVC web applications where controllers and views are the primary focus.
Suitable for server-rendered HTML with routing, model binding, and validation.
Features: Adds support for controllers and views.
Does not support Razor Pages (e.g., .cshtml files under the /Pages folder).

Example:

builder.Services.AddControllersWithViews();

AddControllers()

Purpose: Configures the app to support controllers only, for building API applications without views.

Use Case: Suitable for building Web APIs. Does not include Razor Pages or support for views.
Features: Adds support for controllers, but excludes Razor Pages and views. Focused on API endpoints, ideal for RESTful services.

Example:

builder.Services.AddControllers();

AddRazorPages()

Purpose: Configures the app to support Razor Pages, a page-focused programming model.

Use Case: Ideal for applications primarily using Razor Pages for server-side rendering. Suitable for smaller apps or apps with a page-oriented architecture (e.g., intranet applications).

Features:
Supports Razor Pages (e.g., .cshtml files under the /Pages folder).
Does not support controllers or views unless explicitly added.

Example:

builder.Services.AddRazorPages();

.NET Core Middleware Comparison Table

Method	Controllers	Views	Razor Pages	APIs (JSON/XML responses)
AddMvc()	✅	✅	✅	✅
AddControllersWithViews()	✅	✅	❌	✅
AddControllers()	✅	❌	❌	✅
AddRazorPages()	❌	❌	✅	❌

Choosing the Right Method

For APIs:

Use AddControllers().
Example: Building a RESTful API that does not require views or Razor Pages.

For Traditional MVC Applications:

Use AddControllersWithViews().
Example: Building a web app with controllers and views for server-side rendering.

For Razor Pages Applications:

Use AddRazorPages().
Example: Building a simple page-oriented application with .cshtml files under /Pages.

For Hybrid Scenarios:

Combine AddControllersWithViews() and AddRazorPages() for apps that need both controllers and Razor Pages.

builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();

Best Practices

Use specific configurations (e.g., AddControllersWithViews(), AddRazorPages()) instead of AddMvc() for better clarity and performance.
Choose the appropriate method based on your application's architecture and the required features.
If your app includes API endpoints and views, combine AddControllersWithViews() with features like JsonOptions to configure API behavior.

Connect with Me!
Thanks for reading! If you found this helpful, consider following me for more content like this.

🌟 LinkedIn
💻 GitHub

Your support motivates me to keep sharing valuable insights. Stay tuned for more! 🚀

Thanks for Reading.

Comprehensive Guide to Documentation Comments in C#

Ravi Vishwakarma — Sun, 19 Jan 2025 11:20:09 +0000

Documentation comments in C# are structured comments that describe code functionality and are processed by tools like Visual Studio and Sandcastle to generate user-friendly documentation. These comments are written in XML format and placed above code elements like classes, methods, properties, and fields.

Syntax for Documentation Comments in C#
In C#, documentation comments start with three slashes (///) and support XML-based tags to provide detailed descriptions.

Example

/// <summary>
/// Represents a basic calculator for arithmetic operations.
/// </summary>
public class Calculator
{
    // Class implementation
}

Common XML Tags in C#
Here are the most commonly used XML tags in C# documentation comments:

General Tags

<summary>: Provides a brief summary of a class, method, or property.
<remarks>: Adds additional or detailed remarks about the element.
<example>: Contains code examples to demonstrate usage.
<value>: Describes the value returned by a property.
<inheritdoc>: Inherits documentation from the base class or interface.

Method-Specific Tags

<param>: Describes a method parameter.
<returns>: Documents the return value of a method.
<exception>: Describes exceptions thrown by the method.

Cross-Referencing Tags

<see>: Links to another code element for inline reference.
<seealso>: Refers to related code elements for more information.
<c>: Embeds inline code.
<code>: Displays a block of code in the documentation.

Examples of Documentation Comments in C#

Documenting a Class

/// <summary>
/// Performs basic arithmetic operations such as addition and subtraction.
/// </summary>
/// <remarks>
/// This class is intended for demonstration purposes only.
/// </remarks>
public class Calculator
{
    // Class implementation
}

Documenting a Method

/// <summary>
/// Adds two integers and returns the result.
/// </summary>
/// <param name="a">The first integer.</param>
/// <param name="b">The second integer.</param>
/// <returns>The sum of the two integers.</returns>
/// <exception cref="ArgumentNullException">Thrown if a or b is null.</exception>
public int Add(int a, int b)
{
    if (a == null || b == null)
    {
        throw new ArgumentNullException("Parameters cannot be null.");
    }
    return a + b;
}

Documenting a Property

/// <summary>
/// Gets or sets the name of the calculator's manufacturer.
/// </summary>
/// <value>
/// A string representing the manufacturer's name.
/// </value>
public string Manufacturer { get; set; }

Documenting an Example

/// <example>
/// <code>
/// Calculator calc = new Calculator();
/// int result = calc.Add(5, 10);
/// Console.WriteLine(result); // Output: 15
/// </code>
/// </example>
public int Add(int a, int b)
{
    return a + b;
}

Best Practices for Documentation Comments in C#

Write Clear Summaries: Use to describe the purpose of a code element in a concise and meaningful way.
Use and Tags Appropriately: Ensure all method parameters and return values are documented.
Provide Examples: Use tags to demonstrate usage, especially for complex methods.
Link to Related Elements: Utilize and to refer readers to related parts of the codebase.
Maintain Consistency: Follow consistent formatting and style for all documentation comments.
Update Regularly: Sync documentation comments with code changes to prevent inaccuracies.

For more go to Microsoft Documentation

Thanks for reading.

Global Class Validator for Enhanced Object Validation in EMS

Ravi Vishwakarma — Sun, 19 Jan 2025 10:01:25 +0000

Introducing Global Class Validator: Streamlined Object Validation for Employee Management Systems

Validation is a critical aspect of any application that handles structured data. To ensure accuracy, consistency, and compliance with business logic, validation must be seamless and reliable.

Our Global Class Validator is a powerful utility tailored for .NET applications, particularly useful in systems like the Employee Management System. It simplifies object validation by leveraging .NET’s built-in ValidationAttributeand ensures that your data meets defined standards effortlessly.

Key Features

Thread-Safe Error Tracking: Errors are captured and stored in a thread-safe manner, ensuring accurate results even in multi-threaded environments.
Dynamic Property Validation: The validator dynamically inspects all public properties of an object and applies the associated ValidationAttributeto validate their values.
Comprehensive Error Handling: The tool provides methods to retrieve errors in multiple formats:

GetErrors: Returns a collection of validation errors for detailed inspection.
GetErrorsString: Provides a string-formatted summary of all validation errors.

4.Ease of Use: Add a simple IsValidmethod to your model, and the validator will handle everything from validation checks to error aggregation.

Sample Usage

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.VisualBasic;

namespace Employee_Management_System
{
    internal class EmployeeModel
    {
        public EmployeeModel() { }

        [Required]
        [Range(0, uint.MaxValue)]
        public int EmployeeID { get; set; }

        [Required]
        [StringLength(100, MinimumLength = 2)]
        public string Name { get; set; }

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

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

        [Required]
        [RegularExpression(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$", ErrorMessage = "Please enter valid EmailID. ")]
        public string Email { get; set; }

        [Required]
        [RegularExpression(@"^\d{8,}$", ErrorMessage = "Please enter valid PhoneNumber. ")]
        public string Phone { get; set; }

        [Required]
        public DateTime JoiningDate { get; set; }

        public EmployeeModel(int employeeID, string name, string designation, string department, string email, string phone, DateTime joiningDate)
        {
            EmployeeID = employeeID;
            Name = name;
            Designation = designation;
            Department = department;
            Email = email;
            Phone = phone;
            JoiningDate = joiningDate;
        }
    }
}

Here’s how you can integrate and use the Global Class Validator in your .NET projects:

var employee = new EmployeeModel { Name = "", Email = "develop" }; // Example model with errors  

bool IsValid = ClassModelValidator<EmployeeModel>.IsValid(employee);

if (!IsValid)
{
     MessageBox.Show( ClassModelValidator<EmployeeModel>.GetErrorsString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}

Code Implementation

Below is the full implementation of the GlobalClassValidator class for your reference:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;

namespace Employee_Management_System.Helper
{
    public static class ClassModelValidator<T> where T : class
    {
        // Errors list for tracking validation issues
        [ThreadStatic]
        private static List<string> Errors;

        static ClassModelValidator()
        {
            Errors = new List<string>();
        }



        public static bool IsValid(T model)
        {
            if (model == null)
            {
                AddError("Model cannot be null.");
                return false;
            }

            Errors.Clear();

            foreach (var property in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                var value = property.GetValue(model);
                foreach (var attribute in property.GetCustomAttributes<ValidationAttribute>())
                {
                    if (!attribute.IsValid(value))
                    {
                        AddError(attribute.FormatErrorMessage(property.Name));
                    }
                }
            }

            return Errors.Count == 0;
        }

        public static IEnumerable<string> GetErrors()
        {
            return Errors;
        }

        public static string GetErrorsString()
        {
            return string.Join(Environment.NewLine, Errors);
        }

        private static void AddError(string error)
        {
            if (!string.IsNullOrEmpty(error))
            {
                Errors.Add(error);
            }
        }
    }
}

Benefits of Using Global Class Validator

Enhances data integrity with minimal overhead.
Reduces boilerplate code by utilizing reflection and attributes.
Easily extensible for specific validation requirements.

With the Global Class Validator, you can ensure that your Employee Management System is robust, efficient, and error-free.

Feel free to integrate this utility into your projects and let us know how it transforms your validation processes!

Thanks for Reading!

For more details, visit:
🔗 Employee Management System on GitHub

Direct link to the code:
🔗 ClassModelValidator.cs

Feel free to explore the repository and contribute! 🚀

Generate SEO-Friendly Slugs from Titles in ASP.NET Core

Ravi Vishwakarma — Sun, 05 Jan 2025 09:50:55 +0000

To create shorter, user-friendly, or "slugged" URLs with Latin-based names, you can use URL slugging. This process typically involves converting strings (like page titles or names) into lowercase, replacing spaces and special characters with hyphens or other valid URL characters, and ensuring the resulting URL is unique and human-readable.

Example: Generating Latin Name Slugs for URLs in ASP.NET Core

Create a Utility Method for Slug Generation

A utility method can convert any string into a slug-friendly format.

using System.Text;
using System.Text.RegularExpressions;
public static class UrlSlugger
{
    public static string GenerateSlug(string input)
    {
        if (string.IsNullOrEmpty(input))
            return string.Empty;

        // Convert to lowercase
        input = input.ToLowerInvariant();

        // Remove diacritics (accents) from Latin characters
        input = RemoveDiacritics(input);

        // Replace spaces and invalid characters with hyphens
        input = Regex.Replace(input, @"[^a-z0-9\s-]", ""); // Allow only alphanumeric, spaces, and hyphens
        input = Regex.Replace(input, @"\s+", "-").Trim();  // Replace spaces with hyphens
        input = Regex.Replace(input, @"-+", "-");         // Replace multiple hyphens with a single one

        return input;
    }

    private static string RemoveDiacritics(string text)
    {
        var normalizedString = text.Normalize(NormalizationForm.FormD);
        var stringBuilder = new StringBuilder();

        foreach (var c in normalizedString)
        {
            var unicodeCategory = System.Globalization.CharUnicodeInfo.GetUnicodeCategory(c);
            if (unicodeCategory != System.Globalization.UnicodeCategory.NonSpacingMark)
            {
                stringBuilder.Append(c);
            }
        }

        return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
    }
}

Using the Slug Generator in Your Application

You can use this slug generator for URLs when defining routes or generating links dynamically.

Example in Controller:

public IActionResult GenerateSluggedUrl(string title)
{
    string slug = UrlSlugger.GenerateSlug(title);
    return Ok($"Generated slug: {slug}");
}

Example Usage:
For a title like "Éxample Title for URL!", the slug will be:

example-title-for-url

Integrating Slugs in Routing

To use slugs in your routing, you can define a route pattern with a {slug} parameter and parse the slug dynamically.

Example in Program.cs:

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "sluggedRoute",
        pattern: "page/{slug}",
        defaults: new { controller = "Page", action = "Details" });

    // Default route
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");
});

Example in PageController:

public class PageController : Controller
{
    public IActionResult Details(string slug)
    {
        // Retrieve the page data by the slug
        return View(model: $"Page with slug: {slug}");
    }
}

Testing Slugged URLs

Example URLs:
/page/example-title-for-url
/page/sample-page-title
Result:
You can use the slug parameter in the controller to load content based on the slug (e.g., querying the database for matching pages).

Additional Tips

Ensure slugs are unique for your content. Add a database field to store slugs and validate uniqueness.
Store slugs in your database alongside the corresponding entity (e.g., articles, pages, or products).
Use slugs in links to improve SEO and user experience.

Thanks

Roman to Integer

Ravi Vishwakarma — Wed, 25 Dec 2024 10:12:00 +0000

Roman numerals, originating from ancient Rome, utilize combinations of Latin letters to represent values:

I = 1
V = 5
X = 10
L = 50
C = 100
D = 500
M = 1000

Typically, numerals are written from largest to smallest from left to right. However, to represent numbers like 4 and 9, a subtractive notation is used, where a smaller numeral precedes a larger one, indicating subtraction. For example, IV represents 4 (5 - 1), and IX represents 9 (10 - 1).
MEDIUM

To convert a Roman numeral to an integer, follow these steps:

Initialize a total sum to zero.
Traverse the Roman numeral from left to right.
For each symbol:

If its value is less than the value of the next symbol, subtract it from the total.
Otherwise, add its value to the total.

This method accounts for both additive and subtractive combinations in Roman numerals.

For example, to convert "MCMXCIV" to an integer:

M (1000)
CM (900)
XC (90)
IV (4)

Adding these values together: 1000 + 900 + 90 + 4 = 1994.

This approach ensures accurate conversion of Roman numerals to their integer equivalents.

Example 1
`
using System;
class Program
{
static void Main()
{
string roman = "MCMXCIV"; // Example Roman numeral
int result = RomanToInt(roman);
Console.WriteLine($"The integer value of {roman} is {result}.");
}

static int RomanToInt(string s)
{
    int total = 0;
    int prevValue = 0;

    foreach (char c in s)
    {
        int currentValue = RomanCharToValue(c);

        if (currentValue > prevValue)
        {
            // Subtract twice the previous value since it was added earlier
            total += currentValue - 2 * prevValue;
        }
        else
        {
            total += currentValue;
        }

        prevValue = currentValue;
    }

    return total;
}

static int RomanCharToValue(char c)
{
    switch (c)
    {
        case 'I': return 1;
        case 'V': return 5;
        case 'X': return 10;
        case 'L': return 50;
        case 'C': return 100;
        case 'D': return 500;
        case 'M': return 1000;
        default: throw new ArgumentException("Invalid Roman numeral character");
    }
}

}

Example 2
`
class RomanToInt {
public static int _RomanToInt(string s)
{
int total = 0, prevValue = 0, currentValue = 0;

    for (int i = s.Length - 1; i >= 0; i--)
    {
        switch (s[i])
        {
            case 'I':  currentValue =  1; break;;
            case 'V': currentValue =  5; break;;
            case 'X': currentValue =  10; break;;
            case 'L': currentValue =  50; break;;
            case 'C': currentValue =  100; break;;
            case 'D': currentValue =  500; break;;
            case 'M': currentValue =  1000; break;;
            default: throw new ArgumentException("Invalid Roman numeral character");
        }
        total = (currentValue > prevValue) ? (total + currentValue) : total - currentValue;
        prevValue = currentValue;
    }

    return total;
}

}

Thanks for Reading.