Search results for 'app:weblogs' matching tag '.NET 4.0'

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.

Improvements in Entity Framework 4.0

NunoGodinho — Thu, 06 Aug 2009 05:00:00 GMT

With .NET 4.0 a lot of new features and technologies will see the light, as long as others will get improved, and Entity Framework will be one of those technologies that will get improved.

A lot of this changes are being made on the Query pipeline, that means that are being done on the translation from Linq to SQL code, and some of the changes in Beta 1 are the following:

Avoid projecting all columns in nested queries

Instead of making a query for the complete set of columns and the make the projection on top of it, just make the projection and get only the needed columns

Avoiding Unnecessary IS NULL Checks in LINQ to Entities Queries

remove the Is null check when using Joins

Additional join elimination: Eliminate parent table in “Child Left Outer Join Parent”

Avoid having a child left outer join if no column from that relation is needed for the projection

Using IN instead of nested OR’s

Instead of having several Or’s in place such as “CategoryId = 1 OR CategoryID = 2 (…)” have “CategoryId In (1,2,…)”

Translating more of LINQ’s GroupBy operator into GROUP BY

Better use of the SQL Group By in order to simplify the query

Avoiding “Cast (1 as bit)”, using “1” instead
Simplifying some queries that go against a subtype in a type hierarchy

Some of the changes after Beta 1:

Elimination of null sentinels

In the output query there is often the constant 1 projected both in nested and in top-most queries. By avoiding it and reusing other columns for the same purpose in many cases we are able to avoid levels of nesting.

Additional Join Elimination
Use of Inner Joins instead of Left Outer Joins when possible
Provide mechanism for efficient queries on non-Unicode columns

We now generate non-unicode constants and parameters when these are used in LINQ to Entities queries in comparisons with non-unicode columns. This allows indexes to be used by SQL Server.

Improve the translation of the functions String.StartsWith, String.Contains and String.EndsWith in LINQ to Entites to use LIKE.
Improve the translation of the canonical functions StartsWith, Contains and EndsWith to use LIKE (these canonical functions became available in .NET 4.0 Beta1)
Collapse multiple Case statements into one

You can read more about this topic on this ADO.NET Team post.

Data Services – Can be ADO.NET or SQL – What’s the difference

NunoGodinho — Tue, 07 Jul 2009 05:00:00 GMT

Just a while ago I was talking about Data Services and suddenly a confusion between ADO.NET Data Services and SQL Data Services took place, because we were talking about different Data Services, and so in order to try to clarify the differences I remembered to write this post.

There are two types of Data Services that are:

SQL Data Services

Cloud – at this moment is being converted from ACE (Activity, Container and Entity) to TDS (Tabular Data Stream) as I’ve presented in this post.
In this case we are talking about a Database in the Cloud and the ultimate desire will be to just change the ConnectionString used.

ADO.NET Data Services aka. “Project Astoria”

This one is about making available a set of REST Services on top of ADO.NET

Highly Extensible:

Query Filtering (GET requests)
Operation Filtering (PUT, POST, DELETE, etc requests)
Making other Operations available with the same capabilities as the ones associated with ADO.NET Data Services.

Filter
Sort
Group
Take
Skip
and so on.

This layer can be placed on top of:

Entity Framework
Linq-to-SQL
Custom CLR Objects

Where to know more:

Overview: http://msdn.microsoft.com/en-us/library/cc956153.aspx
Sample: http://msdn.microsoft.com/en-us/magazine/cc748663.aspx

Offline Version:

Hope it helps you get the confusions out of discussions on this topic.

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);
            }

[VSTS 2010] Disponible para Descarga el Beta 1 de VSTS y .Net Framework 4.0

ffagas — Fri, 22 May 2009 05:00:00 GMT

Ahora ya pueden descargar el Beta 1 de Visual Studio Team System el cual brinda un sin número de nuevas características las cuales pueden revisar en el siguiente blog (http://blogs.msdn.com/jasonz/archive/2009/05/18/announcing-vs2010-net-framework-4-0-beta-1.aspx), así como el .Net Framework 4.0 Beta 1. A continuación la lista de herramientas disponibles para descargar con su respectivo enlace.

.NET Framework

Microsoft .NET Framework 4.0 Beta 1

Microsoft .NET Framework 4.0 Client Profile Beta 1

Documentación

Visual Studio 2010 Beta 1

.NET Framework 4 Beta 1

Herramientas:

Professional

Visual Studio 2010 Professional Beta 1 – Web Installer

Visual Studio 2010 Professional Beta 1 – ISO

Team System

Visual Studio Team System 2010 Team Suite Beta 1 – Web Installer

Visual Studio Team System 2010 Team Suite Beta 1 - ISO

Visual Studio Team System 2010 Test Load Agent Beta 1

Visual Studio Team System 2010 Team Foundation Server Beta 1

Microsoft Visual Studio Lab Management 2010 Beta 1

Visual Studio Team System 2010 Lab Agent Beta 1

Herramientas adicionales

Microsoft Visual Studio 2010 Remote Debugger (Beta 1)

Visual Studio 2010 Shell (Integrated) Beta 1 Redistributable Package

Visual Studio 2010 Shell (Isolated) Beta 1 Redistributable Package

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.