Search results for 'app:weblogs' matching tag 'Visual Studio 2010'

Visual Studio 2010 Beta 2 available for MSDN subscribers

BrianMadsen — Tue, 20 Oct 2009 05:00:00 GMT

Visual Studio 2010 Beta 2 – probably the most anticipated release of the VS family – has just hit a milestone. It’s reached the MSDN subscription downloads!

VS2010 Beta 2 available to MSDN
http://blogs.msdn.com/bharry/archive/2009/10/19/vs-2010-beta-2-is-now-available-for-msdn-subscriber-download.aspx

VS2010 Licensing Changes
http://blogs.msdn.com/bharry/archive/2009/10/19/vs-2010-licensing-changes.aspx

4 new SKUs, Express, Professional, Premium, Ultimate

What’s new in VS2010 and Learning about VS2010
http://blogs.msdn.com/bharry/archive/2009/10/19/learning-about-vs-2010-beta-2.aspx

TFS 2010 Compatibility with older clients
http://blogs.msdn.com/bharry/archive/2009/10/19/tfs-2010-compatibility-with-older-clients.aspx

Update:

Visual Studio 2010 Beta 2 will be available to the public on the 21st of October, 2009 (for those not endowed with a MSDN subscription)

Visual Studio 2010 Beta 2 released

Joacim — Tue, 20 Oct 2009 05:00:00 GMT

Yesterday Microsoft had a big announcement day. At the same time as Steve Ballmer held his keynotes at the SharePoint Developers Conference (see the video) Microsoft released Visual Studio 2010 Beta 2 for MSDN subscribers, the public release will be tomorrow, October 21st. They also announced that the official release date of Visual Studio 2010 and the .Net 4.0 Framework will be on March 22nd, 2010.

Visual Studio has been given a new blue-purple logo and at the same time the MSDN web site has also been given a face lift using this blue-purple color scheme. If you have visited the Visual Basic Developer Center recently you may have already seen the preview of the new MSDN look. In my opinion it’s much nicer compared to the old red color scheme it had before.

With the beta release Microsoft also released Visual Studio 2010 Tools for SharePoint.

Microsoft have compiled a lot of 2010 resources on the VB and C# Developer Centers: VB 2010 Resources, C# 2010 Resources. They have also released a number of How do I videos. Note, the first two links will be available very soon, if they aren’t already.

How Do I: Use auto-implemented properties?
How Do I: Use implicit line continuations in VB 10?
How Do I: Use highlight reference in the Visual Studio 2010 IDE?
How Do I: Use Code Snippets in the Visual Studio IDE?
How Do I: Use Generate from Usage in Visual Studio 2010?
How Do I: Enhance performance in the Visual Studio 2010 IDE when editing VB code?
How Do I: Step with the debugger in Visual Studio?
How Do I: Refactor my code in Visual Studio (Part 1 and Part 2)

I have looked forward to this beta release for a long time now, even though I have used Beta 1 since it was released back in May, beta 2 is much more promising simply because everything should be in place by now. Microsoft will probably not add any new features but rather just fix any bugs that are reported and concentrate on performance issues. So I can now start doing some real world testing and finally concentrate on to fully learn the new features of the framework. This of course also means that you can expect to see a lot more posts about VS2010 on this blog in the near future.

Have fun, I know I will. :)

New Features in Visual Studio 2010

NunoGodinho — Mon, 07 Sep 2009 05:00:00 GMT

Visual Studio 2010 is approaching rapidly from the launch and with it a new set of features will also appear.

One that I think is very important is the Architectural Tools that come with this new version, and elements like:

Dependency Graph
- Filters using Direct Graph Markup Language (DGML) on top of the generated graph.
- Views as:
  - Dependency Matrix
  - Forced Direct Layout
  - Top to Bottom Layout

Sequence Diagrams
- Available on the Code Editor

Unified Modeling Language (UML)
- Usage of UML to define the project

Use Cases (UC)
- Creation of Use Cases
- Integration with TFS, since we can select an element in the use case and build, link or View the associated Work Items.

Layer Designer and Layer Validation
- Possibility do build the Architecture of the solution and associate some validation elements that will always be enforced during the development process.

To know more about this subject read this S.Somasegar post.

Another very important features are the Debugging and Profiling.

Debugging
- Built in Debugger for MPI programs. Now with the new VS2010 we can select a cluster head node, how many cores you want, and hit F5 to debug your MPI program.
- SOA Debugging
  - Up until now, debugging Cluster SOA was limited to basic WCF/.Net style debugging with no cluster integration.
  - In Visual Studio 2010, an add-in for Cluster SOA enables the SOA Settings tab, allowing you to choose a head node, debug nodes and services, deploy runtime libraries and clean up automatically.

Profiling
- VS Profiler can offer insight into performance issues
- Shows a comparison report across multiple runs or builds so you can easily see the effect of your changes.

To know more about this subject read this S. Somasegar post.

Interesting reading about Entity Framework 4.0

NunoGodinho — Mon, 06 Jul 2009 05:00:00 GMT

Entity Framework has suffered great changes and in order to know more about them I recommend the following reading:

POCO (Plain Old CLR Object or Persistence ) in the Entity Framework 4.0

Sneak Preview: Persistence Ignorance and POCO in Entity Framework 4.0
POCO in the Entity Framework:

“Why is POCO important in Entity Framework? Is important because now we have the ability to really separate the Storage Model from the Conceptual Model, and being the Conceptual Model our normal CLR Objects, that was not possible in previous versions of Entity Framework. This is a huge breakthrough for this 4.0 version. Is not perfect, and in this technologies it never is but it’s very interesting”

Part 1 - The Experience (Explains how to make this two parts of the POCO experience with Entity Framework 4.0, from making the Model to the designing of the POCO entities, as well as answering some interesting questions)
Part 2 – Complex Types, Deferred Loading and Explicit Loading (Goes further in the POCO entities and make changes shows how to implement Complex Types as well as configuring the Loading by using Deferred/Lazy Loading or Explicit Loading)
Part 3 – Change Tracking with POCO (Explains furthermore how the Change Tracking, that is so important in Entity Framework, works in POCO entities and how can it be configured by using Metadata)

Using Repository and Unit of Work patterns with Entity Framework 4.0 (Explains how to implement common patterns like Repository and Unit of Work using Entity Framework 4.0)
Entity Framework Feature CTP 1 (Announcement of the Entity Framework CTP Features for .NET 4.0 Beta 1)

Feature CTP Walkthrough: Self Tracking Entities for Entity Framework (Explains the scenarios on where to use the Self Tracking Entities)
Feature CTP Walkthrough: POCO Templates for Entity Framework (Explains how to use POCO Templates, that is a kind of T4 Template in order to generate POCO entities)
Feature CTP Walkthrough: Code Only for Entity Framework (Explains how to Entity Framework without any model like EDMX, just code)

I hope you enjoy the reading.

Microsoft Releases Roadmap

NunoGodinho — Wed, 03 Jun 2009 05:00:00 GMT

A lot is being announced this days regarding Microsoft Products and Technologies, and so this is a little summary of all those information's.

Exploiting covariance with LINQ to XML

MartinH — Mon, 01 Jun 2009 05:00:00 GMT

In my last post I showed how the new contravariance feature in .NET 4.0/Visual Studio 2010 for type parameters of generic interfaces makes coding with LINQ to XML easier and more straightforward. In this post I will show how the covariance of the type parameter T of IEnumerable<T> also allows us to write LINQ to XML queries in a more straightforward way.

Let's assume we have the following XML document:

<?xml version="1.0" encoding="utf-8" ?>
<root>
  <!-- comment 1 -->
  <foo>foo 1</foo>
  <bar>bar 1</bar>
  <!-- comment 2 -->
  <foo>foo 2</foo>
  <bar>2</bar>
  <!-- comment 3 -->
</root>

and we want to transform that document into a second one with the same root element having the same child nodes, except where all 'bar' child elements of the 'root' element node have been removed. So the result should look as follows:

<?xml version="1.0" encoding="utf-8" ?>
<root>
  <!-- comment 1 -->
  <foo>foo 1</foo>
  <!-- comment 2 -->
  <foo>foo 2</foo>
  <!-- comment 3 -->
</root>

A first attempt to achieve that with LINQ to XML could look as follows:

            XDocument doc1 = XDocument.Load(@"XMLFile1.xml");

            XDocument doc2 =
                new XDocument(
                    new XElement(doc1.Root.Name,
                        doc1
                        .Root
                        .Nodes()
                        .Except(
                            doc1
                            .Root
                            .Elements("bar"))));

            doc2.Save(Console.Out);

So we create a new XDocument with a new root XElement having the same name as the Root of the first XDocument where all child nodes except of the 'bar' child elements are copied.

Looks nice and straightforward only if you try to compile that with Visual Studio 2008/.NET 3.5 you get the following error: "Argument '2': cannot convert from 'System.Collections.Generic.IEnumerable<System.Xml.Linq.XElement>' to 'System.Collections.Generic.IEnumerable<System.Xml.Linq.XNode>'".

The problem is that the Nodes() call returns an IEnumerable<XNode> and then the following Except() call also needs an IEnumerable<XNode> as its argument while Elements("bar") gives us an IEnumerable<XElement>. With generic interfaces being invariant in .NET 3.5 we can't pass that IEnumerable<XElement> in for an IEnumerable<XNode>, although XElement is a class derived from XNode.

As a workaround we can first cast the IEnumerable<XElement> to an IEnumerable<XNode>:

            XDocument doc1 = XDocument.Load(@"XMLFile1.xml");

            XDocument doc2 =
                new XDocument(
                    new XElement(doc1.Root.Name,
                        doc1
                        .Root
                        .Nodes()
                        .Except(
                            doc1
                            .Root
                            .Elements("bar")
                            .Cast<XNode>())));

            doc2.Save(Console.Out);

That way it compiles fine and produces the wanted result with .NET 3.5, only it seems desirable that you would not need that Cast<XNode>() call.

The good news is that starting with .NET 4.0 the type parameter T of IEnumerable<T> is covariant meaning where an IEnumerable<T> of a certain type T is expected we can always pass in an IEnumerable<T2> where T2 is type derived from T, as in our example where XElement is a subclass of XNode (or subsubclass to be precise).

Thus with .NET 4.0 the following compiles and works fine:

            XDocument doc1 = XDocument.Load(@"XMLFile1.xml");

            XDocument doc2 =
                new XDocument(
                    new XElement(doc1.Root.Name,
                        doc1
                        .Root
                        .Nodes()
                        .Except(
                            doc1
                            .Root
                            .Elements("bar"))));

            doc2.Save(Console.Out);

Exploiting contravariance with LINQ to XML

MartinH — Sun, 31 May 2009 05:00:00 GMT

Covariance and contravariance for generic interfaces are new features in C# and VB.NET in Visual Studio 2010 respectively the .NET framework 4.0. Generic interfaces like IEnumerable<T> or IEqualityComparer<T> in the .NET framework 4.0 use these new features. Starting with .NET 4.0 the type parameter T in IEqualityComparer<T> is contravariant. That can make coding with LINQ to XML easier, as the class XNodeEqualityComparer implements IEqualityComparer<XNode> where XNode is a common base class for other LINQ to XML classes like XElement.

Let's look at an example. Assume we have the following XML document

<?xml version="1.0" encoding="utf-8" ?>
<root>
  <items>
    <item>
      <foo>a</foo>
      <bar>1</bar>
    </item>
    <item>
      <foo>b</foo>
      <bar>2</bar>
    </item>
    <item>
      <foo>a</foo>
      <bar>1</bar>
    </item>
    <item>
      <foo>c</foo>
      <bar>3</bar>
    </item>
    <item>
      <foo>c</foo>
      <bar>3</bar>
    </item>
  </items>
</root>

and we want to use LINQ to XML to extract distinct items where we use XNodeEqualityComparer to compare the 'item' elements in the XML document.

You could be tempted to try it as follows:

            XDocument doc = XDocument.Load("XMLFile1.xml");

            var distinctItems =
                doc
                .Root
                .Element("items")
                .Elements("item")
                .Distinct(new XNodeEqualityComparer())
                .Select(i => new { foo = (string)i.Element("foo"), bar = (int)i.Element("bar") });

            foreach (var item in distinctItems)
            {
                Console.WriteLine(item);
            }

but with .NET 3.5 that does not compile, complaining "Instance argument: cannot convert from 'System.Collections.Generic.IEnumerable<System.Xml.Linq.XElement>' to 'System.Collections.Generic.IEnumerable<System.Xml.Linq.XNode>'" on the Distinct(new XNodeEqualityComparer()) call. That happens because Elements("item") gives us an IEnumerable<XElement> and subsequently the Distinct method wants an IEqualityComparer<XElement> to be passed in while we only pass in an IEqualityComparer<XNode>.

With .NET 3.5 to work around that problem we first have to cast IEnumerable<XElement> up to IEnumerable<XNode> before we call Distinct(new XNodeEqualityComparer()) and then down again after the Distinct() call:

            XDocument doc = XDocument.Load("XMLFile1.xml");

            var distinctItems =
                doc
                .Root
                .Element("items")
                .Elements("item")
                .Cast<XNode>()
                .Distinct(new XNodeEqualityComparer())
                .Cast<XElement>()
                .Select(i => new { foo = (string)i.Element("foo"), bar = (int)i.Element("bar") });

            foreach (var item in distinctItems)
            {
                Console.WriteLine(item);
            }

That compiles fine and nicely returns only distinct items:

{ foo = a, bar = 1 }
{ foo = b, bar = 2 }
{ foo = c, bar = 3 }

With .NET 4.0 however the type parameter T of IEqualityComparer is contravariant meaning if we have a method expecting an IEqualityComparer<XElement> it suffices to use a base type of XElement like XNode and thus with .NET 4.0 our original attempt compiles and runs fine:

            XDocument doc = XDocument.Load("XMLFile1.xml");

            var distinctItems =
                doc
                .Root
                .Element("items")
                .Elements("item")
                .Distinct(new XNodeEqualityComparer())
                .Select(i => new { foo = (string)i.Element("foo"), bar = (int)i.Element("bar") });

            foreach (var item in distinctItems)
            {
                Console.WriteLine(item);
            }

What is new in System.Xml in .NET 4.0/Visual Studio 2010

MartinH — Thu, 21 May 2009 05:00:00 GMT

Beta 1 of the .NET framework 4.0 and of Visual Studio 2010 has been released a few days ago. Although the "What's new" document does not list any new features in System.Xml or LINQ to XML I am browsing through the documentation to find new features or changes in APIs.

So far I have found the following:

With LINQ to XML the SaveOptions enumeration has a new flag named OmitDuplicateNamespaces. That is particularly useful with VB.NET XML literals as using them you might end up with more namespace declaration attributes as you want resulting in superfluous namespace declarations on child or descendant elements when you save/serialize a LINQ to XML XDocument or XElement.

Here is an example in VB.NET with .NET 3.5:

Imports System
Imports System.Xml.Linq
Imports <xmlns="http://www.w3.org/1999/xhtml">

Module Module1

    Sub Main()
        Dim html As XElement = _
        <html>
            <head>
                <title>Example</title>
            </head>
            <body>
            </body>
        </html>

        html.<body>(0).Add(GetParagraphs())

        html.Save(Console.Out)

    End Sub

    Function GetParagraphs() As IEnumerable(Of XElement)
        Dim ps() As String = {"Paragraph 1.", "Paragraph 2."}
        Return (From p In ps Select <p><%= p %></p>)
    End Function

End Module

Its output is as follows:

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <title>Example</title>
  </head>
  <body>
    <p xmlns="http://www.w3.org/1999/xhtml">Paragraph 1.</p>
    <p xmlns="http://www.w3.org/1999/xhtml">Paragraph 2.</p>
  </body>
</html>

As you can see, the namespace declarations on the 'p' elements are redundant as the namespace is already defined on the 'html' root element.

With .NET 4.0 and the SaveOptions.OmitDuplicateNamespaces flag you can avoid them as follows:

Imports System
Imports System.Xml.Linq
Imports <xmlns="http://www.w3.org/1999/xhtml">

Module Module1

    Sub Main()
        Dim html As XElement = _
        <html>
            <head>
                <title>Example</title>
            </head>
            <body>
            </body>
        </html>

        html.<body>(0).Add(GetParagraphs())


        html.Save(Console.Out, SaveOptions.OmitDuplicateNamespaces)

    End Sub

    Function GetParagraphs() As IEnumerable(Of XElement)
        Dim ps() As String = {"Paragraph 1.", "Paragraph 2."}
        Return (From p In ps Select <p><%= p %></p>)
    End Function

End Module

Now the output is fine:

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <title>Example</title>
  </head>
  <body>
    <p>Paragraph 1.</p>
    <p>Paragraph 2.</p>
  </body>
</html>

Have you ever wondered why an XDocument or XElement in .NET 3.5 could be saved to a TextWriter or a file or an XmlWriter but not directly to a Stream? In .NET 3.5 you need to construct an XmlWriter or TextWriter over a Stream but now in .NET 4.0 you can save directly to a Stream: XDocument.Save(Stream), XElement.Save(Stream). No functionality gain but a convenient addition, for instance when you want to send the serialization of an XDocument or XElement to the request stream of an HttpWebRequest. There are also corresponding Load methods taking a Stream as the input, XDocument.Load(Stream), XElement.Load(Stream).

There is also a new enumeration ReaderOptions in System.Xml.Linq but so far I have not found any method or property using that enumeration.

XmlReaderSettings has a new property DtdProcessing that replaces the now obsolete ProhibitDtd property. With the boolean property ProhibitDtd you could choose to either allow DTD parsing/processing or to prohibit it. With the new DtdProcessing property you have now three choices, prohibit, parse, or ignore. Ignore could give you performance benefits over parse. for instance the following parses the W3C home page twice, once ignoring the DTD, once parsing/processing it:

            Stopwatch watch = new Stopwatch();
            XmlReaderSettings settings = new XmlReaderSettings();
            settings.DtdProcessing = DtdProcessing.Ignore;
            watch.Start();
            using (XmlReader reader = XmlReader.Create(@"http://www.w3.org/", settings))
            {
                while (reader.Read())
                {
                }
            }
            watch.Stop();
            Console.WriteLine("DtdProcessing.Ignore: Elapsed time: {0}", watch.Elapsed);

            settings.DtdProcessing = DtdProcessing.Parse;
            watch.Start();
            using (XmlReader reader = XmlReader.Create(@"http://www.w3.org/", settings))
            {
                while (reader.Read())
                {
                }
            }
            watch.Stop();
            Console.WriteLine("DtdProcessing.Parse: Elapsed time: {0}", watch.Elapsed);

The output for me here is

DtdProcessing.Ignore: Elapsed time: 00:00:01.5245222
DtdProcessing.Parse: Elapsed time: 00:00:09.1677892

so ignoring the DTD is about nine times faster for that sample document. On the other hand if the DTD defines any entities that are then referenced in the XML document ignoring the DTD would give you an exception:

            XmlReaderSettings settings = new XmlReaderSettings();
            settings.DtdProcessing = DtdProcessing.Ignore;

            string xhtml = @"<!DOCTYPE html 
     PUBLIC ""-//W3C//DTD XHTML 1.0 Strict//EN""
     ""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"">
<html xml:lang=""en"">
<head>
<title>Example</title>
</head>
<body>
<p>Price is: 100 &euro;</p>
</body>
</html>";
            using (XmlReader reader = XmlReader.Create(new StringReader(xhtml), settings))
            {
                while (reader.Read()) { }
            }

throws the exception "Reference to undeclared entity 'euro'".

That's all I have found so far, I will edit this post when I find more.

[edit 2009-05-26] I have now found a page "What's new in System.Xml" in the .NET framework 4 Beta 1 documentation. Oddly enough it lists LINQ to XML and the XSLT compiler as new features although both were introduced in .NET 3.5. It also mentions new methods in the XmlConvert class.

Visual Studio 2010 and .NET Framework 4.0 Beta 1 Just Released

NunoGodinho — Wed, 20 May 2009 05:00:00 GMT

The Beta 1 release of Visual Studio 2010, .NET Framework and Visual Studio Team Foundation Server Beta 1 was release on the last 18th of May, just last Monday, this for MSDN Subscribers and today for Non-MSDN Subscribers, and it will bring great enhancements in several levels. You can install it Side-By-Side with your existing Visual Studio Edition and try it, but don’t forget to read the ReadMe file for both Visual Studio 2010 and .NET Framework 4.0 in order to know what to expect. I still think that is better to test this version on a Virtual Machine, but you can choose what to do.

A quick look at some of the Enhancements:

.NET Framework 4.0
- Main Technologies
  - WPF 4.0
  - WCF 4.0
  - WF 4.0
  - ASP.NET 4.0
  - ASP.NET AJAX 4.0
  - Entity Framework 2.0
  - Data Services 2.0
  - Project "Velocity"
- Managed Languages
  - VB
    - Implicit Line Continuation
    - Multi-line Lambdas
    - Statement Lambdas
    - Auto Properties
  - C#
    - Named Parameters
    - Optional Parameters
  - F#
- Other Elements
  - Parallel Linq
  - Managed Extensibility Framework
  - DLR Built-In
  - No need for PIAs – New way to Interoperate
  - Generic Covarience
  - Generic Contravariance
  - CLR running In-Proc Side-by-Side
  - Code Contracts
  - Background GC

Visual Studio 2010
- WPF-Based Editor
- New Look & Feel
- Improved WPF Tooling
- MVC Tooling
- Dynamic Data Tooling
- Sharepoint Tooling
- Click-Once Enhancements for Office
- Html Snippets
- Web Deploy
- Breakpoint Grouping
- Parallel Tasks Window
- Highlight References
- Call Hierarchy
- Historical Debugging
- Inline Call Tree
- Quick Search
- JQuery Intellisense
- Concurrency Profiler
- Breakpoint Import/Export
- Document Map Margin
- Parallel Stacks Window
- Improved Multi-Monitor

Be in touch for more information regarding this release and other releases and don’t forget to see Channel 9 and the related Visual Studio 2010 Videos and also .NET Framework 4.0.

Also check the Visual Studio 2010 Training Kit May Preview 2009 that is also available for download.

More 10-4

keith — Mon, 04 May 2009 05:00:00 GMT

Episode 2 of “10-4” (Dec 24th – Jason Olson)

Key feature shown – The customized start page. I like the carry over from office of pining down a document. In this case the pining of a project. I know this sounds small, but how many times have you been working on your core project, to interupt it with some proof of concept projects? I find that I then have to either expand the number of projects in my file menu or navigate to the project files again. This will allow me to keep my official work always at the top.

Jason then demonstrated the extensibility of the Start Page. There are some options here like the folder lists and changing the background, etc. However, in my training, I have found very few people who took advantage of any Start Page customization in the last two versions of VS.

I tried out the customizations myself through the walkthroughs that Brian Keller talked about in Episode 1 (see prior post). While Jason showed us how to make changes by using notepad, I loaded up the csproj file into Visual Studio and used the WPF designer. The first load of the xaml looked very odd. After closing the xaml and reopening, it looked great.

Rather than deleting or commenting the code for the button referenced in the walkthrough, the Walkthrough button’s visibility was set to “Hidden” in the properties window.

In order to add a new item to the TrayGroup, I clicked on the group and expanded the Items property.

I was surprised to see that I could not “Add” a new TrayGroupItem through the dialog box.

Therefore I used the XAML tab under the designer to add the new item manually.

Moving to the next part of adding content, be sure in step 5 to read the note. I love in training when an attendee asks a question about a bug in their lab work. I ask them to read the next sentence which asks them to observe the bug which was just created. The standard response is “Ooohh.” Additionally, I created a new TabGroup to host any RSS Feeds I might want to track. I inserted the following code at the end after the “Visual Studio” TrayItem.

<vs:TrayItem Header="RSS Feeds" x:Uid="RSS_Header">
            <vs:TrayGroup>

                <vs:TrayGroupItem Content="Soma's blog"
                                  ImageSource="c:\Users\Public\Documents\CTPWalkthroughs\Visual Studio\Samples\Start Page\soma.png"
                                  InnerContentUri="SomaBlog;Component/UserControl1.xaml" />
            </vs:TrayGroup>
        </vs:TrayItem>

    </vs:Tray>
</Grid>

Here were my results:

It looks pretty good except for one part. Visibility with WPF does not mean to ignore the element and have other elements slide into its place. By changing the property to “Collapsed” the image disappears and there is no need for the scroll bar to be used this time. Feedback looks better when it is not cut off.

Overall, this was a pretty easy approach at adding items, using code to extend the IDE, and now for me to add several other blogs to my environment.

Episode 3 of “10-4” (Dec 31st – Jonathan Carter)

Two items out of this episode I liked hearing. Jonathan firmly states that WebForms is still a major player in VS. This version adds a lot of strength and new features to the model we have been using for the last six years. Why would this be questioned? Well VMC seems to be a fan favorite right now and there is a very vocal camp that assumes this is the only way to create content now. I’m not an extremist myself, so I like to know how a proven tech is improved.

The second item proves my closing sentence in the prior paragraph: ClientID! Working with dynamically created items through code has been a hassle for me since the framework 1.1. I spent a lot of time in 2003-2004 writing code with Regular Expressions to help me navigate through shopping carts and such. Microsoft has provided some really great approaches to this. I’m very hopeful for this feature in making your lives easier. Be sure to watch this one.