Comments for onezero

Comment on Shorter Construction Syntax by April

April — Tue, 08 Jul 2008 15:12:00 +0000

I agree with you completely. The lack of a more concise syntax in C# is all the more puzzling considering that VB allows a syntax very similar to what you propose:
Dim a As New Thing2(3,2)

Comment on The “Structs Should Always be Immutable” Guideline by Jackie

Jackie — Wed, 23 Apr 2008 10:52:32 +0000

You came to bid me good bye, then you are just in time probably free movies of musclar lesbians What did St John Rivers think of this earthly angel I naturally sagtdbuzini

Comment on Shorter Construction Syntax by Andrew

Andrew — Sat, 13 Oct 2007 06:23:49 +0000

Good point Radu! This is a nice syntax to use in some cases.

I think that this point leaves the argument largely unchanged, in that it seems helpful to have a concise notation such as new() that could be used consistently for local and non-local variables.

Comment on Shorter Construction Syntax by Radu

Radu — Sat, 13 Oct 2007 06:09:25 +0000

Type inference in C# 3.0 makes it much more concise (though it only works for local variables). So rather than your proposed shorthand
Dictionary = new();
you can instead do
var dict = new Dictionary();
(where “var” is still strongly typed, not to be confused with the loose typing “var” in javascript)

Comment on The Worst Songs Ever by Trace

Trace — Thu, 27 Sep 2007 05:27:14 +0000

The jackpot CD you mention is “Sounds of the Seventies: AM Top Twenty” by Time Life Music.

Comment on The Worst Songs Ever by Deb Hoppe

Deb Hoppe — Thu, 13 Sep 2007 03:11:55 +0000

What about The Brothers Johnson?
“strawberry letter number 23, oooow woo wooo woo woooo!”

Comment on The “Structs Should Always be Immutable” Guideline by Georg Kolling

Georg Kolling — Thu, 19 Jul 2007 14:22:43 +0000

The first argument ist very weak. I don’t really see how immutable types are supposed to be simpler. Is it simpler to always create new objects instead of changing existing ones?

The second argument is plain wrong. In your example, s is already a copy of the argument passed to threadSafeMethod. There is no need for t at all because C# passes method arguments by value, unless you explicitly declare it a reference argument with the ref keyword. Which is required both in the argument list as well as at the call site, so it’s instantly obvious you’re dealing with a reference.

The third argument is a matter of perspective. You may actually consider the primitive types mutable, given operators such as ++, +=, *=, etc.

The fourth argument is based on a flawed assumption.
“This scenario violates reasonable client assumptions that values residing inside a box will not be modified.”
What is the reasoning behind this assumption to make it a “reasonable” one?

The correct assumption is: when I’m dealing with a variable of type Object, or an interface variable (like boxed, cast to IChangeable in your example), I expect it to behave as if it refers to an instance of a reference type.

IChangeable.Change _should_ change the instance it’s called on, whether that’s a boxed value type or a “real” reference type.

Regards,
Georg