DEV Community: hasan kılıç

Reflection in C# : What It Is, How It Works, and Why It Matters for Unity Developers

hasan kılıç — Sun, 06 Jul 2025 20:24:56 +0000

What is Reflection?

C# program compiles into an assembly that includes metadata, compiled code and resources. Inpsecting the metadata and compiled code at runtime is called reflection

To understand reflection properly , you need to understand what metadata is first.

What is metadata?

In C# , metadata refers to information about built-in or custom types, members and other constructs defined in an assembly.
In other words, metadata is not the data itself — it’s data about data.
It tells the runtime things like : What classes and interfaces exist, Which field, properties and methods they have, what attributes decorate them and more.

How It Works?

Let’s take a look at how to obtain a Type — the backbone of the Reflection API — inspect its metadata, and use it to interact with your code at runtime.

In C#, every object and type has metadata attached to it. The System.Type class represents this information. You can get a Type object in a few ways:

Using typeof(T)
Type type1 = typeof(Player)
Using .GetType() on an instance
Type type2 = (new Player()).GetType();

Once you have a Type , you can:

Inspect its fields, properties and methods
Check its attributes
Invoke methods or create instances dynamically

How to use it?

Okay that's enough of theory let's code a simple player class and inspect it's properties , methods and attributes at runtime.

Player class

[Serializable]
public class Player
{
    public string Name { get; private set; }
    public int Level { get; private set; }

    public Player(string name, int level)
    {
        Name = name;
        Level = level;
    }

    // parameterless constructor
    public Player() { }

    public void LevelUp()
    {
        Level++;
        Debug.Log("Player leveled up");
    }
}

Reflector class

private void Start()
    {
        Player player = new Player("Dude", 1);

        // Get the Type metadata of Player
        Type playerType = player.GetType();

        // Get property value using Reflection
        var level = playerType.GetProperty("Level").GetValue(player);
        Debug.Log($"Level: {level}"); // Output: Level: 1

        // Inspect all properties
        PropertyInfo[] properties = playerType.GetProperties(
            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

        foreach (var property in properties)
        {
            Debug.Log($"Property Name: {property.Name}"); // Output: Name, Level
        }

        // Inspect and invoke methods with no parameters
        MethodInfo[] methods = playerType.GetMethods(
            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

        foreach (var methodInfo in methods)
        {
            if (methodInfo.GetParameters().Length == 0)
            {
                Debug.Log($"Invoking: {methodInfo.Name}");
                methodInfo.Invoke(player, null); 
                // Will call LevelUp and show "Player leveled up"
            }
        }

        // Inspect class-level attributes
        IEnumerable<Attribute> attributes = playerType.GetCustomAttributes();
        foreach (var attribute in attributes)
        {
            Debug.Log($"Player class has an attribute named: {attribute.GetType().Name}"); 
            // Output: Player class has an attribute named: SerializableAttribute
        }
    }

✨ And that’s it — now you’ve seen how Reflection works in C# and how you can use it in Unity to peek inside your own code!

It’s a handy tool for building smarter workflows, editor tools, or just satisfying your curiosity at runtime, but be careful about performance costs of it.

Stay tuned — in upcoming articles, we’ll build a simple yet extendable Developer Console using Reflection and Attributes.

✨ Thanks for reading!
buy me a coffee

How to Use Operator Overloading in C# to Write Cleaner Unity Code

hasan kılıç — Thu, 03 Jul 2025 16:14:27 +0000

What is operator overloading?

Opetor overloading is use to make math operations like +, -, ==, != ... on your own custom types.

Why use operator overloading?

It’s perfect for custom numeric types, like health, damage, stats, currencies, or game grid positions. Your math operations become short, readable, and less error-prone..
Without operator overloading, you’d often write repetitive Add(), Subtract(), CombineWith() methods. Overloading removes that boilerplate and keeps your API small.

How to use operator overloading?

To overload an operator in C#, you define a public static method inside your class or struct. The method must return a value and use the special operator keyword.
You tell C# which operator you’re overloading by writing it after the operator keyword — like operator + for addition, operator - for subtraction, or operator == for equality.
The operator method must take the same number of operands the operator normally uses. For example, + and - are binary operators, so they take two parameters.

Example use case

Let's see it in action. I’ll write a simple GridPosition struct for demonstration — I think this is one of the most common ways you’d use operator overloading in Unity, especially for tilemaps, grid-based movement, or strategy games.

But you can use the exact same approach for your stat system, prize system, or any other numeric game logic where clean, natural math syntax makes your code easier to read.

CustomGrid struct

The CustomGrid struct is simple — it holds the X and Y coordinates of a grid position. You can use this to represent tile positions, map nodes, or any grid-based system in your game..

    public struct CustomGrid
    {
        public int X { get; }
        public int Y { get; }    

        public CustomGrid(int x, int y)
        {
            X = x;
            Y = y;
        }
    }

Adding operator overloading

Let's see how we can overload "+" operator.

        // + operator requires two parameters
        public static CustomGrid operator + (CustomGrid grid1, CustomGrid grid2)
        {
            return new CustomGrid(grid1.X + grid2.X, grid1.Y + grid2.Y);
        }

The method must be public static
It must return a CustomGrid
It takes two CustomGrid parameters — one for each side of the + operation.

Adding other operations

 public static CustomGrid operator -(CustomGrid grid1, CustomGrid grid2)
 {
     return new CustomGrid(grid1.X - grid2.X, grid1.Y - grid2.Y);
 }

 public static CustomGrid operator *(CustomGrid grid1, CustomGrid grid2)
 {
     return new CustomGrid(grid1.X * grid2.X, grid1.Y * grid2.Y);
 }

 // == operator must return a bool 
 public static bool operator ==(CustomGrid grid1, CustomGrid grid2)
 {
     return grid1.X == grid2.X && grid1.Y == grid2.Y;
 }

 // != operator must return a bool
 public static bool operator !=(CustomGrid grid1, CustomGrid grid2)
 {
     return grid1.X != grid2.X || grid1.Y != grid2.Y;
 }

⚠️ When you overload == and != in C#, you should also override the Equals and GetHashCode methods to ensure your type works correctly in collections and comparisons.

Testing

void Start()
{
  CustomGrid grid1 = new CustomGrid(4, 1);
  CustomGrid grid2 = new CustomGrid(2, 6);

  var addition = grid1 + grid2; // add
  var subtraction = grid1 - grid2; // subtract
  var multiplication = grid1 * grid2; // multiply element-wise

  // override ToString() methods to get expected output
  Debug.Log($"Addition: {addition} , subtraction: {subtraction} , multiplication: {multiplication}"); 
}

output: Addition: (6.00, 7.00) , subtraction: (2.00, -5.00) , multiplication: (8.00, 6.00)

Conclusion

Operator overloading is a powerful feature in C# that lets you make your custom types behave like built-in ones — using natural and readable syntax.

In Unity development, this means cleaner and more intuitive code for things like grid positions, stats, currencies, and other numeric systems. Instead of writing verbose helper methods, you get to write expressive math operations that improve readability and reduce errors.

Give it a try in your next Unity project, and enjoy the benefits of clearer, cleaner, and more maintainable code!

Thanks for reading
buy me a coffee

Unity C# Tip: Sort Your Data Like a Pro with IComparable & IComparer

hasan kılıç — Thu, 26 Jun 2025 17:13:47 +0000

__Have you ever needed to sort your inventory items by rarity, or rank your enemies based on distance to the player? Writing custom sorting logic in Unity can quickly become messy if you don’t know about two powerful C# interfaces: IComparable and IComparer. In this post, we'll look at how you can use these interfaces to cleanly organize and sort your data in Unity — with real-world examples like an inventory system.Since the today's discussion is all about Sorting things , our inventory system will be pretty small , but you can scale it however you want (i also suggest to using Scriptable Objects).

What is IComparable interface?

The IComparable interface in C# is used to define a natural (default) sorting order for objects of a class.

You implement this interface when your objects should be able to compare themselves to other objects of the same type.

This allows you to use methods like List.Sort() directly without needing an external comparer.

Use this interface to implement a default comparison.

What is IComparer interface?

The IComparer interface is used to define custom or external sorting logic for objects.

You use this interface when you want to define multiple ways to compare objects, or when you can't modify the original class.

You pass the comparer as an argument to sorting methods like List.Sort(IComparer).

Item class

Item class is pretty simple , it holds the item data , implements IComparable interface for default comparison

public class Item : IComparable<Item>    
{
    public int Id { get; }
    public int Power { get; }
    public Rarity Rarity { get; }

    public Item(int id, int power, Rarity rarity)
    {
        Id = id;
        Power = power;
        Rarity = rarity;
    }

    // Comes from IComparable interface , it helps to define 'default' sorting logic.
    public int CompareTo(Item other)
    {
        // let's compare ids as default
        return this.Id.CompareTo(other.Id);
    }
}

public enum Rarity
{
    Common,
    Rare,
    Legendary
}

Comparer classes

Comparer classes implement IComparer interface, which allows us to define custom comparing logic.Since we implemented default comparison logic by using IComparable interface in Item class, let's create our own Comparer classes.I will start with Power comparer:

    /// <summary>
    /// Use this class to sort items based on their power
    /// </summary>
    public class ItemPowerComparer : IComparer<Item>
    {
        // Compares by power
        public int Compare(Item x, Item y)
        {
            return x.Power.CompareTo(y.Power);
        }
    }

And now — let’s sort our items based on Rarity.

💡 Remember: enums in C# are backed by integers by default. So comparing enum values is just like comparing integers — and the C# compiler is smart enough to handle that elegantly under the hood.


    /// <summary>
    /// Use this class to sort items based on their rarity
    /// </summary>
    public class ItemRarityComparer : IComparer<Item>    
    {
        // Compares by Rarity
        public int Compare(Item x, Item y)
        {
            return x.Rarity.CompareTo(y.Rarity);
        }
    }

Inventory class

I think we all get it.Let's use it in action.It's time for our big guy Inventory class.I will make it simple for the sake of this tutorial but you can extend it however you want.

public class Inventory : MonoBehaviour
{
    // Item list
    private readonly List<Item> items = new List<Item>()
    {
        new Item(id: 0 , power:10 , rarity:Rarity.Rare),
        new Item(id: 1 , power:6 , rarity:Rarity.Common),
        new Item(id: 2 , power:7 , rarity:Rarity.Legendary)
    };

    private void Update()
    {
        // default sorting
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Sort();
            // output : 0,1,2 -> when sorted by id
        }

        //Power sorting
        if (Input.GetKeyDown(KeyCode.P))
        {
            Sort(new ItemPowerComparer());
            // output : 1,2,0 -> when sorted by power
        }

        //Rarity sorting
        if (Input.GetKeyDown(KeyCode.R))
        {
            Sort(new ItemRarityComparer());
            // output : 1,0,2 -> when sorted by Rarity
        }
    }

    public void Sort(IComparer<Item> comparer = null)
    {
        items.Sort(comparer); // sorts by ascending 
        foreach (Item item in items)
        {
            Debug.Log($"\n {item.Id}");
        }
    }

}

Conclusion

Sorting is one of those things that sounds simple — until your game needs to rank, order, or organize complex data. Thankfully, with IComparable and IComparer, you can keep your logic clean, modular, and easy to extend.

Whether you're building a full inventory system, a quest tracker, or a leaderboard, these interfaces will save you from messy code and hard-to-maintain conditionals_

Thanks for reading
buy me a coffee