Struct Vs Classes

[Ashish Sheth]

Hi Gurus,
In C# why struct can't be inherited from another struct, just like a class
can be inherited from another class? another question is all struct by
default are inherited from System.Object class, how this is possible when it
is not allowed to derive a struct from a class? and System.Object is the
reference type provided by the .NET Framework then why structs are value
types? since the struct are derived from System.Object then they should be
also a reference type. Can anybody answer this questions?

thanks and regards,
Ashish Sheth

[Nicholas Paldino [.NET/C# MVP]]

Ashish,

A structure is a special case type in .NET, and is considered to have
certain semantics. Also, structures are derived from ValueType, not Object
(but ValueType is derived from Object).

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m
"Ashish Sheth" <ea*****@gmail. com> wrote in message
news:O9******** ******@TK2MSFTN GP09.phx.gbl...

Hi Gurus,
In C# why struct can't be inherited from another struct, just like a class
can be inherited from another class? another question is all struct by
default are inherited from System.Object class, how this is possible when
it
is not allowed to derive a struct from a class? and System.Object is the
reference type provided by the .NET Framework then why structs are value
types? since the struct are derived from System.Object then they should be
also a reference type. Can anybody answer this questions?

thanks and regards,
Ashish Sheth

[Tom Porterfield]

Ashish Sheth wrote:

Hi Gurus,
In C# why struct can't be inherited from another struct, just like a class
can be inherited from another class? another question is all struct by
default are inherited from System.Object class, how this is possible when it
is not allowed to derive a struct from a class? and System.Object is the
reference type provided by the .NET Framework then why structs are value
types? since the struct are derived from System.Object then they should be
also a reference type. Can anybody answer this questions?

Your logic is flawed. Numeric types such as int and decimal also derive
from System.Object, so following your logic an int should be a reference
type and should be allowed to derive from a class or be derived from.

As structs are value types, unlike classes they do not require heap
allocation. Also, as value types they cannot be derived from. Structs
can implement an interface.
--
Tom Porterfield

[Jon Skeet [C# MVP]]

Daniel Jin <Da*******@disc ussions.microso ft.com> wrote:

A structure is a special case type in .NET, and is considered to have
certain semantics. Also, structures are derived from ValueType, not Object
(but ValueType is derived from Object).

as an interesting side note, System.ValueTyp e itself is in fact not a value
type.

As another interesting side note, the value types themselves don't
inherit from System.ValueTyp e, either. Instead, their corresponding
boxed types inherit from ValueType, and they don't inherit from
anything.

It's a murky world out there...

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

[Joe Mayo [C# MVP]]

Hi Ashish,

In addition to what the other people said, there is a concept called Type
System Unification, which allows everything to be treated as an object. It
kind of gives you the best of all worlds with the benefits of performance
with struct/value types and the power of object-oriented programming with
reference types. I discuss it more in the following article:

http://www.csharp-station.com/Articles/ObjectClass.aspx

BTW, comments on this article are welcome.

Joe
--
Joe Mayo, Author/Instructor
Need C#/.NET training?
visit www.mayosoftware.com
C# Tutorial - www.csharp-station.com

"Ashish Sheth" <ea*****@gmail. com> wrote in message
news:O9******** ******@TK2MSFTN GP09.phx.gbl...

Hi Gurus,
In C# why struct can't be inherited from another struct, just like a class
can be inherited from another class? another question is all struct by
default are inherited from System.Object class, how this is possible when it is not allowed to derive a struct from a class? and System.Object is the
reference type provided by the .NET Framework then why structs are value
types? since the struct are derived from System.Object then they should be
also a reference type. Can anybody answer this questions?

thanks and regards,
Ashish Sheth

[Mike Schilling]

"Joe Mayo [C# MVP]" <jm***@nospamAt CSharpDashStati on.com> wrote in message
news:ud******** ******@TK2MSFTN GP09.phx.gbl...

Hi Ashish,

In addition to what the other people said, there is a concept called Type
System Unification, which allows everything to be treated as an object.
It
kind of gives you the best of all worlds

(cough, cough, cough)

That is, it makes different tradeoffs than do systems that distinguish
objects from scalar types.

[Joe Mayo [C# MVP]]

"Mike Schilling" <ms************ *@hotmail.com> wrote in message
news:%2******** **********@TK2M SFTNGP14.phx.gb l...

"Joe Mayo [C# MVP]" <jm***@nospamAt CSharpDashStati on.com> wrote in message
news:ud******** ******@TK2MSFTN GP09.phx.gbl...

Hi Ashish,

In addition to what the other people said, there is a concept called Type System Unification, which allows everything to be treated as an object.
It
kind of gives you the best of all worlds

(cough, cough, cough)

That is, it makes different tradeoffs than do systems that distinguish
objects from scalar types.

That is true. Thanks. ;)

Joe
--
Joe Mayo, Author/Instructor
Need C#/.NET training?
visit www.mayosoftware.com
C# Tutorial - www.csharp-station.com

[Mike Schilling]

"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...

Daniel Jin <Da*******@disc ussions.microso ft.com> wrote:

> A structure is a special case type in .NET, and is considered to
> have
> certain semantics. Also, structures are derived from ValueType, not
> Object
> (but ValueType is derived from Object).

as an interesting side note, System.ValueTyp e itself is in fact not a
value
type.

As another interesting side note, the value types themselves don't
inherit from System.ValueTyp e, either. Instead, their corresponding
boxed types inherit from ValueType, and they don't inherit from
anything.

Can you enlarge on that? Consider:

int i = 12;
Object o = i;
int j = (int)o;

While it's clear that boxing and unboxing are taking place, it's not
obviuous (to me, now) that type conversion is taking place as well.

[Jon Skeet [C# MVP]]

Mike Schilling <ms************ *@hotmail.com> wrote:

As another interesting side note, the value types themselves don't
inherit from System.ValueTyp e, either. Instead, their corresponding
boxed types inherit from ValueType, and they don't inherit from
anything.

Can you enlarge on that? Consider:

int i = 12;
Object o = i;
int j = (int)o;

While it's clear that boxing and unboxing are taking place, it's not
obviuous (to me, now) that type conversion is taking place as well.

It is, because the boxed type isn't the same as the value type. Boxing
and unboxing themselves are conversions.

This is hidden at any number of levels from the developer, to be
honest, but if you look at the CLI spec it's all there. Just don't
expect to come out again with your mind in tact :)

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

[Mike Schilling]

"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...

Mike Schilling <ms************ *@hotmail.com> wrote:

> As another interesting side note, the value types themselves don't
> inherit from System.ValueTyp e, either. Instead, their corresponding
> boxed types inherit from ValueType, and they don't inherit from
> anything.

Can you enlarge on that? Consider:

int i = 12;
Object o = i;
int j = (int)o;

While it's clear that boxing and unboxing are taking place, it's not
obviuous (to me, now) that type conversion is taking place as well.

It is, because the boxed type isn't the same as the value type. Boxing
and unboxing themselves are conversions.

This is hidden at any number of levels from the developer, to be
honest, but if you look at the CLI spec it's all there. Just don't
expect to come out again with your mind in tact :)

Here's another program.

public static void Main()
{
int i = 12;
Object o = (Object)i;

Console.WriteLi ne(i.GetType()) ;
Console.WriteLi ne(i.GetType(). BaseType);
Console.WriteLi ne(i.GetType(). GetHashCode());
Console.WriteLi ne(o.GetType()) ;
Console.WriteLi ne(0.GetType(). BaseType);
Console.WriteLi ne(o.GetType(). GetHashCode());
Console.WriteLi ne(i.GetType() == o.GetType());
}

Its output is:

System.Int32
System.ValueTyp e
113273860
System.Int32
System.ValueTyp e
113273860
True

This doesn't disprove what you said, of course, it shows only that GetType()
on an unboxed object returns the boxed type, or conversely that GetType() on
a boxed object returns the unboxed type, which thereupon lies about its
ancestry. Once dishonesty enters the type system, it's difficult to know
who to believe:-)