design question : struct or class

[phoenix]

Hello,

I've got a design question. I need to keep track of some variables and I am
planning to put them inside a class or struct. Basically I'm talking about
10 bools, 20 ints and 2 arrays of ints. The size of the arrays would depend
on some external value (going from 0 to around 1000 max). I would have an
array of max 255 of these classes/structs (in most cases it will be less
then 5 however)

Since there's no real business logic my choice would be structs. But looking
at the size of the objects in memory I would think they are a bit large to
put on the stack and should be better of on the heap. Which would mean I
should use classes.

Any ideas about what would be best?

TIA

Yves

[rhavaldar at shodaka dot net]

I would suggest grouping your 'data' into structs/classes (based on the
your need for value type/reference type. You would potentially
end up w/ many of these structures and not just 'one' global placeholder.

For more, check out the structural design patterns @ c2 -
http://c2.com/cgi/wiki?CategoryStructuralPatterns

- raghu
codymanix wrote:

I've got a design question. I need to keep track of some variables and I

am

planning to put them inside a class or struct. Basically I'm talking about
10 bools, 20 ints and 2 arrays of ints. The size of the arrays would

depend

on some external value (going from 0 to around 1000 max). I would have an
array of max 255 of these classes/structs (in most cases it will be less
then 5 however)

You should *Always* use classes. structs are only needed in very rare
circumatances which isn't the case.

[Jon Skeet [C# MVP]]

peter x <la******@boltb lue.com> wrote:

<snip>

When objects are passed to a method, they are passed by reference.

No they are not. "Pass by reference" has a very specific meaning, and
it *doesn't* apply here (unless you use the ref modifier). There is a
big difference between a reference being passed by value (which is what
actually happens) and a parameter itself being passed *by* reference.

See http://www.pobox.com/~skeet/csharp/parameters.html for more
information.

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

[peter x]

I stand corrected :) Although I'm not sure I totally understand your
response. Can you send me an example to help me clarify. Apart from this
point was the rest of the assessment correct? specifically the point about
the overhead involved in passing by value. I may need to reassess how I
program

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

peter x <la******@boltb lue.com> wrote:

<snip>

When objects are passed to a method, they are passed by reference.

No they are not. "Pass by reference" has a very specific meaning, and
it *doesn't* apply here (unless you use the ref modifier). There is a
big difference between a reference being passed by value (which is what
actually happens) and a parameter itself being passed *by* reference.

See http://www.pobox.com/~skeet/csharp/parameters.html for more
information.

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

[Jon Skeet [C# MVP]]

peter x <la******@boltb lue.com> wrote:

I stand corrected :) Although I'm not sure I totally understand your
response. Can you send me an example to help me clarify.
Sure.

Here's what pass by value means:
The value of the expression in the actual parameter (i.e. in the
calling code) becomes the value of the new variable which is the formal
parameter (i.e. in the method itself).

Here's what pass by reference means:
Only a variable (non-read only) can be used as a pass by reference
parameter, and the formal parameter variable in the called method is
effectively aliased with the actual parameter - they are different
names for the same memory location, so changing the value of one
changes the value of the other.

Note that nowhere in those definitions is the type of the parameter
(i.e. reference type or value type) used. Both value type parameters
and reference type parameters can be passed by value or by reference,
and in both cases the default is "by value". The only twist here is
understanding that the value of a reference type expression (or
variable) isn't an object - it's a reference. So, if I do:

string x = "hello";
Foo (x);
....
void Foo (string y)
{
....
}

the string itself isn't passed - the string *reference* (the value of
x) is passed by value.

For more examples etc, have another look at the article I linked to
before.
Apart from this point was the rest of the assessment correct?
As far as I saw, yes - I only skimmed it though. (The usual terminology
is reference type rather than object type though.)
specifically the point about
the overhead involved in passing by value. I may need to reassess how I
program

Unlikely. You should indeed by using classes most of the time, and
passing a reference by value is indeed cheaper than passing a large
value type value.

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

[Ravichandran J.V.]

Yes, if the memory that the object is going to occupy is large, the
usual choice is a class but, if the object is going to contain only
data-members, then it is beter to use a struct as a class is generally
resolved as a container for logic apart from data-members.

with regards,
J.V.Ravichandra n
- http://www.geocities.com/
jvravichandran
- http://www.411asp.net/func/search?
qry=Ravichandra n+J.V.&cob=aspn etpro
- http://www.southasianoutlook.com
- http://www.MSDNAA.Net
- http://www.csharphelp.com
- http://www.poetry.com/Publications/
display.asp?ID= P3966388&BN=999 &PN=2
- Or, just search on "J.V.Ravichandr an"
at http://www.Google.com

*** Sent via Developersdex http://www.developersdex.com ***
Don't just participate in USENET...get rewarded for it!

[Jeff Louie]

As Jon has stated, objects, by default, are passed by value. Structures
have the overhead of value semantics, as I see it, just like C++
classes,
but without the benefit of C++'s deterministic destructors. Thus the
limited usefullness of structures in C#.

Regards,
Jeff

*** Sent via Developersdex http://www.developersdex.com ***
Don't just participate in USENET...get rewarded for it!

[Jon Skeet [C# MVP]]

Jeff Louie <an*******@devd ex.com> wrote:

As Jon has stated, objects, by default, are passed by value.

I didn't quite state that - I stated that *parameters* are passed by
value by default. Reference type objects are never passed in any way,
as the type of an expression is never a reference type object, only a
reference.

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

[L#]

On Fri, 30 Jan 2004 00:56:36 +0100, "codymanix"
<do************ *********@gmx.d e> wrote:

You should *Always* use classes. structs are only needed in very rare
circumatance s which isn't the case.

You should use structs if they are very small. They live on the stack
and are therefore faster. But if they are too big, the advantage of
being faster dissappears. If they become too big, the framework will
put them on the heap anyway, even if you declared it as a struct.

So, is they are very small, use structs, else use classes.

--
Ludwig
mailto:ludwig_( nospamplease)st uyck@pandora(no spamplease).be

[L#]

On Sat, 31 Jan 2004 12:05:33 -0000, Jon Skeet [C# MVP]
<sk***@pobox.co m> wrote:

peter x <la******@boltb lue.com> wrote:

<snip>

When objects are passed to a method, they are passed by reference.

No they are not. "Pass by reference" has a very specific meaning, and
it *doesn't* apply here (unless you use the ref modifier). There is a
big difference between a reference being passed by value (which is what
actually happens) and a parameter itself being passed *by* reference.

See http://www.pobox.com/~skeet/csharp/parameters.html for more
information.

Being objects, they are passed by value; meaning that the pointer to
the object is passed by value. Eventually it has the same effect as
being passed by reference. Placing the ref keyword in front of it,
won't make a difference.

--
Ludwig
mailto:ludwig_( nospamplease)st uyck@pandora(no spamplease).be

[Joe Mayo [C# MVP]]

"L#" <ludwig_(nospam please)stuyck@p andora(nospampl ease).be> wrote in message
news:oo******** *************** *********@4ax.c om...

On Fri, 30 Jan 2004 00:56:36 +0100, "codymanix"
<do************ *********@gmx.d e> wrote:

You should *Always* use classes. structs are only needed in very rare
circumatance s which isn't the case.

You should use structs if they are very small. They live on the stack
and are therefore faster. But if they are too big, the advantage of
being faster dissappears. If they become too big, the framework will
put them on the heap anyway, even if you declared it as a struct.

So, is they are very small, use structs, else use classes.

Hi L#,

Structs reside on the stack if they are parameters or local variables,
otherwise they are stored on the heap. The best way to determine whether
the size of the struct is affecting performance is to benchmark your
application. I've never seen or heard anything that would make me believe
that the size of a value type determines whether they reside on the stack or
on the heap.

Jon Skeet wrote a nice article that explains this better:
http://www.yoda.arachsys.com/csharp/memory.html.

The reason you would use a struct instead of a class is if you need
value-type semantics, similar to int, float, or DateTime.

Joe
--
http://www.csharp-station.com