What does mean "symmetry" between predefined types and custom types?

Question

Currently, I'm reading C# 5.0 in a Nutshell and in the Type Basics (located at Chapter 2) subtopic the term symmetry of predefined types and custom types is introduced...

...why the author talks about symmetry between those types? What are the argument to say that types are symmetric?

This is the original paragraph:

A beautiful aspect of C# is that predefined types and custom types have few differences. The predefined int type serves as a blueprint for integers. It holds data -32 bits- and provides function members that use that data, such as ToString. Similarly, our custom UnitConverter type acts as a blueprint for unit conversions. It holds data -the ratio- and provides function members to use that data.

Chapter two is not type basics...in fact, there isn't a chapter called type basics. Page number? Also, this sort of questions isn't for SO. — It'sNotALie., Jun 28 '13 at 23:00
@newStackExchangeInstance: There is a *section* in chapter 2 called "Type Basics", (p15 in fact). It's not that hard to deduce from the description. — Jon, Jun 28 '13 at 23:05
@newStackExchangeInstance "This sort of questions isn't for SO" Why not? — Fabian Bigler, Jun 28 '13 at 23:19

Jon · Answer 1 · 2013-06-28T23:27:55.253

The meaning of the text is that all of the types in the language "behave like objects". For example, you can do this:

int i = 42;
Console.WriteLine(i.ToString()); // called a method on an int

as easily as you can do this:

DateTime d = DateTime.Now;
Console.WriteLine(d.ToString()); // called a method on a DateTime

That is, if you did not know the types of i and d you would not be able to deduce anything by just reading the code that calls .ToString().

Contrast this with a language like C++:

std::string s = "hello";
std::cout << s.length();

int i = 42;
// ...but you cannot invoke any method on i; "ints are special"

Here the fact that s.length() compiles tells us that s is not an int, or a pointer, or any other primitive type.

This uniformity does not buy you anything from a technical standpoint, but it is nevertheless a welcome feature -- especially if you are just learning the language.

score 2 · Answer 2 · answered Jun 28 '13 at 23:11

I believe the author's point is that built-in types and custom types are both meant to serve similar purposes; hold data and provide mechanisms for using that data. I believe there is also a veiled reference in there that both built-in objects and custom objects inherit from System.Object, thus they share similar abilities (i.e. ToString()).

I do not necessarily agree with term 'symmetry', but that is my two cents on the topic.

score 1 · Answer 3 · edited May 23 '17 at 11:56

There are languages where you can't create type that behave similarly to something that is built in like int. In C# one can create type with all properties of 'int' (which is synonym of System.Int32) - value type with +/-/=operation.

I.e. in JavaScript one can't create another Array type or string type. In Java value types are (were?) not present, so type equivalent to 'int' can't be written by programmer ( Does Java make distinction between value type and reference type ).

score 0 · Answer 4 · answered Feb 06 '23 at 14:55

I am reading the latest edition of this book for C# 10 and had the same question. I like all of the answers so far provided, but have one additional point: this is a reference to the utility of C#'s unified type system, which the author mentions briefly in Chapter 1 under the section 'Object Orientation':

Unified type system The fundamental building block in C# is an encapsulated unit of data and functions called a type. C# has a unified type system in which all types ultimately share a common base type. This means that all types, whether they represent business objects or are primitive types such as numbers, share the same basic functionality. For example, an instance of any type can be converted to a string by calling its ToString() method.

To distill the author's writing and the comments from others down into a few points:

The type system of C# is unified, in that all types inherit from the common System.Object type.
Logically, type components can be logically grouped into two components: data members and function members.
Practically, because types behave like objects (they all have some data and/or behavior); developers can expect a minimum set of functionality from all types when using C#, such as the ability to call .ToString(), among other things.

These three points seem to be what the author had in mind when he referred to the C# type system having a 'symmetric beauty'.

What does mean "symmetry" between predefined types and custom types?

4 Answers4