[C#] Writing Safe Code by Eliminating Hardcoded Strings with the nameof Operator

2025年12月10日

The nameof operator, introduced in C# 6.0, is a feature that allows you to obtain the name of a type, member, or variable as a string at compile time.

Previously, names were written as string literals (e.g., "variableName") when outputting logs or throwing exceptions. However, this approach had issues, such as forgetting to update the string when the variable name changed or failing to notice typos. Using nameof solves these problems and helps create safe code that is resilient to refactoring.

Implementation Example: Getting Names of Various Targets
Benefits of Using nameof
Summary

Implementation Example: Getting Names of Various Targets

Below is a basic implementation example showing how to use nameof to get the names of classes, properties, methods, and variables as strings. It is particularly effective for checking method arguments.

using System;

namespace NameofExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Get class name
            // Gets the string "DateTime" (System.DateTime also yields the last name)
            string className = nameof(DateTime);
            Console.WriteLine($"Class: {className}");

            // 2. Get property name
            // Gets the string "Year"
            string propertyName = nameof(DateTime.Year);
            Console.WriteLine($"Property: {propertyName}");

            // 3. Get method name
            // Gets the string "AddDays"
            string methodName = nameof(DateTime.AddDays);
            Console.WriteLine($"Method: {methodName}");

            Console.WriteLine("------------------------------");

            // 4. Practical Example: Argument Validation
            // Even if you rename the variable, the IDE's refactoring tool will automatically update the nameof part.
            try
            {
                ProcessUserData(null);
            }
            catch (ArgumentNullException ex)
            {
                Console.WriteLine($"Error occurred: {ex.Message}");
                // The ParamName property contains the string "user"
                Console.WriteLine($"Target argument name: {ex.ParamName}");
            }
        }

        static void ProcessUserData(string user)
        {
            // Throw an exception if the argument is null
            // Previously written as "user", but by writing nameof(user),
            // the code won't break if the argument name changes.
            if (user == null)
            {
                throw new ArgumentNullException(nameof(user), "User information is required.");
            }

            Console.WriteLine($"Processing: {user}");
        }
    }
}

Benefits of Using `nameof`

Improved Refactoring Resilience: When using the IDE’s “Rename” feature, the content of nameof(target) is automatically updated to the new name. With string literals ("target"), manual updates were required, carrying the risk of missing some instances.
Typo Prevention: Specifying a non-existent member name in nameof causes a compilation error, allowing you to detect mistakes before execution.
Improved Readability: It clarifies the code’s intent, explicitly stating, “I want to use the name of this variable.”