String vs string in C#: What's the Difference?

By the end of this page, you will understand that string in C# is a language keyword that maps directly to System.String. You will learn why both forms represent the same .NET type, how they are used in real code, and which style is usually preferred for readability and consistency.

In C#, string and String refer to the same underlying type:

• string is a C# keyword
• String usually refers to System.String, the .NET class

That means these are effectively equivalent:

string a = "hello";
System.String b = "hello";

If you have using System; at the top of your file, then you can also write:

String c = "hello";

All three variables above have the same type: System.String.

Why this exists

C# provides built-in aliases for some common .NET types to make code easier to read and write. For example:

• int -> System.Int32
• bool -> System.Boolean
• string ->

Think of string and System.String like two labels on the same box.

• The box is the actual .NET type that stores text
• string is the short C# label
• System.String is the full official label

They do not represent different boxes. They both point to the same thing.

A similar idea exists in everyday language:

• TV and television mean the same object
• one is shorter and more convenient
• the other is the formal name

In C#, string is like saying TV, while System.String is like saying television.

Basic syntax

string message = "Hello";
System.String message2 = "Hello";

If using System; is in scope:

String message3 = "Hello";

These all create variables of the same type.

Example: proving they are the same type

using System;

class Program
{
    static void Main()
    {
        string a = "hello";
        String b = "world";

        Console.WriteLine(a.GetType());
        Console.WriteLine(b.GetType());
    }
}

Output:

System.String
System.String

Example: common style

using System;

class Program
{
    static void Main()
    {
         name = ;

         (.IsNullOrEmpty(name))
        {
            Console.WriteLine();
        }
        
        {
            Console.WriteLine(name);
        }
    }
}

Consider this example:

using System;

class Program
{
    static void Main()
    {
        string first = "Hello";
        String second = "World";

        Console.WriteLine(first.GetType() == second.GetType());
    }
}

Step by step

1. string first = "Hello";

   • A variable named first is created.
   • Its type is System.String through the string alias.

2. String second = "World";

   • A variable named second is created.
   • Because String refers to System.String, it has the same type.

3. first.GetType()

   • Returns the runtime type of first.

1. Declaring text data in applications

string username = "alice";
string email = "alice@example.com";

This is the most common use in web apps, desktop apps, and APIs.

2. Validating input

if (string.IsNullOrWhiteSpace(email))
{
    Console.WriteLine("Email is required.");
}

String validation is common in forms, request handling, and configuration loading.

3. Working with API data

string json = "{ \"name\": \"Sam\" }";

APIs often send and receive textual data such as JSON, URLs, headers, and tokens.

4. Logging and messages

string logMessage = "User logged in successfully.";

Most logs, status updates, and error messages are strings.

5. Configuration values

string connectionString = "Server=localhost;Database=AppDb;";

Environment variables and configuration files often produce string values first.

In real C# projects, developers usually follow style conventions rather than technical necessity, because string and String are the same type.

Common pattern: use aliases for built-in types

Most codebases prefer aliases like:

• string
• int
• bool
• object

This makes everyday declarations shorter and more familiar.

public string GetDisplayName(User user)
{
    return user.FirstName + " " + user.LastName;
}

Validation and guard clauses

Strings are often validated early:

public void SaveUser(string name)
{
    if (string.IsNullOrWhiteSpace(name))
    {
        throw new ArgumentException("Name is required.");
    }

    
}

Mistake 1: Thinking string and String are different types

Broken assumption:

string a = "x";
String b = "y";
// These are different types  <-- incorrect idea

Reality:

• both are System.String
• there is no type difference

Mistake 2: Forgetting that String may need a namespace

This may fail if using System; is missing:

String name = "Ali";

Safer alternatives:

using System;
String name = "Ali";

or

string name = "Ali";

or

System.String name = "Ali";

string vs String vs System.String

Quick facts

• string == System.String
• String usually means System.String
• No performance difference
• No behavior difference
• string is the C# keyword alias
• String is the .NET type name

Common syntax

string a = "hello";
String b = "hello";
System.String c = "hello";

Recommendation

• Use string for declarations in most C# code
• Be consistent across the project

Notes

• String may require using System;
• Strings in C# are immutable
• Static methods can be called like this:

string.IsNullOrEmpty(value)
String.IsNullOrEmpty(value)
System.String.IsNullOrEmpty(value)

Is string different from String in C#?

No. string is the C# alias for System.String, so they represent the same type.

Which is better to use in C#: string or String?

Most C# developers prefer string for variable and method declarations because it matches other built-in aliases like int and bool.

Is there any performance difference between string and String?

No. They compile to the same underlying .NET type.

Why does C# have both string and String?

C# includes keyword aliases for common .NET types to make code easier to read and write.

Do I need using System; to use String?

Usually yes, unless you write the full name as System.String.

Can I call methods on a variable?

Related concepts

• System.Int32 vs int — another example of C# keyword aliases for .NET types
• bool vs Boolean — shows the same alias pattern with logical values
• Namespaces in C# — helps explain why String may require using System;
• Value types vs reference types — useful because string is a reference type
• String immutability — important for understanding how string operations behave
• var in C# — often compared with explicit type declarations like string name = "A";
• Static methods in C# — relevant for calls like string.IsNullOrEmpty(...)