I'll toss another one into the mix. I've personally become a HUGE fan of the null coalesce operator [0] introduced in C# 2.0. I used to LOVE the ternary operator, but now, the null coalesce operator does what I always *wanted* to be able to do with the ternary operator. VERY cool.

[0]: http://bob.yexley.net/archive/2006/07/31/Nullable-types-and-the-new-_3F003F00_-operator-in-C_2300_-2.0.aspx

The features I end up using the most are definately the ones you mentioned.  I have used iterators as well.  They are particularly useful if you have a tree structure and you need to iterate over all the nodes.  Using iterators, it is surprisingly easy to write this, and without using recursion either.  

For ASP.NET projects I have found myself using the new GridView most.  In the WinForms arena, the new layout panels are particularly useful and so is the BackgroundWorker.

There are lots of littel things that I love as well, such as string.IsNullOrEmpty and int.TryParse.

In addition to Master Pages, I use the ASP.NET Membership and Role Management, SQL Output Caching Support, CSS Control Adapters, GridView control, and Menu system.  These save me dozens of hours a project.

The Array class has several static methods that work similar to the List<T> class for arrays.

One of the new features i have enjoyed is Nullable types, but they did a really, really bad job of implementing them in the winforms UI stuff.

As for iterators, I have found a use for them, and they have made life easier for other developers on my team.

Jeff - I actually prefer having flexible control adapters versus having HTML hard-coded into controls.  For our teams we've built serveral common class libraries that encapsulate output markup (using control adapters together with CSS stylesheets that we had a designer build for us), navigation layout that integrates with a CMS library we build, and security architecture.  

When we start a new project, we simply add references to these common libraries and we are pretty far on our way with the application.  Being able to encapsulate and test these separately and re-use them across multiple solutions is really useful for us.

Apart from the most popular things that have already been mentioned (generics, nullable types, iterators, String.IsNullOrEmpty and TryParse family of methods) I have found new XmlReader features particularly useful. Methods like XmlReader.ReadContentAsInt make XML parsing a charm.

Hi Jeff,

Heres my list of "being used" .NET 2.0 features:

- Tracing in System.Net

 System.Net libraries have been instrumented via Trace output.

 http://www.leastprivilege.com/TracingSystemNet.aspx

- Automatic Proxy Detection

 http://msdn.microsoft.com/msdnmag/issues/05/08/AutomaticProxyDetection/default.aspx

- ASP.NET 2.0 Deployment Mode

 If set in the machine.config file, instructs ASP.NET to disregard debug="true" etc settings in web.config files.

  <system.web>

    <deployment retail=”true”/>

  </system.web>

- Generation of Serialization Assemblies at Design Time

 XML Serializer Generator Tool (Sgen.exe)

 http://msdn2.microsoft.com/en-us/library/bk3w6240.aspx

- Version Tolerant Serialization between .NET 1.1/.NET 2.0

 Useful for upgrade strategy from .NET 1.1 to .NET 2.0.

 http://blogs.msdn.com/eugeneos/archive/2006/03/15/552315.aspx

- SynchronizationContexts

 Execute behaviour in the UI context

 http://blogs.msdn.com/mattdotson/archive/2006/02/13/531315.aspx

Whilst I don't have an immediate list of unused .NET 2.0 features, heres a list of behavioral changes to watch out for:

- try{}catch{} Behaves Differently for Unmanaged Exceptions

 Unamanaged exceptions are now wrapped in a RuntimeWrappedException instance.

 http://davidbetz.net/winfx/2005/12/trycatch-in-net-20-part-2.aspx

- Non-UI Threads Raise Unhandled Exceptions by Default

 .NET 1.0/.NET 1.1 behaviour can be restored using the <legacyUnhandledExceptionPolicy> element:

 http://msdn2.microsoft.com/en-us/library/ms228965.aspx

- Assembly Loading Failures are Cached

 For a further explanation:

 http://blogs.msdn.com/junfeng/archive/2004/07/22/190813.aspx

 .NET 1.0/.NET 1.1 behaviour can be restored using the <disableCachingBindingFailures> element:

 http://blogs.msdn.com/junfeng/archive/2006/03/13/550877.aspx

Cheers,

Matt

Jeff,

My used versus unused list is almost exactly like yours,  except for anonymous delegates (which I will use very soon) and I am using the web project model.

Oh, and Object Data Sources, I'm using these too along with the Grid View class.  Okay, now I'm starting to sound like one of the bloggers in my cartoon :)

http://devlicio.us/photos/brendan/images/15/original.aspx

The one thing I think you're hitting on is that while some of the stuff is very useful, some other stuff probably would have been better left out.

Ha!  I just thought it was a zeitgeist thing.. Cool!

Oh, and I couldn't agree more about just making controls render css-stylable markup. That's the real solution... just give us some stylable html, and we'll take it from there.

One small thing I discovered this weekend while working on some 1.1 code is that I like being able to declare a class static.

Another feature I've used is declaring different visibility on getters and setters.

Almost all of my 2005 experience, thus far, as been at polar ends--console apps for automation and AD tasks and web applications.

A note, I was a slow adopter of .NET and only used 1.1 for developing in CMS and SharePoint; 2.0 is my first real experience with enterprise application development and I'm glad I finally made the switch. ;)

My likes:

Master Pages, already mentioned.  The amount of time saved for things I was already doing with includes in the legacy ASP days.

Better exception handling using try/catch/finally as well as custom redirection via web.config for error types.

More acceptance from vendors.  Much of my database backend work is on Oracle; the new Oracle tools go a long ways from the ODBC tools in legacy ASP and 1.1.

Code snippets and the manager.  Most all of my common tasks now have their own snippets.

GridView & imageButtons.  These are the two new controls I tend to use the most.  The flexibility of Gridviews continue to amaze me on some projects--given the amount of time available to dink.

Things I don't use:

Themes.  Style sheets for everything.  I've messed around with theming a bit, but cannot see much use for it.  *shrug*

SiteMaps.  Why?  Modifying the XML file required for SiteMaps seems more of a hassle than creating a custom control and storing the information in a database table.

Other controls such as the Wizard, AdRotator, Menu, TreeView, SiteMapPath & Calendar.

Now, things I'd like to learn more about, but just haven't had time.

Authentication and Roles.  Almost everything I do is AD-integrated, so I rarely use Roles (using Group memberships in AD).  I hope to have time to sit down and learn the advantages of Role/form-based authentication in 2.0 as the controls look pretty straight-forward.

One of my favorite 2.0 features (besides generics) are iterators. Makes encapsulating data access calls super sweet...

public IEnumerable<Document> SearchDocuments()

{

using (SqlConnection connection = new SqlConnection(ConnectionString))

using (SqlCommand command = new SqlCommand(CommandText, connection))

{

command.Parameters.AddWithValue("@drawingNumber", drawingNumber);

connection.Open();

using (SqlDataReader reader = command.ExecuteReader())

while (reader.Read())

yield return BuildResult(reader);

}

}

Results are streamed and all the IDisposable objects get cleaned up nicely. BuildResult converts an IDataRecord into a DTO. Calling code has no clue about databases. Sweet.

Jim,

Could you elaborate a little on the code in the post above and maybe provide some skeleton code for BuildResult(). This is an interesting approach that I'm not familiar with. Thanks.

Jim,

I'd like to see some code too.  Thanks.