DEV Community: Zanyar Jalal

Creating Custom Exceptions in C#

Zanyar Jalal — Thu, 27 Jul 2023 12:26:30 +0000

Introduction:

Briefly explain the importance of error handling in applications.
Introduce the concept of custom exceptions and how they can help developers better manage errors.
Mention that in this post, you'll be covering how to create and use custom exceptions in C#.

Section 1: Understanding Built-in Exceptions

Provide a quick overview of the built-in exceptions available in C# (e.g., System.Exception, System.ArgumentException, System.NullReferenceException, etc.).
Explain scenarios where using built-in exceptions might not be sufficient for your specific use cases.

Section 2: Creating Custom Exceptions

Describe the process of creating custom exceptions in C#.
Show how to define a custom exception class by inheriting from System.Exception or any other relevant base exception class.
Provide guidance on choosing meaningful names for custom exceptions that reflect the type of errors they represent.

Section 3: Adding Custom Properties and Constructors

Explain how to extend custom exceptions with additional properties to provide more context about the error.
Demonstrate how to create constructors for custom exceptions to simplify error message handling.

Section 4: Throwing and Handling Custom Exceptions

Show how to throw custom exceptions using the throwkeyword.
Explain the importance of proper exception handling using try-catch blocks.
Discuss best practices for logging and displaying custom exception information.

Section 5: Creating Hierarchical Custom Exceptions (Optional)

For more advanced scenarios, you can explain how to create a hierarchy of custom exceptions to categorize different types of errors within your application.

Example

using System;

// Custom exception class
public class CustomException : Exception
{
    public CustomException() { }

    public CustomException(string message) : base(message) { }

    public CustomException(string message, Exception innerException) : base(message, innerException) { }
}

// Example usage of the custom exception
public class Calculator
{
    public int Divide(int dividend, int divisor)
    {
        if (divisor == 0)
        {
            throw new CustomException("Division by zero is not allowed.");
        }

        return dividend / divisor;
    }
}

public class Program
{
    public static void Main()
    {
        Calculator calculator = new Calculator();
        int dividend = 10;
        int divisor = 0;

        try
        {
            int result = calculator.Divide(dividend, divisor);
            Console.WriteLine($"Result: {result}");
        }
        catch (CustomException ex)
        {
            Console.WriteLine($"Custom Exception: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Other Exception: {ex.Message}");
        }
    }
}

Conclusion:

Summarize the benefits of using custom exceptions in C#.
Encourage developers to implement custom exceptions for their applications to improve error management and debugging.
Provide any additional resources or links for further reading.

Background Services in .NET Core: Building Efficient and Scalable Applications

Zanyar Jalal — Sun, 23 Jul 2023 06:21:48 +0000

Introduction:
In modern application development, it's not uncommon to encounter tasks that need to be executed in the background, such as sending emails, processing data, or performing scheduled jobs. These background tasks are crucial for maintaining a responsive user experience and ensuring the smooth operation of your application. In this post, we'll explore how to implement background services in .NET Core, a powerful feature that enables developers to efficiently handle such tasks.

What are Background Services?
Background services, also known as hosted services, are components in .NET Core applications that run in the background independently of user requests. They are implemented as long-running tasks that execute periodically or remain active throughout the application's lifetime. .NET Core provides a convenient and robust way to create and manage these services.

Creating a Background Service:
To create a background service in .NET Core, start by creating a new class that derives from the BackgroundService base class. This class will contain the logic for your background task.

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

public class MyBackgroundService : BackgroundService
{
    private readonly ILogger<MyBackgroundService> _logger;

    public MyBackgroundService(ILogger<MyBackgroundService> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // Your background task logic goes here
            _logger.LogInformation("Background service is running at: {time}", DateTimeOffset.Now);
            await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
        }
    }
}

In this example, we create a background service called MyBackgroundService. The ExecuteAsync method is overridden, and within it, we run a continuous loop that logs a message every 30 seconds. You can replace the logging with any other background task, such as sending emails, processing data, etc.

Register the Background Service:

Next, we need to register the background service in the ConfigureServices method of the Startup class.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

public class Startup
{
    // Other configuration code

    public void ConfigureServices(IServiceCollection services)
    {
        // Register the background service
        services.AddHostedService<MyBackgroundService>();

        // Other service registrations
    }

    // Other configuration code
}

With this registration, the background service will start running automatically when the application starts.

Handling Asynchronous Tasks:
Often, background tasks involve asynchronous operations, such as calling external APIs or performing database operations. Within the ExecuteAsync method, you can use the Task.Run method or async/await to handle these asynchronous tasks efficiently. Be mindful of properly handling exceptions and cancellation tokens in such scenarios.

Conclusion:
Background services are a valuable feature in .NET Core that allows developers to efficiently handle long-running tasks and background processing. Whether you need to perform periodic operations, process data asynchronously, or handle scheduled jobs, background services provide a scalable and robust solution for your application. By understanding the concepts discussed in this post and incorporating them into your projects, you'll be well-equipped to build responsive and efficient .NET Core applications.

Happy coding! 🚀

Exploring MS SQL Server Triggers

Zanyar Jalal — Wed, 12 Jul 2023 11:24:55 +0000

Introduction:

Triggers in MS SQL Server are powerful tools that automate actions in response to specific events. In this post, we'll dive into the world of triggers and explore their various types, creation process, functionality, best practices, and real-world examples.

Types of Triggers:

MS SQL Server supports two main types of triggers: Data Manipulation Language (DML) triggers and Data Definition Language (DDL) triggers.

DML Triggers: DML triggers execute in response to modifications made to the data within tables. They are useful for enforcing data integrity rules, implementing auditing mechanisms, and executing custom business logic. Here's an example of a DML trigger that logs any updates to a customer table:

CREATE TRIGGER CustomerUpdateTrigger
ON Customers
AFTER UPDATE
AS
BEGIN
    INSERT INTO CustomerLogs (CustomerId, LogMessage, LogDate)
    SELECT Id, 'Customer updated', GETDATE()
    FROM inserted;
END

DDL Triggers:

DDL triggers execute in response to Data Definition Language (DDL) events, such as table creations, modifications, or deletions. They enable you to enforce specific rules or policies related to database schema changes. Here's an example of a DDL trigger that prevents dropping a table:

CREATE TRIGGER PreventTableDropTrigger
ON DATABASE
FOR DROP_TABLE
AS
BEGIN
    IF EXISTS (SELECT * FROM sys.objects WHERE name = EVENTDATA().value('(/EVENT_INSTANCE/ObjectName)[1]', 'nvarchar(max)'))
    BEGIN
        PRINT 'Dropping tables is not allowed.';
        ROLLBACK;
    END
END

Creating Triggers:
To create triggers in MS SQL Server, you need to follow a specific syntax and define the trigger scope, timing, and event conditions. Make sure to include proper error handling and consider any potential performance implications.

Functionality and Use Cases:

Triggers offer a wide range of functionality, including enforcing complex data integrity rules, auditing changes, implementing cascading updates, and executing business logic. They can be used for scenarios like tracking changes to critical data, automatically updating deformalized tables, or enforcing referential integrity.

Best Practices:
When working with triggers, it's essential to follow some best practices:

Keep triggers concise and focused on a specific task.
Avoid recursive triggers by using appropriate conditions and filters.
Thoroughly test triggers and consider their performance impact.
Document the purpose and functionality of triggers for easier maintenance.

Real-world Examples:

Audit Log Trigger: Show how a trigger can log changes made to a specific table, capturing the old and new values for auditing purposes.
Denormalization Trigger: Demonstrate a trigger that automatically updates a deformalized table whenever data in the source table changes.

Conclusion:
MS SQL Server triggers provide a powerful mechanism for automating actions in the database. By understanding their types, creation process, functionality, and best practices, developers can harness their potential to enhance data integrity, implement business rules, and streamline database operations.

What's New in C# 11: Features and Tips for Developers

Zanyar Jalal — Tue, 11 Jul 2023 11:37:07 +0000

Introduction:
Introducing the latest version of C#, version 11, packed with exciting new features and enhancements that will level up your development experience. In this article, we'll explore some of the noteworthy features and tips introduced in C# 11 and demonstrate how they can improve your code. Let's dive in!

1) Implicit using declarations:
Say goodbye to repetitive using directives! C# 11 introduces the global using statement, allowing you to implicitly import namespaces throughout your codebase. This feature streamlines your code and reduces clutter. Here's an example:

global using System;
global using System.Collections.Generic;

// No need for explicit 'using' directives
List<string> myList = new();
Console.WriteLine("Hello, C# 11!");

2) Interpolated strings with interpolated verbatim strings:
C# 11 combines the power of interpolated strings and verbatim strings with interpolated verbatim strings. This feature lets you include dynamic values in verbatim strings more conveniently. Here's an example:

string name = "John";
string message = $@"Hello, {name}!
                  Welcome to C# 11!";
Console.WriteLine(message);

3) Improved target typing with var:
Embrace more concise and readable code! C# 11 allows the use of var in control flow statements and other scenarios, where the type can be inferred by the compiler. Check out this example:

if (GetSomeValue() is var result && result > 0)
{
    Console.WriteLine($"Value is {result}");
}

4) Relaxed implicit function return types:
C# 11 reduces boilerplate by enabling you to omit the explicit return type when the return statement is the last line of the method. The compiler can infer the return type based on the context. See how it simplifies code:

int Add(int a, int b)
{
    return a + b;
}

5) Extended support for interpolated strings in attributes:
Enjoy more flexibility when working with attributes! C# 11 allows interpolated strings directly in attribute arguments, making it easier to include dynamic values. Take a look:

[Description($"This is the {nameof(MyClass)} class")]
public class MyClass { }

6) is not pattern matching:

Say hello to the is not pattern matching syntax! C# 11 introduces the negation of the ispattern, allowing you to check if an object is not of a specific type. Here's an example:

if (myObject is not null)
{
    Console.WriteLine("Object is not null");
}

Conclusion:
C# 11 brings an array of exciting features and tips that enhance the language and make your code more expressive and efficient. We've covered just a glimpse of what C# 11 has to offer. So, start exploring these new features and elevate your C# development experience!

I hope this draft provides a good starting point for your dev.to post. Feel free to modify and enhance it further to suit your style and content preferences. Happy writing!

Hello dev.to Community! Welcome to My Coding Journey

Zanyar Jalal — Tue, 11 Jul 2023 06:12:16 +0000

Introduction:
Hello fellow developers! I am thrilled to join the dev.to community and share my coding journey with all of you. In this welcome post, I want to introduce myself, talk about my passion for coding, and share what you can expect from my future posts. Let's dive in!

About Me:
My name is Zanyar Jalal, and I've been a passionate developer for 6 years. I have a strong background in software development and database design. Throughout my journey, I have worked on various projects, ranging from small web applications to complex enterprise solutions. I believe in continuous learning and exploring new technologies to stay updated in this rapidly evolving field.

My Coding Journey:
My love for coding started at university. I was captivated by the idea of turning lines of code into real-world applications. Since then, I have dedicated countless hours to improving and honing my skills. I have faced challenges, overcome obstacles, and celebrated victories. Through this platform, I hope to connect with fellow developers, share knowledge, and inspire others on their coding journey.

Topics I'll Cover: In my upcoming posts, I plan to cover a wide range of topics related to Web development, database design and programming tips.

Here are some areas that you can expect to see in my articles:

Backend development by using .NET core.
Frontend development by using Vuejs, Reactjs and Blazor.
Database design and how start new project and make database for it.
Best practice for development.

I am open to suggestions and requests, so if there's a specific topic or concept you'd like me to explore, please let me know in the comments.

Let's Connect:
I believe that learning and growing together is a key aspect of being a developer. I encourage you to connect with me on dev.to and other social media platforms. Feel free to leave comments, ask questions, or share your thoughts on my posts. I am always excited to engage in meaningful discussions and help fellow developers.

Conclusion:
Thank you for taking the time to read my welcome post. I am thrilled to be a part of the dev.to community and share my knowledge and experiences with all of you. Together, let's embark on this coding journey, learn from each other, and make a positive impact in the world of software development.

Stay tuned for my upcoming posts, and until then, happy coding!

Understanding Middleware in .NET Core

Zanyar Jalal — Tue, 11 Jul 2023 05:28:31 +0000

Introduction:
Middleware plays a crucial role in the request pipeline of a .NET Core application. It provides a flexible and modular way to handle HTTP requests and responses. In this article, we will explore the concept of middleware in .NET Core and how it can be used to enhance your application's functionality. We will also dive into some code examples to demonstrate its practical implementation.

What is Middleware?
Middleware, in the context of .NET Core, is software that sits between the server and your application, intercepting and processing incoming HTTP requests and outgoing responses. It provides a chain of components that can inspect, modify, or short-circuit the request/response flow. Each middleware component performs a specific task, such as authentication, logging, error handling, or routing.

Defining Middleware:
In a .NET Core application, middleware can be defined using the Use extension method on the IApplicationBuilder interface within the Configure method of the Startup class. This method allows you to add middleware components in the desired order.

Here's an example of adding a simple logging middleware:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ...

    app.Use(async (context, next) =>
    {
        // Perform some logging before the request is processed
        Console.WriteLine($"Request received: {context.Request.Path}");

        await next.Invoke();

        // Perform some logging after the response is generated
        Console.WriteLine($"Response sent: {context.Response.StatusCode}");
    });

    // ...
}

This middleware component logs the incoming request path and the outgoing response status code. It also calls the next middleware component in the pipeline using the next.Invoke() method.

Ordering Middleware Components:
The order of middleware components is significant, as each component can inspect or modify the request/response before passing it on to the next component. For example, authentication middleware should come before authorization middleware to ensure that requests are authenticated before being authorized.

To specify the order explicitly, use the UseMiddleware<T>() method. Here's an example of configuring middleware components in a specific order:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ...

    app.UseMiddleware<AuthenticationMiddleware>();
    app.UseMiddleware<AuthorizationMiddleware>();

    // ...
}

In this example, the AuthenticationMiddleware _runs before the _AuthorizationMiddleware, ensuring that requests are authenticated before being authorized.

Building Custom Middleware:

Apart from the built-in middleware components provided by ASP.NET Core, you can also create custom middleware to address your specific requirements. Custom middleware is created by implementing the **IMiddleware **interface or by writing a delegate-based middleware component.

Here's a simple example of custom middleware that adds a custom header to every response:

`public class CustomHeaderMiddleware
{
private readonly RequestDelegate _next;

public CustomHeaderMiddleware(RequestDelegate next)
{
    _next = next;
}

public async Task Invoke(HttpContext context)
{
    context.Response.Headers.Add("X-Custom-Header", "Hello from Custom Middleware!");

    await _next.Invoke(context);
}

To use this custom middleware, add it to the pipeline as shown below:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ...

    app.UseMiddleware<CustomHeaderMiddleware>();

    // ...
}

Conclusion:

Middleware in .NET Core provides a powerful mechanism to handle HTTP requests and responses. It allows you to modularize your application's functionality and enables you to add cross-cutting concerns like logging, authentication, and error handling. By understanding the concept of middleware and leveraging its capabilities, you can build robust and scalable web applications in .NET Core.

I hope this article helps you grasp the concept of middleware in .NET Core and how to use it effectively in your projects. Feel free to experiment with different middleware components to enhance your application's functionality further.

Happy coding!