from (Cláusula, Referencia de C#)
Una expresión de consulta debe comenzar con una cláusula from, Además, una expresión de consulta puede contener subconsultas, que también comienzan con una cláusula from. La cláusula from especifica lo siguiente:
El origen de datos en el que se ejecutará la consulta o subconsulta.
Una variable de rango local que representa cada elemento de la secuencia de origen.
Tanto la variable de rango como el origen de datos están fuertemente tipados. El origen de datos al que se hace referencia en la cláusula from debe tener un tipo de IEnumerable, IEnumerable<T> o un tipo derivado como IQueryable<T>.
En el ejemplo siguiente, numbers es el origen de datos y num es la variable de rango. Tenga en cuenta que ambas variables están fuertemente tipadas a pesar de que se usa la palabra clave var.
class LowNums
{
static void Main()
{
// A simple data source.
int[] numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0];
// Create the query.
// lowNums is an IEnumerable<int>
var lowNums = from num in numbers
where num < 5
select num;
// Execute the query.
foreach (int i in lowNums)
{
Console.Write(i + " ");
}
}
}
// Output: 4 1 3 2 0
Variable de rango
El compilador deduce el tipo de la variable de rango cuando el origen de datos implementa IEnumerable<T>. Por ejemplo, si el origen tiene un tipo de IEnumerable<Customer>, entonces se deduce que la variable de rango es Customer. La única vez en que debe especificar el tipo explícitamente es cuando el origen es un tipo IEnumerable no genérico como ArrayList. Para obtener más información, vea Procedimiento para consultar un objeto ArrayList con LINQ (C#).
En el ejemplo anterior, num se deduce que es de tipo int. Como la variable de rango está fuertemente tipada, puede llamar a los métodos en ella o usarla en otras operaciones. Por ejemplo, en lugar de escribir select num, podría escribir select num.ToString() para hacer que la expresión de consulta devuelva una secuencia de cadenas en lugar de enteros. O podría escribir select num + 10 para hacer que la expresión devuelva la secuencia 14, 11, 13, 12, 10. Para obtener más información, vea Cláusula select.
La variable de rango es como una variable de iteración en una instrucción foreach excepto por una diferencia muy importante: una variable de rango realmente nunca almacena datos del origen. Es solo una comodidad sintáctica que permite a la consulta describir lo que ocurrirá cuando se ejecute la consulta. Para obtener más información, vea Introducción a las consultas LINQ (C#).
Cláusulas From compuestas
En algunos casos, cada elemento de la secuencia de origen puede ser por sí mismo una secuencia o contener una. Por ejemplo, su origen de datos puede ser un IEnumerable<Student> donde cada objeto de estudiante en la secuencia contiene una lista de resultados de las pruebas. Para tener acceso a la lista interna dentro de cada elemento Student, puede usar las cláusulas from compuestas. La técnica es como usar instrucciones foreach anidadas. Puede agregar cláusulas where u orderby a cualquier cláusula from para filtrar los resultados. En el ejemplo siguiente se muestra una secuencia de objetos Student, cada uno de los cuales contiene un List interno de enteros que representa los resultados de las pruebas. Para tener acceso a la lista interna, use una cláusula from compuesta. Puede insertar cláusulas entre las dos cláusulas from si es necesario.
class CompoundFrom
{
// The element type of the data source.
public class Student
{
public required string LastName { get; init; }
public required List<int> Scores {get; init;}
}
static void Main()
{
// Use a collection initializer to create the data source. Note that
// each element in the list contains an inner sequence of scores.
List<Student> students =
[
new Student {LastName="Omelchenko", Scores= [97, 72, 81, 60]},
new Student {LastName="O'Donnell", Scores= [75, 84, 91, 39]},
new Student {LastName="Mortensen", Scores= [88, 94, 65, 85]},
new Student {LastName="Garcia", Scores= [97, 89, 85, 82]},
new Student {LastName="Beebe", Scores= [35, 72, 91, 70]}
];
// Use a compound from to access the inner sequence within each element.
// Note the similarity to a nested foreach statement.
var scoreQuery = from student in students
from score in student.Scores
where score > 90
select new { Last = student.LastName, score };
// Execute the queries.
Console.WriteLine("scoreQuery:");
// Rest the mouse pointer on scoreQuery in the following line to
// see its type. The type is IEnumerable<'a>, where 'a is an
// anonymous type defined as new {string Last, int score}. That is,
// each instance of this anonymous type has two members, a string
// (Last) and an int (score).
foreach (var student in scoreQuery)
{
Console.WriteLine("{0} Score: {1}", student.Last, student.score);
}
}
}
/*
scoreQuery:
Omelchenko Score: 97
O'Donnell Score: 91
Mortensen Score: 94
Garcia Score: 97
Beebe Score: 91
*/
Usar cláusulas From múltiples para realizar combinaciones
Una cláusula from compuesta se usa para tener acceso a las colecciones internas en un origen de datos único. En cambio, una consulta también puede contener varias cláusulas from que generan consultas adicionales de orígenes de datos independientes. Esta técnica le permite realizar determinados tipos de operaciones de combinación que no son posibles mediante la cláusula join.
En el siguiente ejemplo se muestra cómo pueden usarse dos cláusulas from para formar una combinación cruzada completa de dos orígenes de datos.
class CompoundFrom2
{
static void Main()
{
char[] upperCase = ['A', 'B', 'C'];
char[] lowerCase = ['x', 'y', 'z'];
// The type of joinQuery1 is IEnumerable<'a>, where 'a
// indicates an anonymous type. This anonymous type has two
// members, upper and lower, both of type char.
var joinQuery1 =
from upper in upperCase
from lower in lowerCase
select new { upper, lower };
// The type of joinQuery2 is IEnumerable<'a>, where 'a
// indicates an anonymous type. This anonymous type has two
// members, upper and lower, both of type char.
var joinQuery2 =
from lower in lowerCase
where lower != 'x'
from upper in upperCase
select new { lower, upper };
// Execute the queries.
Console.WriteLine("Cross join:");
// Rest the mouse pointer on joinQuery1 to verify its type.
foreach (var pair in joinQuery1)
{
Console.WriteLine("{0} is matched to {1}", pair.upper, pair.lower);
}
Console.WriteLine("Filtered non-equijoin:");
// Rest the mouse pointer over joinQuery2 to verify its type.
foreach (var pair in joinQuery2)
{
Console.WriteLine("{0} is matched to {1}", pair.lower, pair.upper);
}
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
/* Output:
Cross join:
A is matched to x
A is matched to y
A is matched to z
B is matched to x
B is matched to y
B is matched to z
C is matched to x
C is matched to y
C is matched to z
Filtered non-equijoin:
y is matched to A
y is matched to B
y is matched to C
z is matched to A
z is matched to B
z is matched to C
*/
Para obtener más información sobre las operaciones de combinación que usan varias cláusulas from, vea Realizar operaciones de combinación externa izquierda.
