using (XmlReader reader = XmlReader.Create(directoryTemp + fichero))
{
 reader.MoveToContent();

 int count = 0; // una variable contador XElement nombretabla = null; // un XElement auxiliar

 while (!reader.EOF)
 {
 switch (reader.NodeType)
 {
 case XmlNodeType.Element: // se puede filtrar por tipo de XmlNodeType...
 if (count == 0)
 {
 // CUALQUIER CONDICION
 count++;
 reader.Read();

 } else if (count == 1)
 {

 nombretabla = new XElement((XName)reader.Name); // esto para crear un XELEMENT con el nombre del Reader actual
 count++;
 reader.Read();
 } else
 {

 if (string.IsNullOrEmpty(nodoReg)) nodoReg = reader.Name; // condicion para omitir anidados..

 if (nodoReg == reader.Name)
 {
 count++;
 nombretabla.Add(XElement.ReadFrom(reader) as XElement);

 // INSERCION .. cada X lanzo una inserción en BD
 if (count % numInserciones == 0)
 {
 nombrecondicionado.Add(nombretabla);
 docaux.Add(nombrecondicionado);

 // VALIDACION ...
 validado = ValidarEsquema(docaux, esquema);

 if (validado)
 {
 nreg += cond.Insertar(docaux, delete);
 delete = false;

 // vacio contenidos
 nombretabla.Elements().Remove();
 nombrecondicionado.Elements().Remove();
 docaux.Elements().Remove();
 }
 else
 {
 OnReportInformation(string.Format("ERROR fichero{0} no valido.", fichero), ReportLevel.Error);
 EstadoCarga = 2;
 }
 }

 }

 }
 break;

 default :
 reader.Read();
 break;

 }

 }
 // INSERCION DE LOS ULTIMOS QUE NO ENTRAN EN EL ÚLTIMO WHILE
 nombrecondicionado.Add(nombretabla);
 docaux.Add(nombrecondicionado);

 // VALIDACION
 validado = ValidarEsquema(docaux, esquema);

 if (validado)
 {
 nreg += cond.Insertar(docaux, delete);

 // vacio contenidos
 nombretabla.Elements().Remove();
 nombrecondicionado.Elements().Remove();
 docaux.Elements().Remove();
 }
 else
 {
 OnReportInformation(string.Format("ERROR fichero{0} no valido.", fichero), ReportLevel.Error);
 EstadoCarga = 2;
 }

}

 string xml = @"
                <Root>
                    <Item>
                        <id>1</id>
                    </Item>
                    <Item>
                        <id>2</id>
                    </Item>
                    <Item>
                        <id>3</id>
                        <Items>
                            <Item>
                                <id>5</id>
                            </Item>
                            <Item>
                                <id>6</id>
                            </Item>                            
                        </Items>
                    </Item>
                    <Item>
                        <id>4</id>
                    </Item>
                </Root>";

            XDocument doc1 = XDocument.Parse(xml);

            var q1 = from e in doc1.Root.Descendants("Item")
                     select e;

            var q2 = from e in doc1.Root.Elements("Item")
                     select e;

            int c1 = q1.Count(); //6
            int c2 = q2.Count(); //4

One of the nice development features that LINQ to SQL supports is the ability to use a “debug visualizer” to hover over a LINQ expression while in the VS 2008 debugger and inspect the raw SQL that the ORM will ultimately execute at runtime when evaluating the LINQ query expression.

For example, assume we write the below LINQ query expression code against a set of data model classes:

We could then use the VS 2008 debugger to hover over the “products” variable after the query expression has been assigned:

And if we click the small magnifying glass in the expression above, we can launch the LINQ to SQL debug visualizer to inspect the raw SQL that the ORM will execute based on that LINQ query:

If you click the “Execute” button, you can even test out the SQL query and see the raw returned results that will be returned from the database:

This obviously makes it super easy to see precisely what SQL query logic LINQ to SQL ORM is doing for you. 

You can learn even more about how all this works by reading the Part 3: Querying our Database segment in my LINQ to SQL series above.

How to Install the LINQ to SQL Debug Visualizer

The LINQ to SQL Debug Visualizer isn’t built-in to VS 2008 – instead it is an add-in that you need to download to use.  You can download a copy of it here.

The download contains both a binary .dll assembly version of the visualizer (within the \bin\debug directory below), as well as all of the source code for the visualizer:

To install the LINQ to SQL debug visualizer, follow the below steps:

1) Shutdown all running versions of Visual Studio 2008

2) Copy the SqlServerQueryVisualizer.dll assembly from the \bin\debug\ directory in the .zip download above into your local \Program Files\Microsoft Visual Studio 9.0\Common7\Packages\Debugger\Visualizers\ directory:

3) Start up Visual Studio 2008 again.  Now when you use the debugger with LINQ to SQL you should be able to hover over LINQ query expressions and inspect their raw SQL (no extra registration is required).