DEV Community: Emre Kocadere

C# Implicit Operator Explained with Examples

Emre Kocadere — Tue, 16 Sep 2025 08:23:43 +0000

Normally, when converting between types, you might need to use explicit casting. However, if the conversion is guaranteed to be safe (no data loss or runtime exceptions), you can define an implicit conversion. Once defined, the compiler automatically applies it wherever appropriate.

A Practical Example

Let’s create a simple Metre class that internally stores a distance value as a double. We want conversion from Metre to double.

class Metre
{
    public double Value { get; }

    public Metre(double value)
    {
        Value = value;
    }
}

Two Ways to Define an Implicit Operator

In C#, you can define an implicit operator in two syntactic styles: the modern expression-bodied form and the traditional block-bodied form. Both work the same way; it’s just a matter of readability and coding style.


class Metre
{
    public double Value { get; }

    public Metre(double value)
    {
        Value = value;
    }

    // Expression-bodied (short, single-line)
    public static implicit operator double(Metre metre) => metre.Value;           

    // Block-bodied (classic, multi-line)
    public static implicit operator double(Metre metre)
    { 
       return metre.Value;
    }
}

double → The target type.

Metre metre → the source type.

metre.Value → the actual conversion logic: it pulls out the double value stored in the Metre object.

When Does a User-Defined Implicit Operator Run?

During Assignment

When you assign an object to a variable of the target type

Metre m = new Metre(5.0);
double d = m; //implicit operator automatically converts m to double

2.In Return Statements
When returning the object from a method with the target type

Metre m = new Metre(4.0);

double GetValue() 
{
    return m; //implicit operator automatically converts m to double
}

3.As a Method Argument
When passing the object as a parameter to a method expecting the target type

void PrintValue(double value)
{
    Console.WriteLine(value);
}

Metre m = new Metre(7.0);

PrintValue(m); //implicit operator automatically converts m to double

4.In Expressions
When used in mathematical or other operations:

Metre m = new Metre(3.0);

double result = m + 2.0; //implicit operator automatically converts m to double

What is Quartz.Net and its simple implementation

Emre Kocadere — Tue, 14 Jan 2025 13:55:46 +0000

quartz.net is a c# library that allows specific actions to be run at certain times and periods.

Job:it is action that to be run
Trigger: it controls when a job runs
Scheduler:responsible for coordinating jobs and triggers

Example

For example, you have a service about currency rates. Your service needs to go to another service every 5 minutes and get the rates. You will agree that you cannot call the function every 5 minutes.

At this point, Quartz.NET comes into play.

First of all, after get the library from NuGet, you need a class that implements the IJob interface to create a background job.

The IJob interface includes a method called Execute. You will write the job you want to run within this method.

public class CurrencyRatesFetcherJob: IJob
{

    public async Task Execute(IJobExecutionContext context)
    {

      // background job..
    }
}

builder.Services.AddQuartz(configure =>
{

    var jobKey = new JobKey("GetCurrencyRates");
    configure
        .AddJob<CurrencyRatesFetcherJob>(jobKey)
        .AddTrigger(
            trigger => trigger.ForJob(jobKey).WithSimpleSchedule(
                schedule => schedule.WithIntervalInMinutes(5).RepeatForever()));

});

This configuration ensures that the code we wrote in Execute runs every 5 minutes.

By default, Quartz configures all jobs using the RAMJobStore. The locations where Quartz.NET jobs are stored are managed by the Quartz job store.These job stores are used to store the status, schedules, and other information of jobs and triggers.

In my next article, I will write about using cron for more complex schedules and how to store jobs and triggers somewhere other than RAM.

Exploring the Program.cs File: Key Components and Configuration in ASP.NET Web API

Emre Kocadere — Mon, 19 Aug 2024 22:31:42 +0000

The Program.cs is the main class for .NET applications. It starts the application and allows us to configure the application.
It allows us to add things like dependencies, configuration files, and middlewares.

This is a default Program.cs file for ASP.NET.

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();
app.MapControllers();

app.Run();

Key Components.

1-WebApplication:creates the WebApplicationBuilder instance necessary for your application and performs the basic configurations.

2-WebApplicationBuilder:It is used to start ASP.NET Core applications and to configure the application's settings and services.
You can add dependencies and services using the Services property of the WebApplicationBuilder class.It is used to add services to the dependency injection container. These services provide the objects needed throughout the application.
For Example

builder.Services.AddDbContext<UserManagementContext>(options => options.UseNpgsql(connectionString));

builder.Services.AddScoped<GuidanceService>();

In these lines,
builder.Services.AddDbContext(options => options.UseNpgsql(connectionString)); registers the UserManagementContext with the dependency injection container using Npgsql for PostgreSQL.
builder.Services.AddScoped(); This line registers the GuidanceService as scoped in the dependency injection container, meaning a new instance is created for each request.

builder.Services represents an instance of IServiceCollection,
IServiceCollection is used to register dependencies (services) in your application.
Its official description is as follows:
"A collection of services for the application to compose. This is useful for adding user-provided or framework-provided services."

Also, you can add and read configuration files using the WebApplicationBuilder.

builder.Configuration.AddJsonFile("ConnectionString.json");

var connectionString = builder.Configuration["ConnectionString"];

This code snippet adds the ConnectionString.json file to the configuration and then retrieves the value associated with the "ConnectionString" key from the configuration.

3-var app = builder.Build();:This line creates a WebApplication instance using all the services configured above. This is a fundamental step for building and starting the application.

Additionally, you can add middleware using the app object, which is an instance of the WebApplication. For example, middleware like app.UseHttpsRedirection();, app.UseAuthorization();, and app.MapControllers(); has been added here.

The application's startup process begins at the builder.Build() line. The application's execution starts at the app.Run() line.

What is Asp.Net middleware in its simplest definition?

Emre Kocadere — Wed, 14 Aug 2024 12:54:15 +0000

They are structures that make it possible to take customized actions on the Request/Response Pipeline
The request coming to your service does not immediately fall into the action method you wrote. It first passes through the middleware. Here you can change the requests coming to your service, check identity or keep a log record. There are already middleware in asp.net.

If you have analyzed the program.cs class of the asp.net project before, you will have seen that there are already midllewares there.

this is regular program.cs for asp.net web api projects

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

As the 2nd comment line says, you can configure Http request or response pipeline.

So the things in the pipeline image above;

app.UseHttpsRedirection(): This code is used to redirect HTTP requests to HTTPS.

app.UseAuthorization(): This code is used to set up authentication and authorization.

app.MapControllers(): This defines how your API responds to clients and how your controller classes are routed.

So how to add custom middleware to this pipeline?

How to Add Custom Middleware?

Middleware is actually a class and its structure is as follows.

public class CustomMiddleware
{
        private readonly RequestDelegate _requestDelegate;
        public CustomMiddleware(RequestDelegate requestDelegate)
        {
            _requestDelegate = requestDelegate;
        }
        public async Task Invoke(HttpContext context)
        {

        await _requestDelegate.Invoke(context);

        }
}

The RequestDelegate: is required to run the next middleware. _requestDelegate.Invoke(context) function sends the http content to the next middleware

Invoke: This is the Method that will be Executed when Middleware is called. It allows us to handle in the Request coming to the application and the Response created.
You can change the response or request in it

HttpContext: It stores the request and response information, such as the properties of request.

For example, let's write a text to the console for every request coming to the service.

       public async Task Invoke(HttpContext context)
        {
        Console.WriteLine("here is CustomMiddleware");

        await _requestDelegate.Invoke(context);

        }

Finally, we need to add this to the pipeline. For this, we add the middleware to program.cs.

app.UseMiddleware<CustomMiddleware>();

When I send any request, a log will be written to the console.

It doesn't matter which endpoint it goes to. Since every request will pass through middleware, it will be printed to the console with every request.

Or You can change the content of every response and request coming to your application whenever you want in Invoke method.

Let’s write a simple middleware that catches exceptions.

for that we need a Controller Class first.

public class ValuesController : ControllerBase
    {

        [HttpGet]
        public int Get()
        {
            int a = 0;
            int b = 15;
            int c = b / a;
            return c;
        }
    }

I created an error inside the controller class.

If this method works, the response will be as follows:

Now let's write a very simple middleware to prevent our application from crashing and to catch any missed exceptions.

public class CustomMiddleware
{
    private readonly RequestDelegate _requestDelegate;
        public CustomMiddleware(RequestDelegate requestDelegate)
        {
            _requestDelegate = requestDelegate;
        }
        public async Task Invoke(HttpContext context)//
        {
            try
            {
                await _requestDelegate.Invoke(context);
            }
            catch(Exception e) {
                context.Response.StatusCode = 500;
                await context.Response.WriteAsJsonAsync(e.Message);

            }

        }
}

add it to the pipeline

app.UseMiddleware<CustomMiddleware>();

After the middleware we wrote, the response will be as follows

Now the application continues without crashing.

why use middleware?

1.Requests can be passed through the desired controls

2.Solutions for Exception Handling can be provided

3.Authorization

4.Authentication

5.You can create logging mechanisms on the application.