Define my own data type

[Just D]

All,

It was possible before in Pascal, C++, etc. to define our custom data type
or redefine the existing type, like in Turbo Pascal we could assume that
shortint is int and use all references to shortint like all these variables
became int.

How can we define our own user data type in C# is we can?

Just D.

[noah]

On 22 Jun 2006 20:03:24 -0700, "Bruce Wood" <br*******@cana da.com>
wrote:

just a word, bruce...

what do you say about basic types like int32, uint32, int16, uint16
and so on? they are in fact even more readable than the original
one's. In Unix I also found datatypes like this: u8, i8, u16, i16,
u32, i32... unix programmers always tend to write as less as possible
:-)

I agree to you, if someone uses int32 as a 16 bit type, then you have
the right to complain. on the other hand, if you need one hour to
debug a misuse of a data type, which in first sight has another name
than the original ones, then I doubt a bit of your programming skills
at this time ;-)

And yes, I agree to JustD , this C "feature" was one of the first
things I missed in C#.

so long,
noah

Just D wrote:

It was possible before in Pascal, C++, etc. to define our custom data type
or redefine the existing type, like in Turbo Pascal we could assume that
shortint is int and use all references to shortint like all these variables
became int.

How can we define our own user data type in C# is we can?

In general terms, defining a new class in C# _is_ defining a new type.

If, however, you mean that you want to define an "alias" for an
existing data type, so that, for example, all places in your code that
say

short x;

and suchlike use the int type instead of the "short" that is written
there, then no, you cannot do that in C#. Furthermore, it's a great
feature (or un-feature) that you can't do that. In 20 years of C
programming I saw this feature (ab)used only once, and it took me an
hour of staring at the code and debugging, wondering why it was acting
so #$&*$@ weird, before I looked inside a header file and found that
some jackass had redefined a basic type in this way. Fortunately he no
longer worked for the company, or I would have been honour-bound to
have killed him and mounted his head on a pike or something like that.

I'm very happy that C# doesn't let people do crap like redefine
existing, basic types.

However, if you want to define a brand new type, then just declare a
new class and there you have it.

[Jon Skeet [C# MVP]]

noah <noah@home> wrote:

I agree to you, if someone uses int32 as a 16 bit type, then you have
the right to complain. on the other hand, if you need one hour to
debug a misuse of a data type, which in first sight has another name
than the original ones, then I doubt a bit of your programming skills
at this time ;-)

To me, that just suggests you haven't been in macro hell. When things
end up getting redefined (so that potentially the same name can mean
different things at different points in the same file) life can get
very nasty indeed.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Bruce Wood]

> I agree to you, if someone uses int32 as a 16 bit type, then you have

the right to complain. on the other hand, if you need one hour to
debug a misuse of a data type, which in first sight has another name
than the original ones, then I doubt a bit of your programming skills
at this time ;-)

That was exactly the sort of thing that happened. Someone had created a
macro like this, if I recall correctly (it was a long time ago):

#define int short

I spent an hour or so stepping through the code, trying to figure out
why the code was failing for large values, when everything was stored
in ints which were clearly capable of storing the information.

Anyway, it was something along those lines. Stuff like this, I don't
miss.