Lesser-Known C# Features and Language Tricks for Everyday Development

By the end of this page, you will understand how to recognize and use several lesser-known but practical C# features. Instead of treating them as random tricks, you will learn the categories they belong to—such as keywords, generic constraints, null-handling, iterators, attributes, and syntactic shortcuts—so you can apply them confidently in real projects.

C# contains many features that developers do not use every day, even though they solve common problems cleanly.

These are not "secret" features in the sense of being undocumented. They are usually part of the language or .NET framework, but they can be easy to miss because:

• they appear in more advanced codebases
• they solve specific problems
• they are introduced gradually as you need them
• some are syntax sugar, so beginners use them without realizing what they mean

A useful way to study hidden C# features is by grouping them into categories.

1. Generic constraints

These restrict what types a generic parameter can be.

public class Repository<T> where T : class
{
}

They matter because they let you write safer generic code. For example, where T : struct guarantees T is a value type.

2. Type inference and concise syntax

Features like var, anonymous types, object initializers, and auto-properties reduce noise.

var person = new { Name = "Ava", Age = 30 };

These matter because they make code shorter while keeping it strongly typed.

Think of C# as a large toolbox.

Most developers use the hammer, screwdriver, and wrench every day: variables, if, loops, methods, and classes.

But the toolbox also contains specialized tools:

• yield is like a vending machine that gives one item at a time instead of dumping everything out at once.
• using is like borrowing a library book and automatically returning it when you leave.
• where T : struct is like a rule on a form that says only a certain kind of input is allowed.
• ?? is like saying, "If this box is empty, use the backup item."
• attributes are like sticky notes attached to code that tell the compiler, debugger, or framework something important.

The point is not to memorize every unusual feature. The point is to recognize the problem each feature solves.

When you see a problem like:

• "I need to ensure cleanup"
• "I want a default fallback"
• "I want to constrain a generic type"
• "I want to return values lazily"
• "I want metadata on a class or method"

then one of these lesser-known C# features often becomes the right tool.

Generic constraint: where T : struct

This constraint means T must be a value type.

public static bool IsDefaultValue<T>(T value) where T : struct
{
    return value.Equals(default(T));
}

Example

Console.WriteLine(IsDefaultValue(0));    // True
Console.WriteLine(IsDefaultValue(5));    // False

This is useful when your generic method should only accept value types like int, bool, DateTime, or custom structs.

Null-coalescing operator: ??

Use a fallback when a value is null.

string name = null;
 displayName = name ?? ;
Console.WriteLine(displayName);

Consider this small example using yield return:

public static IEnumerable<int> CountToThree()
{
    Console.WriteLine("Start");
    yield return 1;

    Console.WriteLine("Middle");
    yield return 2;

    Console.WriteLine("End");
    yield return 3;
}

foreach (int number in CountToThree())
{
    Console.WriteLine($"Received: {number}");
}

What happens step by step

1. The foreach loop begins.
2. CountToThree() does not immediately run from top to bottom like a normal method.
3. Execution starts and prints:

Start

1. The method reaches yield return 1; and pauses, giving 1 back to the loop.

Resource cleanup

using is common when working with:

• files
• streams
• HTTP responses
• database connections
• graphics objects

Example:

using (var connection = new SqlConnection(connectionString))
{
    connection.Open();
    // Work with the database
}

Safer generic utilities

Generic constraints are useful in helper libraries and reusable components.

public static T CreateInstance<T>() where T : new()
{
    return new T();
}

This is common in factories, serializers, mappers, and infrastructure code.

Returning data lazily

yield return is helpful in:

• parsing files line by line
• generating test data
• walking a tree structure
• exposing filtered results

Handling optional values

Nullable types and ?? are useful in:

In real projects, developers usually do not use these features as isolated tricks. They appear as part of common coding patterns.

Validation and guard clauses

Type checks and null fallbacks often appear early in methods.

public void SendEmail(string address)
{
    if (string.IsNullOrEmpty(address))
    {
        throw new ArgumentException("Address is required.");
    }

    // Continue safely
}

Configuration defaults

The null-coalescing operator is common when reading config values.

string environment = configValue ?? "Development";

Factory and infrastructure code

Generic constraints are frequently used in reusable library code.

public class CacheItem<T> where T : class
{
    public T Value { get; set; }
}

Deferred pipelines

Mistake 1: Thinking var makes C# dynamically typed

Broken assumption:

var number = 10;
number = "hello"; // Error

var still has a fixed compile-time type. Here, number is an int.

Mistake 2: Using as with value types incorrectly

Broken code:

object value = 5;
int number = value as int; // Error

as works with reference types and nullable value types.

Correct approach:

object value = 5;
if (value is int number)
{
    Console.WriteLine(number);
}

Quick reference

Generic constraints

where T : struct   // value type only
where T : class    // reference type only
where T : new()    // must have parameterless constructor

Null handling

string name = input ?? "Guest";
int? count = null;
bool hasValue = count.HasValue;
int value = count.GetValueOrDefault();

Resource cleanup

using (var file = new StreamReader("data.txt"))
{
    // use file
}

Lazy sequences

public IEnumerable<int> GetValues()
{
    yield return 1;
      ;
}

What are hidden features in C#?

They are valid language or framework features that many developers do not use often, such as yield, generic constraints, attributes, nullable types, and using.

Is var a hidden C# feature?

Not really hidden, but often misunderstood. It still creates a strongly typed variable based on the assigned value.

What does where T : struct mean in C#?

It means the generic type parameter T must be a value type, such as int, bool, DateTime, or a custom struct.

When should I use yield return?

Use it when you want to return items one at a time instead of building a full collection first.

What is the difference between as and a cast in C#?

A cast throws an exception if the conversion fails. as returns null instead, for compatible reference-type conversions.

Why is using important in C#?

• Generics — Hidden features often appear in generic constraints such as where T : struct and where T : new().
• Nullable types — Important for understanding optional values and null-handling.
• LINQ — Many concise C# features are commonly used together with LINQ queries.
• Extension methods — A powerful C# feature that can make APIs feel built-in.
• Attributes — Essential for metadata-driven code and framework integration.
• IDisposable — Needed to fully understand using and resource cleanup.
• Iterators — The broader concept behind yield return.
• Type inference — Explains how var works.
• Object initializers — Common shorthand used in modern C#.
• Pattern matching — Related to modern uses of is for cleaner type checks.