?? Basic C# Language Questions ??

[Robin Bowning]

Hi all,

I have two questions I was hoping someone could answer regarding C#.

First, I noticed C# does not allow local readonly variables. For example,
the following is illegal:

void X() {
readonly int i = 1;
}

I know that for this simple example I could have used const but there are
times when you must use readonly. Why can't readonly variables be local?

My second question has to do with jagged arrays. The following construct is
legal:
int[] a1 = {1, 2, 3};

but this is not:
int[][] a2 = {{1, 2, 3}, {4, 5}};

The above declaration of a2 will generate two errors (both the same):
"Array initializers can only be used in a variable or field initializer. Try
using a new expression instead."

I'm obviously missing something here. To my (obviously incorrect) way of
thinking, a2 *IS* being initialized with a variable initializer.

If I change the above declaration to this:

int[][] a2 = { new int[] {1, 2, 3}, new int[] {4, 5}};

the errors goes away. Would someone be able to clarify this behavior,
please?

Thanks very much.

[Freiddie]

For one thing, I don't see any reason why local variables, which are
never accessed by any external code, should be readonly. You can use
constants (equivalent of readonly). But what readonly really means is
that external code (e.g. if you're making a DLL library and someone
else is supposed to use it) cannot change this property, while you may
still be able to change the inner variable. It only applies to
properties, which are exposed to external codes.

Next, for any array the "proper" declaration is:
int[] a = new int[] { xxxxxxx ];
But C# makes it easier, by using the "less legal" version
int[] a = { xxxxxxx };
That makes it a shorthand notation.
But it doesn't apply to the inner brackets of the jagged arrays.
The notation you said to be illegal is valid for multidimensiona l
arrays, though.

Freiddie
http://fei.yuanbw.googlepages.com/
http://freiddy.blogspot.com/
http://scilearn.blogspot.com/

[=?Utf-8?B?RGF2aWQgQW50b24=?=]

'readonly' variables can be initialized either in the declaration or in a
constructor, but nowhere else. How did you expect this to relate to local
variables?

In your array example, your first initializer is a 2-dimensional array
initializer. Your second try is appropriate for a jagged array since it is
an array of arrays.
--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
C++ to C# Converter: converts C++ to C#
Instant C++: converts C# or VB to C++/CLI
"Robin Bowning" wrote:

Hi all,

I have two questions I was hoping someone could answer regarding C#.

First, I noticed C# does not allow local readonly variables. For example,
the following is illegal:

void X() {
readonly int i = 1;
}

I know that for this simple example I could have used const but there are
times when you must use readonly. Why can't readonly variables be local?

My second question has to do with jagged arrays. The following construct is
legal:
int[] a1 = {1, 2, 3};

but this is not:
int[][] a2 = {{1, 2, 3}, {4, 5}};

The above declaration of a2 will generate two errors (both the same):
"Array initializers can only be used in a variable or field initializer. Try
using a new expression instead."

I'm obviously missing something here. To my (obviously incorrect) way of
thinking, a2 *IS* being initialized with a variable initializer.

If I change the above declaration to this:

int[][] a2 = { new int[] {1, 2, 3}, new int[] {4, 5}};

the errors goes away. Would someone be able to clarify this behavior,
please?

Thanks very much.

[Robin Bowning]

Below...
"Freiddie" <fe********@gma il.comwrote in message
news:11******** *************@l 77g2000hsb.goog legroups.com...

For one thing, I don't see any reason why local variables, which are
never accessed by any external code, should be readonly. You can use
constants (equivalent of readonly).

const is certainly not the equivalent of readonly. Sure, they're similar, to
a limited extent, but not at all the same. Try doing this:
const MyClass mc = new MyClass();

But what readonly really means is
that external code (e.g. if you're making a DLL library and someone
else is supposed to use it) cannot change this property, while you may
still be able to change the inner variable. It only applies to
properties, which are exposed to external codes.

"...what readonly really means..."? No -- you have described one possible
use of 'readonly'. What readonly means is that once a value is assigned it
cannot be re-assigned. That's all it "means". You have described one
possible intention of using 'readonly', but certainly not the only reason.
There's no sense in going into details as to *why* I want to make a local
readonly. It just seems that there's no good reason why I shouldn't be able
to.

Next, for any array the "proper" declaration is:
int[] a = new int[] { xxxxxxx ];
But C# makes it easier, by using the "less legal" version
int[] a = { xxxxxxx };

"Less legal"? There's nothing "less legal" about it.

That makes it a shorthand notation.
But it doesn't apply to the inner brackets of the jagged arrays.
The notation you said to be illegal is valid for multidimensiona l
arrays, though.

Yes, Thank you. I've discovered this myself. That's what I was asking about.
You basically re-phrased what I'd already stated.

[Robin Bowning]

"David Anton" <Da********@dis cussions.micros oft.comwrote in message
news:89******** *************** ***********@mic rosoft.com...

'readonly' variables can be initialized either in the declaration or in a
constructor, but nowhere else. How did you expect this to relate to local
variables?

Yes, I know this. But why? What's the rational? I can think of a couple good
reasons for having readonly locals but no good reasons *not* to allow them.
I already understand what is allowed/disallowed. I'm trying to get at the
rational.

In your array example, your first initializer is a 2-dimensional array
initializer. Your second try is appropriate for a jagged array since it
is
an array of arrays.

Yes, yes, yes... I know that....

--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
C++ to C# Converter: converts C++ to C#
Instant C++: converts C# or VB to C++/CLI
"Robin Bowning" wrote:

>Hi all,

I have two questions I was hoping someone could answer regarding C#.

First, I noticed C# does not allow local readonly variables. For example,
the following is illegal:

void X() {
readonly int i = 1;
}

I know that for this simple example I could have used const but there are
times when you must use readonly. Why can't readonly variables be local?

My second question has to do with jagged arrays. The following construct
is
legal:
int[] a1 = {1, 2, 3};

but this is not:
int[][] a2 = {{1, 2, 3}, {4, 5}};

The above declaration of a2 will generate two errors (both the same):
"Array initializers can only be used in a variable or field initializer.
Try
using a new expression instead."

I'm obviously missing something here. To my (obviously incorrect) way of
thinking, a2 *IS* being initialized with a variable initializer.

If I change the above declaration to this:

int[][] a2 = { new int[] {1, 2, 3}, new int[] {4, 5}};

the errors goes away. Would someone be able to clarify this behavior,
please?

Thanks very much.

[Jon Skeet [C# MVP]]

Robin Bowning <rb******@yahoo .comwrote:

<snip>

There's no sense in going into details as to *why* I want to make a local
readonly. It just seems that there's no good reason why I shouldn't be able
to.

I disagree on that front. Language features need to justify themselves
for inclusion, as each one contributes (even slightly) to the
complexity of the language. For instance, would you expect to be able
to do this:

readonly int x;

if (someCondition)
{
x = 0;
}
else
{
x = 1;
}

? The compiler could guarantee exactly one assignment, but the simpler
approach would be to force assignment in the same statement as
declaration. This kind of thing would need to be addressed in the spec.
Not having the possibility at all keeps the spec simpler.

So, I think there *is* sense in saying why it would be a positive thing
to have. For what it's worth, it's available in Java, and aside from
the times where one has to use it for anonymous inner classes reasons,
I can't remember ever seeing it being used. If one keeps methods
appropriately short (e.g. easily fitting on a single page) then it
should be reasonably clear that it's not being reassigned.

--
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

[=?Utf-8?B?RGF2aWQgQW50b24=?=]

I see - you want to set a variable to something at run-time (so a constant
won't work), but don't want it modifiable later in the method after assigning
a value.
--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
C++ to C# Converter: converts C++ to C#
Instant C++: converts C# or VB to C++/CLI
"Robin Bowning" wrote:

"David Anton" <Da********@dis cussions.micros oft.comwrote in message
news:89******** *************** ***********@mic rosoft.com...

'readonly' variables can be initialized either in the declaration or in a
constructor, but nowhere else. How did you expect this to relate to local
variables?

Yes, I know this. But why? What's the rational? I can think of a couple good
reasons for having readonly locals but no good reasons *not* to allow them.
I already understand what is allowed/disallowed. I'm trying to get at the
rational.

In your array example, your first initializer is a 2-dimensional array
initializer. Your second try is appropriate for a jagged array since it
is
an array of arrays.

Yes, yes, yes... I know that....

--
David Anton
www.tangiblesoftwaresolutions.com
Instant C#: VB to C# converter
Instant VB: C# to VB converter
C++ to C# Converter: converts C++ to C#
Instant C++: converts C# or VB to C++/CLI
"Robin Bowning" wrote:

Hi all,

I have two questions I was hoping someone could answer regarding C#.

First, I noticed C# does not allow local readonly variables. For example,
the following is illegal:

void X() {
readonly int i = 1;
}

I know that for this simple example I could have used const but there are
times when you must use readonly. Why can't readonly variables be local?

My second question has to do with jagged arrays. The following construct
is
legal:
int[] a1 = {1, 2, 3};

but this is not:
int[][] a2 = {{1, 2, 3}, {4, 5}};

The above declaration of a2 will generate two errors (both the same):
"Array initializers can only be used in a variable or field initializer.
Try
using a new expression instead."

I'm obviously missing something here. To my (obviously incorrect) way of
thinking, a2 *IS* being initialized with a variable initializer.

If I change the above declaration to this:

int[][] a2 = { new int[] {1, 2, 3}, new int[] {4, 5}};

the errors goes away. Would someone be able to clarify this behavior,
please?

Thanks very much.

[Robin Bowning]

"Jon Skeet [C# MVP]" <sk***@pobox.co mwrote in message
news:MP******** ************@ms news.microsoft. com...

Robin Bowning <rb******@yahoo .comwrote:

<snip>

>There's no sense in going into details as to *why* I want to make a local
readonly. It just seems that there's no good reason why I shouldn't be
able
to.

I disagree on that front. Language features need to justify themselves
for inclusion, as each one contributes (even slightly) to the
complexity of the language. For instance, would you expect to be able
to do this:

readonly int x;

if (someCondition)
{
x = 0;
}
else
{
x = 1;
}

? The compiler could guarantee exactly one assignment, but the simpler
approach would be to force assignment in the same statement as
declaration. This kind of thing would need to be addressed in the spec.
Not having the possibility at all keeps the spec simpler.

So, I think there *is* sense in saying why it would be a positive thing
to have. For what it's worth, it's available in Java, and aside from
the times where one has to use it for anonymous inner classes reasons,
I can't remember ever seeing it being used. If one keeps methods
appropriately short (e.g. easily fitting on a single page) then it
should be reasonably clear that it's not being reassigned.

Let me offer some (admittedly subjective) justification then for why I think
it would be a positive change to have local 'readonly's.

First, they provide a useful means to communicate intent. When I'm reading
someone's code and I see 'readonly' it tells me that the author intended
this variable to be immutable. Many of us try to use "meaningful variable
names" because their use facilitates understanding of code intent.
'readonly' locals would serve the exact same purpose.

Second, it could help in code correctness. If I declare a variable as
readonly and then I later attempt to change it, I've made an incorrect
assumption somewhere and the compiler will tell me -- either I should not
have declared the variable as 'readonly' or I may be changing the wrong
variable or my understanding of the problem may not be correct.

Thirdly (and let me offer this one with a grain of salt), 'readonly' locals
may allow better IL generation. John, you're right that Java allows an
equivalent qualifier (final) on local variables. Unless I'm mistaken,
declaring a variable as 'final' in Java allowed the Java JITter (Hotspot) to
generate more efficient code.

Now, I may be completely wrong about the third point or perhaps it's a point
that does not even apply to C#/CLR. Even so, I think the first two points
are still valid and are advantages we harvest if 'readonly' locals are
allowed. Whether the advantages of 'readonly' locals outweigh the added
complexity they bring to the spec is an open question.

My main motivation for the original post was to discover whether there was
some intrinsic technical issue that precluded their existence and from the
responses so far, it seems here is not.

[Bob Grommes]

Hi Robin,

I wonder if one couldn't create a value type that only allows itself to
be assigned to once? That wouldn't provide the syntax sugar you crave,
nor the compile-time notification of any transgression, nor any IL
optimization opportunities. But it would provide the runtime
functionality anyway, and the intent would show in the code by the type
you're declaring (e.g., ReadOnlyInt32).

--Bob

Robin Bowning wrote:

Hi all,

I have two questions I was hoping someone could answer regarding C#.

First, I noticed C# does not allow local readonly variables. For example,
the following is illegal:

void X() {
readonly int i = 1;
}

I know that for this simple example I could have used const but there are
times when you must use readonly. Why can't readonly variables be local?

My second question has to do with jagged arrays. The following construct is
legal:
int[] a1 = {1, 2, 3};

but this is not:
int[][] a2 = {{1, 2, 3}, {4, 5}};

The above declaration of a2 will generate two errors (both the same):
"Array initializers can only be used in a variable or field initializer. Try
using a new expression instead."

I'm obviously missing something here. To my (obviously incorrect) way of
thinking, a2 *IS* being initialized with a variable initializer.

If I change the above declaration to this:

int[][] a2 = { new int[] {1, 2, 3}, new int[] {4, 5}};

the errors goes away. Would someone be able to clarify this behavior,
please?

Thanks very much.

[Jon Skeet [C# MVP]]

Bob Grommes <bo*@bobgrommes .comwrote:

I wonder if one couldn't create a value type that only allows itself to
be assigned to once? That wouldn't provide the syntax sugar you crave,
nor the compile-time notification of any transgression, nor any IL
optimization opportunities. But it would provide the runtime
functionality anyway, and the intent would show in the code by the type
you're declaring (e.g., ReadOnlyInt32).

No, because it's not the *value* which is assigned to - it's the
*variable*. You tend to be creating a new value each time (with value
types), not changing an old one.

--
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