DEV Community: boomi1

NET API Controller Without ApiController and ControllerBase?

boomi1 — Sun, 10 Aug 2025 12:56:25 +0000

Is it possible to write a .NET API controller without using the ApiController attribute and without inheriting from ControllerBase or Controller?

The short answer is YES.

But, how will .NET identify this as a controller?

If a public class’s name ends with the word Controller, it will be considered a controller class, and the methods defined inside that class will be considered action methods. Generally, controllers inherit from ControllerBase or Controller as per convention.

The major drawback of not explicitly using the ApiController attribute is that functionalities provided by this attribute—such as model binding, model validation, error response handling, etc.—need to be handled manually.

Conclusion:
The best practice is to always follow the convention by using the ApiController attribute and inheriting from ControllerBase or Controller.

What is the difference between string.Empty and ""

boomi1 — Sun, 06 Jul 2025 17:21:00 +0000

Functionally both represent the string is empty but there are some minor differences between both

string.Empty
It is read-only field, which can't be used as a compile time constant or in switch statements

public class HelloWorld
{
public void Display(string name=string.Empty)
{
Console.WriteLine("Display method");
}

public static void Main(string[] args)
{
    HelloWorld h = new HelloWorld();
    h.Display();

}

}
The above code will give a compile-time error:

error CS1736: Default parameter value for 'name' must be a compile-time constant

Similarly, string.Empty can't be used in a switch case.

Whereas "" (an empty string literal)
It is considered a compile-time constant.

Compile-time Constant

The constant value will be fixed during the compilation rather than at runtime

using System;

public class HelloWorld
{
public void Display()
{
string val = "";
Console.WriteLine("Empty string:"+val);
}

public static void Main(string[] args)
{
    HelloWorld h = new HelloWorld();
    h.Display();

}

}

Here, the value will fixed at the time of compilation

Output
Empty string:

Nested If vs. Ternary Operator in C#: When to Use What

boomi1 — Sun, 22 Jun 2025 12:06:17 +0000

Choosing between nested if and ternary is bit tricky. Let's see some real-time example to help choose the right one

using System;

public class HelloWorld
{
public static void Main(string[] args)
{
int age= 18;
bool hasTicket = true;
if(age >=18)
{
if(hasTicket)
{
Console.WriteLine("Allowed to enter");
}
else
{
Console.WriteLine("Please get the ticket");
}
}
else
{
Console.WriteLine("Age must be greater than or equal to 18");
}
}
}
Nested if is used in the above example.This can be achieved using ternary operator as well

Using Ternary Operator

using System;

public class HelloWorld
{
public static void Main(string[] args)
{
int age= 18;
bool hasTicket = true;
var result = age < 18 ? "Age must be greater than or equal to 18" :
(hasTicket ? "Allowed to enter" : "Please get the tickets");
Console.WriteLine(result);
}
}

Output for both nested and ternary
Allowed to enter

Use nested if

When the logic is complex Use ternary operator
For simple logic
While assigning or returning a value

How Missing Initialization of out Parameters Leads to Errors in C#

boomi1 — Sat, 07 Jun 2025 15:21:36 +0000

Missing out variable initialization inside a function leads to exception

using System;

public class HelloWorld
{
public void Demo(out int a)
{
Console.WriteLine("Demo function");
}
public static void Main(string[] args)
{
HelloWorld h = new HelloWorld();
h.Demo(out int number);
Console.WriteLine ("Try programiz.pro");
}
}
The above code will create an exception saying "error CS0177: The out parameter 'a' must be assigned to before control leaves the current method"
using System;

public class HelloWorld
{
public void Demo(out int a)
{
int data = 10;
if(data==9)
{
a = 6;
Console.WriteLine("Inside if block");
}
Console.WriteLine("Demo function");
}
public static void Main(string[] args)
{
HelloWorld h = new HelloWorld();
h.Demo(out int number);
Console.WriteLine ("Try programiz.pro");
}
}

In the above code also the same exception will arise.Even though the initialization is made inside the if block,since the condition fails,it will not go inside the if block and initialization also will not happen.To avoid this, we can follow something I have mentioned in the below code

using System;

public class HelloWorld
{
public void Demo(out int a)
{
int data = 10;
a = 100;
if(data==10)
{
a = 6;
Console.WriteLine("Inside if block");
}
Console.WriteLine("Demo function");
}
public static void Main(string[] args)
{
HelloWorld h = new HelloWorld();
h.Demo(out int number);
Console.WriteLine ("Try programiz.pro");
}
}
In spite of the if block failing, since the initialization happens before the if block the above code will not throw any exception

Output
Inside if block
Demo function

Conclusion
It's mandatory to initialize the out variable inside the function.
Please do share your feedback!!! ☺️

What is the difference between ref,out and in keywords in c#

boomi1 — Sun, 25 May 2025 15:45:23 +0000

In C#, the ref, out, and in keywords are used to pass arguments by reference to methods. This means that instead of passing a copy of the variable, a reference to the original variable is passed. However, these keywords serve different purposes and have distinct behaviors. Let's explore each one in detail.

Ref keyword

Ref keyword is used to pass the value as a reference type inside a function and if it's changed inside a function, the value outside the function will also change since both points to the same address.

using System;

public class Program
{
public void Demofunc(ref int a)
{
a = 10;
Console.WriteLine("Inside function "+a);
}
public static void Main(string[] args)
{
int a = 5;
Program p = new Program();
Console.WriteLine("Before calling the function "+a);
p.Demofunc(ref a);
Console.WriteLine("After calling the function "+a);
}
}

Output:
Before calling the function 5
Inside function 10
After calling the function 10

Out keyword

Out keyword is also very similar to ref keyword the only difference between both is,while passing it as an out keyword
initializing the value is not mandatory but in case of ref keyword it's mandatory.Out keyword is also used to return multiple values from function.

using System;

public class Program
{
public void Demofunc(out int a)
{
a = 10;
Console.WriteLine("Inside function "+a);
}
public static void Main(string[] args)
{

   Program p = new Program();
   p.Demofunc(out int a);
   Console.WriteLine("After calling the function "+a);
}

}

Output:
Inside function 10
After calling the function 10

In keyword

In keyword is used to pass the value as a reference type but it's not possible to change the value inside the function,modifying the value within the function will cause a error with a message "Cannot assign to variable 'in int' because it is a readonly variable".

using System;

public class Program
{
public void Demofunc(in int a)
{
Console.WriteLine("Inside function "+a);
}
public static void Main(string[] args)
{
int a= 10;
Program p = new Program();
Console.WriteLine(" Before calling the function "+a);
p.Demofunc(in a);
Console.WriteLine("After calling the function "+a);
}
}

Output:
Before calling the function 10
Inside function 10
After calling the function 10

Is It Possible to Have Switch Case Without a Default?

boomi1 — Sun, 18 May 2025 13:15:22 +0000

I came across this question while working with switch-case statements and I realised that the answer is both YES AND NO.

The necessity of a default case depends on where and how you're using the switch. If it's used inside a function that returns a value, then having a default case becomes necessary in certain situations. Otherwise, it's not mandatory.

Let’s break this down with two scenarios:

Scenario 1:

using System;
public class Program
{
public int Number(int num)
{
switch(num)
{
case 1: return 1;
case 2: return 2;
default: return -1;
}
}
public static void Main(string[] args)
{
Program p = new Program();
int result = p.Number(9);
Console.WriteLine(result);
}
}
In the above code, we’re returning a value from the function using a switch statement. If none of the case values match, it falls back to the default case and returns -1.

Now, if we remove the default case, the compiler will throw an error:

"Not all code paths return a value"

This is because there's a possibility that no case matches, and the function would have no return path in that situation. Hence, in such scenarios, a default case is necessary to ensure all paths return a value

Scenario 2:

public class Program
{
public void Number(int num)
{
switch(num)
{
case 1 :
Console.WriteLine("One");
case 2 :
Console.WriteLine("Two");

}
}

public static void Main(string[] args)
{

   Program p = new Program();
   int result = p.Number(9);
   Console.WriteLine(result);
}

}
In this case, the function has a void return type, meaning it doesn’t return any value. If none of the cases match, the control simply exits the switch block and continues execution. Here, not having a default case is completely valid—though it might not be ideal for readability or handling unexpected input.

Conclusion:

Whether or not to include a default case depends on the scenario, especially when it involves return values.

However, as a best practice, it’s always recommended to include a default case. It improves code readability, helps with debugging, and ensures you handle all unexpected input gracefully.