In C#, strings can be used like objects with methods, properties, and other features of objects. At the same time, strings are treated the same as primitive data types like int or float in numerous ways as well (lowercase name, behaves like a keyword, etc.).

In Java, strings are just objects (String), and it is very clear that they are just objects; they have a Pascal-case name and everything.

How does the C# string type act like an object and a primitive type simultaneously?

  • "strings are treated the same as primitive data types like int or float in numerous ways as well (lowercase name, behaves like a keyword, etc.)" Can you elaborate on the other ways besides being usable as both String and string? That is just a compiler type alias. That being said, C# does have value types, which act more like primitives than reference types.
    – clcto
    Commented Feb 20 at 16:46
  • Strings are reference types, objects by any definition, and not "primitive" types. They only thing they have in common with int, float etc is that they all inherit from Object.
    – Ccm
    Commented Feb 20 at 16:55
  • I guess what you really mean is why is "string" a keyword at all. c doesnt have it c++ has it in the std lib along with a bunch of stuff
    – Ewan
    Commented Feb 20 at 17:36
  • 2
    This question is a little confused. Take a step back. Is object a "primitive type" in your opinion? How is it possible for object to be both an object and a primitive then? Commented Feb 21 at 0:40
  • 2
    "In Java, strings are just objects" - If we're going to be pedantic about language features, that's not true. Strings in Java are different from all other object types in two ways: they have literals and they have an addition operator. Commented Feb 23 at 8:06

5 Answers 5


In C#, strings can be used like objects with methods, properties, and other features of objects.

In C# strings are objects with methods and properties.

At the same time, strings are treated the same as primitive data types like int or float in numerous ways as well (lowercase name, behaves like a keyword, etc.).

The C# specification used to have the word "primitive" in it. Twice. Never defined. Somehow used inconsistently even though it was only in there twice. We removed it from the specification. There is no such thing as a "primitive" type in C#, so there's really no way to answer questions about it.

The fact that string is an alias for System.String, and object is an alias for System.Object is just a fact about the specification of the language. There's no deeper meaning to suss out there. The fact that string and object are both reserved words is hardly relevant to the type system.

How does the C# string type act like an object and a primitive type simultaneously?

In C#, strings are objects. Integers are also objects. Floats are objects, decimals are objects. Whatever you think a "primitive type" is, there is no contradiction between anything acting like a "primitive type" and anything acting like an object. Objects act like objects because they are objects.

This is probably a deeply unsatisfying answer, but the question is very confusing. Can you sort out what you mean by "primitive type" and clarify the question?  

  • Thankyou for the canonical answer; I think Microsoft may have left this confusion in some of the CodeAnalysis namespace, especially github.com/dotnet/roslyn/blob/main/docs/compilers/… and learn.microsoft.com/en-us/dotnet/api/… . These "core types" look like "primitives" even though they mix machine value types for integers with object reference types like String and Array.
    – pjc50
    Commented Feb 21 at 8:55
  • I think we can presume the OP is coming at this from the perspective of Java and its primitive types. Avoiding the concept of primitives was a great choice given on how poorly that went. One thing I don't quite get, which leads to the OP's confusion here, is why there are alias type names. What's the rationale for having string and String if there's no difference between them?
    – JimmyJames
    Commented Feb 21 at 15:34
  • 1
    While I hate to disagree with Eric Lippert, I think the C# spec contradict the claim that integers and floats are objects. The C# spec defines objects as instances of reference types: Value types differ from reference types in that variables of the value types directly contain their data, whereas variables of the reference types store references to their data, the latter being known as objects. [...] a value of any type can be treated as an object. [...] Values of value types are treated as objects by performing boxing and unboxing operations - so an unboxed int is not in itself an object.
    – JacquesB
    Commented Feb 22 at 16:51
  • 3
    @JacquesB: I've never liked that part of the spec because it is wrong in many ways. First, "unboxing" doesn't make sense in this context, second it is conflating a CLR VES implementation detail with the requirements of the language, third, lots of ways we treat ints as objects do not box. Calling ToString() on an int for example treats it as an object but certainly does not box it. Fourth, pointer types cannot be treated as objects and do not box. Fifth, nullable value types have no boxed form. Commented Feb 23 at 8:27
  • 1
    The whole para is incoherent. It should say that when an object that is a value type must be treated as a reference type, boxing happens. I'll make a note to have the specification committee look at that. Commented Feb 23 at 8:28

There is some big misunderstanding going on here.

In c# everything is object, including primitive types like ints. Following pieces of code are valid:

string text = 123.ToString();
object obj = 123;

The main confusion might come from the fact that C# has both string and String , int and Int32, bool and Boolean. They might look like different things, but they are just aliases. They are interchangeable in code. The former is C# type keywords, while the later is CRL canonical name.

C# also has value types, but those aren't what I think isn't relevant by your question. In most scenarios, value types are semantically identical to objects, as demonstrated above, because Int32 is a value type, yet can have method call or be cast to object. Main differences are that one is passed by reference, while another is passed by value. So if piece of code changes value inside a value object, this change won't propagate to other parts that see that object. This is why it is generally good idea when value object is immutable, eg. it cannot change once created.

Strings are kind of weird, in that they are reference types, but because their immutability, behave more like a value object. But that doesn't have impact on them having same object-like behavior like ints and bools.


So, to be pernickety "string" isn't a primitive in either language, "char" is.

The real question is why "string" is a keyword, like int, byte, char etc. Its hard to be certain but I think the reason is as follows

  1. C# is supposed to be like C
  2. C doesn't have a string either, you declare char arrays. But it was added as part of the standard library in C++
  3. The primitives int, bool, char etc are "basic types" in C and "built in types" in c# and all have keywords in lowercase

Now given the above it seems like if you were making a new language C#, it has to be like C and C++, but you might think missing "string" out of C++ was a mistake, you don't want everyone to be declaring char[] or referencing Microsoft.StandardTypes in every program ever.

You are going to make strings one of your "built in types" that you don't need any extra libraries to use. All the other "built in types" match the c "basic types" and have lower case keywords. You want strings to be part of this set, so you also make "string" a keyword.

It seems logical to me, but I cant track down any articles to prove it.

  • Another compelling factor IMO is having compiled assemblies supporting strings as metadata embedded in the intermediate language (e.g. Attributes); in addition to other low-level CLR features which needed to handle strings beyond simply storing them - for example, interop with native DLLs. Commented Feb 20 at 19:43
  • i dunno, I was fully expecting the answer to be "because C did it" but tracking down these design descisions is next to impossible unless you find someones biography or off hand blog comment "when we we designing the... joe though x would be great!"" kind of thing
    – Ewan
    Commented Feb 20 at 19:48
  • 1
    To be honest, I think they allow string because it is such a common type. Why press the "shift" key 140 times an hour? Sure, Intellisense can turn "string" into "String", but I find Intellisense works better if you match the letter case of the type. And from my experience, people don't use Intellisense efficiently, opting to press the Shift key when they don't really need to. But this is pure conjecture. Commented Feb 20 at 20:01
  • 3
    If the question is actually "what is the history of the string type in .NET?" that is straightforward to answer. The .NET type system is an extension of the Visual Basic type system. The OLE Automation layer which defined interoperability between objects pre .NET was created by the VB team, in the office next to mine in the 1990s. Commented Feb 21 at 0:47
  • 2
    Behind the scenes .NET strings are morally BSTRs -- basic strings -- with some .NET pixie dust sprinkled on them. Length-prefixed, null-terminated, UTF 16 arrays. Commented Feb 21 at 0:47

Key points are that strings are reference types, not value types and that having a native C# name for it or not says nothing about the type.

Identifiers like string and int are part of the C# language. String and Int32 are not, they are .NET types. Formally C# is independent of .NET and could be implemented on a different platform on which no .NET types would be available.


Strings are objects in C#, just like in Java. But strings have value semantics, which mean:

  • They are immutable
  • They are compared by value (content) rather than reference when using ==

When an object have value semantics, it can be considered an implementation detail whether it is a reference type or value type, since the difference is not observable.

Beside strings there are other reference types with value semantics, e.g. tuples, records, and anonymous types.

More generally, C# does not have the sharp syntax-level distinction between objects and primitives as in Java. It has the broader concept of value-types and the syntax does more to smooth over the differences between objects and value types. For example you can call methods on value types including primitives.

About case:

In C# types have a pascal-case name but a number of the most used types have a lower-case type keyword for convenience. For example object is an alias for System.Object, int is an alias for System.Int32 and string is an alias for System.String.

This is a caveat if you are coming from Java. In Java int and Integer are two different types, where int is the primitive and Integer is an object which wraps the primitive. In C# int and System.Int32 is the same type, and wrapping happens through boxing instead.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.