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

"La cadena debe contener exactamente un carácter"

Este es el mensaje que te aparece si has mapeado un nvarchar(1) y LINQ to SQL tiene que tratarlo cuando tiene el valor de string vacio es decir “”.

Si se hace sobre el DBML:

Botón derecho > Abrir Con > Editor XML

y se busca la tabla, nos damos cuenta que se esta mapeando de esta forma:

El problema reside en que al ser de 1 posición esta tratando el string de uno como si fuera tipo Char, la solución es editar a mano el DBML y ponerlo como tipo String:

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).

Más información en  http://msdn.microsoft.com/en-us/library/bb386925.aspx

http://msdn.microsoft.com/en-us/vcsharp/aa336746.aspx

Ejemplos de utilización en un Blog de Microsoft:

http://blogs.msdn.com/vbteam/archive/tags/Converting+SQL+to+LINQ/default.aspx

El operador Any se utiliza para determinar si existe un elemento dentro de una secuencia que cumpla una condición expecífica. Las signaturas del método son las siguientes:

   1:  public static bool Any<TSource>(

   2:      this IEnumerable<TSource> source)

   3:  

   4:  public static bool Any<TSource>(

   5:      this IEnumerable<TSource> source,

   6:      Func<TSource, bool> predicate)

Como se puede ver en las signaturas el método devuelve true si algún elemento cumple con la condición y false si no encuentra nada. En el siguiente ejemplo queremos comprobar si existe algún desarrollador que se llame Jorge dentro de nuestra colección.

   1:  var list = (from d in developers

   2:              select d).Any(d => d.Name == "Jorge");

El ejemplo anterior devolverá true ya que existe un desarrollador que se llame Jorge. Para el siguiente ejemplo, en el cual utilizamos una lista vacía, el método Any devolverá false ya que no existe ningún elemento en la colección.

   1:  var list = Enumerable.Empty<Developer>()

   2:                          .Any(d => d.Name == "Jorge");

All

El operador All se utiliza para determinar si todos los elementos de una colección cumplen con una condición específica. La signatura del método es la siguiente:

   1:  public static bool All<TSource>(

   2:      this IEnumerable<TSource> source,

   3:      Func<TSource, bool> predicate)

Este método devolvera true, si todos los elementos cumplen con la condición indicata y false, si hay algún elemento que no cumpla con la condición. En el siguiente ejemplo queremos comprobar que todos los desarroladores haya estado por lo menos en un cliente.

   1:  var list = (from d in developers

   2:              select d).All(d => d.Customers.Count() >= 1);

Si aplicamos este método sobre una colección vacía, este devolverá true. Esto es debido aque el método devuelve false encuanto encuentra un elemento que no coincide con la condición seleccionada y evidentemente en una colección vacía no va ha encontrar ningún elemento.

   1:  var list = Enumerable.Empty<Developer>()

   2:                 .All(d => d.Customers.Count() >= 1);

Contains

El método Contains determina si un determinado elemento se encuentra en la colección. Las signaturas del método son las siguientes:

   1:  public static bool Contains<TSource>(

   2:      this IEnumerable<TSource> source,

   3:      TSource value)

   4:  

   5:  public static bool Contains<TSource>(

   6:      this IEnumerable<TSource> source,

   7:      TSource value,

   8:      IEqualityComparer<TSource> comparer)

En la segunda signatura nos permite personalidar la forma en la que las comparaciones son realizas. Este método devolverá true si en cuentra el elemento y false sino existe el elemento en la colección.

En el siguiente ejemplo, queremos comprobar que en la colección exista el desarrollador, Jorge. Como veréis en el código ,hemos aprovechado la segunda signatura de este método para que se busque por el nombre simplemente.

   1:  Developer d = new Developer{ Name="Jorge", Language="C#", Age=18};

   2:  

   3:  var list = developers.Contains(d, new DeveloperComparer());

   4:  

   5:  public class DeveloperComparer : IEqualityComparer<Developer>

   6:  {

   7:      public bool Equals(Developer x, Developer y)

   8:      {

   9:          if (x.Name == y.Name)

  10:          {

  11:              return true;

  12:          }

  13:  

  14:          return false;

  15:      }

  16:  

  17:      public int GetHashCode(Developer obj)

  18:      {

  19:          return obj.Name.ToString().GetHashCode();

  20:      }

  21:  }