what is new in c# 3?

[Dan Holmes]

Linq and the features necessary to support it get a lot of attention but
i happened to find out about partial methods by chance. Is there a
comprehensive list of new c# stuff somewhere? i couldn't find anything
obvious on the c# page on msdn.

dan

[Kerem Gümrükcü]

Hi Dan,

your #1 Source for .NET, see there:
http://msdn2.microsoft.com/en-us/net...k/default.aspx

And e.g. have a look at this:
http://msdn2.microsoft.com/en-us/library/bb308966.aspx

Regards

Kerem

--
-----------------------
Beste Grüsse / Best regards / Votre bien devoue
Kerem Gümrükcü
Microsoft Live Space: http://kerem-g.spaces.live.com/
Latest Open-Source Projects: http://entwicklung.junetz.de
-----------------------
"This reply is provided as is, without warranty express or implied."

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

http://msdn2.microsoft.com/en-us/library/bb308966.aspx, as Kerem pointed out,
is a great list of new syntax in C# 3.

For a list of breaking changes in C#, you can see
http://msdn2.microsoft.com/en-us/library/bb308966.aspx

--
Browse http://connect.microsoft.com/VisualStudio/feedback/ and vote.
http://www.peterRitchie.com/blog/
Microsoft MVP, Visual Developer - Visual C#
"Kerem Gümrükcü" wrote:

Hi Dan,

your #1 Source for .NET, see there:
http://msdn2.microsoft.com/en-us/net...k/default.aspx

And e.g. have a look at this:
http://msdn2.microsoft.com/en-us/library/bb308966.aspx

Regards

Kerem

--
-----------------------
Beste Grüsse / Best regards / Votre bien devoue
Kerem Gümrükcü
Microsoft Live Space: http://kerem-g.spaces.live.com/
Latest Open-Source Projects: http://entwicklung.junetz.de
-----------------------
"This reply is provided as is, without warranty express or implied."

[sherifffruitfly]

On Dec 28, 7:35*am, Dan Holmes <[e-mail]:

Linq and the features necessary to support it get a lot of attention but
i happened to find out about partial methods by chance. *Is there a
comprehensive list of new c# stuff somewhere? *i couldn't find anything
obvious on the c# page on msdn.

dan

Whatever Jon Skeet says is new. Only 1/2 joking.

[Jon Skeet [C# MVP]]

Dan Holmes <dh*****@ivsi.comwrote:

Linq and the features necessary to support it get a lot of attention but
i happened to find out about partial methods by chance. Is there a
comprehensive list of new c# stuff somewhere? i couldn't find anything
obvious on the c# page on msdn.

Here we go:

Partial methods
Automatically implemented properties
Implicitly typed local variables
Object initializers
Collection initializers
Implicitly typed arrays
Anonymous types
Extension methods
Lambda expressions and expression trees
Type inference and overloading changes
Query expressions (from x in y where z select foo etc)

<shameless plug>
Find out more details in my book, C# in Depth:
http://manning.com/skeet
</shameless plug>

(Seriously though, if you want more information on any of those, just
let me know.)

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
World class .NET training in the UK: http://iterativetraining.co.uk

[Scott Roberts]

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

Dan Holmes <dh*****@ivsi.comwrote:

>Linq and the features necessary to support it get a lot of attention but
i happened to find out about partial methods by chance. Is there a
comprehensive list of new c# stuff somewhere? i couldn't find anything
obvious on the c# page on msdn.

Here we go:

Partial methods
Automatically implemented properties
Implicitly typed local variables
Object initializers
Collection initializers
Implicitly typed arrays
Anonymous types
Extension methods
Lambda expressions and expression trees
Type inference and overloading changes
Query expressions (from x in y where z select foo etc)

<shameless plug>
Find out more details in my book, C# in Depth:
http://manning.com/skeet
</shameless plug>

(Seriously though, if you want more information on any of those, just
let me know.)

I'd like to know your opinions on those features as they relate to
code-readability and maintainability (i.e. do they help, hurt, or have no
effect).

[Jon Skeet [C# MVP]]

Scott Roberts <sr******@no.spam.here-webworks-software.comwrote:

<snip>

(Seriously though, if you want more information on any of those, just
let me know.)

I'd like to know your opinions on those features as they relate to
code-readability and maintainability (i.e. do they help, hurt,
or have no effect).

When used appropriately, they can help a lot - but only when you
actually *know* the new language features. For example, until you've
learned how query expressions are handled by the compiler, you can
easily make mistakes and the whole thing is somewhat magic. When you
*do* know what's going on behind the scenes, they're a huge boon to
readability, IMO.

I've been thinking a lot recently about two different aspects of
readability: what your code does, and how it does it. Often an increase
in the former aspect means a decrease in the latter. Extension methods
are a good example of that - they allow you to reduce the extra clutter
of specifying where a static method is coming from, but at the cost of
it not being obvious exactly what's going on.

That's okay so long as all the maintainers know how to find out the
"how" when they need to - but it also increases the risk of "cargo cult
programming":

http://blogs.msdn.com/ericlippert/ar...tax-semantics-
micronesian-cults-and-novice-programmers.aspx
A lot of the features of C# 3 could be overused and cause chaos - but
in the right hands they'll contribute a lot to readability, in my view.
I also suspect that a lot of the fear over some of the features
(implicitly typed local variables, for example) stems from a "but it's
never been like that before" viewpoint. I haven't been immune to this -
I initially hated the idea of implicitly typed local variables other
than with respect to anonymous types, but I now welcome them in many
other situations.

One thing I *would* say about C# 3 is that it's been very, very well
thought out. (That's not to say there aren't things I'd change - the
discovery of extension methods being the most obvious one.) The whole
thing hangs together as a set of changes and is very elegant. I've been
fortunate to spend rather a long time poring over specs etc (as part of
the writing process) which has made me think about the language changes
in a deeper way than I would probably have done otherwise.

In short, I really, really like C# 3 :)

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
World class .NET training in the UK: http://iterativetraining.co.uk

[Scott Roberts]

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

I've been thinking a lot recently about two different aspects of
readability: what your code does, and how it does it. Often an increase
in the former aspect means a decrease in the latter. Extension methods
are a good example of that - they allow you to reduce the extra clutter
of specifying where a static method is coming from, but at the cost of
it not being obvious exactly what's going on.

That's okay so long as all the maintainers know how to find out the
"how" when they need to - but it also increases the risk of "cargo cult
programming":

http://blogs.msdn.com/ericlippert/ar...tax-semantics-
micronesian-cults-and-novice-programmers.aspx
A lot of the features of C# 3 could be overused and cause chaos - but
in the right hands they'll contribute a lot to readability, in my view.
I also suspect that a lot of the fear over some of the features
(implicitly typed local variables, for example) stems from a "but it's
never been like that before" viewpoint. I haven't been immune to this -
I initially hated the idea of implicitly typed local variables other
than with respect to anonymous types, but I now welcome them in many
other situations.

I suppose the onus of creating "readable" code always falls to the
individual developer. I just wonder to what extent some language features
invite or encourage "lazy" coding. I'm not an early adopter of new language
features, but I don't think I'm afraid of them either. I am, however, a
little scared when they come with names like "partial methods" (where is the
rest of it?), "Implicitly typed variables" (what's wrong with explicit
types?), and "anonymous types" (you don't want me to know what type it is?).

I'm sure that there is a time and a place for these features, just like
there is probably a time and a place for overloading the "+" operator to
actually perform subtraction in C++. But is it worth it? I suppose that's
not only a subjective and rhetorical question, but one's answer probably
changes over time. I read some C# code today where all of the local
variables were declared (but not initialized) at the top of the routine. I
chuckled, because I used to do that.

[Chris Mullins [MVP - C#]]

"Scott Roberts" <sr******@no.spam.here-webworks-software.comwrote

I'd like to know your opinions on those features as they relate to
code-readability and maintainability (i.e. do they help, hurt, or have no
effect).

I've been very happy with the overall readability improvements in my code
due to C# 3.

- The "intent" of my code has become much more clear. It's very easy to look
at a block of code and tell what that code should be doing. This is a very
positive thing, and is a direct result of many of the new language
features.

- The line-by-line understanding of my code has decreased, I believe. I
blame Lambda functions, and (most recently) custom iterators mixed with LINQ
and LINQ to SQL.

By this I mean, you may look at someone's code that implemented, say, a
QuickSort. You may unsterstand every single line of code, with excellent
clarity. The overall intent of the code though may remain elusive.

With the somewhat abusive way I've been using C# 3 these days, my intent is
typically very, very clear. However, some of the individual lines of code
are very difficult to understand. This is especially true of the reader
doesn't know C# 3.

Now I just need to start adding in some addition complexity:
yield return myFile.BeginWrite( Parallel.For(myBuffer,
d=>SomeOperation(d)), myBuffer.Count(d=>d.Value % 2 == 0), this, null));

(I'm kidding I'm kidding. I would never write code like that. Except on a
Friday afternoon.)
--
Chris Mullins

[Scott Roberts]

"Chris Mullins [MVP - C#]" <cm******@yahoo.comwrote in message
news:en**************@TK2MSFTNGP02.phx.gbl...

Now I just need to start adding in some addition complexity:
yield return myFile.BeginWrite( Parallel.For(myBuffer,
d=>SomeOperation(d)), myBuffer.Count(d=>d.Value % 2 == 0), this, null));

(I'm kidding I'm kidding. I would never write code like that. Except on a
Friday afternoon.)

I think that's why I'm gun-shy. I read macro-compiled Clipper code on a
somewhat frequent basis and it looks just like that!!