How to Use the CASE Statement in SQL for Conditional Logic

In C#, you can format an integer with commas (thousands separator) using ToString with a format specifier.

int number = 1234567;
string formattedNumber = number.ToString("N0"); // "1,234,567"
Console.WriteLine(formattedNumber);

Explanation:

"N0": The "N" format specifier stands for Number, and "0" means no decimal places. The output depends on the culture settings, so in regions where , is the decimal separator, you might get 1.234.567.

Alternative:

You can also specify culture explicitly if you need a specific format:

using System.Globalization;

int number = 1234567;
string formattedNumber = number.ToString("N0", CultureInfo.InvariantCulture);
Console.WriteLine(formattedNumber); // "1,234,567"

When working with financial data in C#, proper currency formatting is essential for clear and professional presentation. The .NET framework provides several convenient methods to format numeric values as currency, with the most common being the ToString() method with the "C" format specifier.

For example, decimal amount = 1234.56m; string formatted = amount.ToString("C"); will display "$1,234.56" in US culture.

For more control over the formatting, you can specify a culture explicitly using CultureInfo - amount.ToString("C", new CultureInfo("fr-FR")) would display "1 234,56 €".

This allows your application to handle different currency symbols, decimal separators, and grouping conventions appropriately.

If you need to handle multiple currencies or require more specialized formatting, you can also use the String.Format() method or string interpolation with custom format strings.

For instance, String.Format("{0:C}", amount) or $"{amount:C}" achieves the same result as ToString("C"). Additionally, you can control the number of decimal places using format strings like "C2" for two decimal places.

Remember that when dealing with financial calculations, it's best practice to use the decimal type rather than float or double to avoid rounding errors that could impact currency calculations.

Example

decimal price = 1234.56m;
// Basic currency formatting
Console.WriteLine(price.ToString("C")); // Output: $1,234.56

// Currency formatting with specific culture
Console.WriteLine(price.ToString("C", new CultureInfo("de-DE"))); // Output: 1.234,56 €

// Currency formatting with string interpolation
Console.WriteLine($"{price:C}"); // Output: $1,234.56

// Controlling decimal places
Console.WriteLine(price.ToString("C3")); // Output: $1,234.560

In C#, readonly, const, and static are keywords used to define variables with different behaviors in terms of mutability, memory allocation, and scope.

Understanding their differences is crucial for writing efficient and maintainable code. In this article we'll take a look at each and see how they are used.

1. const (Constant Values)

A const variable is a compile-time constant, meaning its value must be assigned at declaration and cannot be changed later.

Key Characteristics:

• Must be assigned at declaration.
• Stored in the assembly metadata (not allocated memory at runtime).
• Can only be assigned primitive types, string, or enum values.
• Cannot be modified after compilation.

Example:

public class MathConstants
{
    public const double Pi = 3.14159;
}

// Usage:
Console.WriteLine(MathConstants.Pi); // Output: 3.14159

⚠ Limitations:

• Since const values are replaced at compile-time, updating a const in a library requires recompiling all dependent projects.
• Cannot use non-primitive types (e.g., objects, lists).

2. readonly (Runtime Immutable Fields)

A readonly field allows initialization either at declaration or in the constructor but cannot be modified afterward.

Key Characteristics:

• Can be assigned at declaration or inside a constructor.
• Its value can change during runtime (but only in the constructor).
• Works with all data types, including objects.
• More flexible than const since values are resolved at runtime.

Example:

public class Circle
{
    public readonly double Radius;
    public readonly double Pi = 3.14159;

    public Circle(double radius)
    {
        Radius = radius; // Allowed because it's inside the constructor.
    }
}

// Usage:
Circle c = new Circle(5);
Console.WriteLine(c.Radius); // Output: 5

✔ Best for: Values that should remain constant per instance but need to be assigned dynamically at runtime.

3. static (Shared Across All Instances)

A static variable belongs to the type itself rather than to any instance of the class.

Key Characteristics:

• Shared across all instances of a class.
• Cannot be used with instance constructors.
• Initialized once and persists for the application’s lifetime.
• Can be combined with readonly or const.

Example:

public class GlobalConfig
{
    public static string ApplicationName = "MyApp";
    public static readonly DateTime StartTime = DateTime.Now;
}

// Usage:
Console.WriteLine(GlobalConfig.ApplicationName); // Output: MyApp

✔ Best for: Global state, caching, configuration values, and utility methods.

Key Differences Summary

Choosing the Right One:

• Use const for fixed, compile-time values that will never change.
• Use readonly for immutable values that need runtime initialization.
• Use static for class-level data shared across all instances.

Understanding these differences helps you write cleaner, more efficient C# code. Happy coding! 🚀