Compartilhar via

Transformações de dados com o LINQ (C#)

  • Artigo

LINQ (consulta integrada à linguagem)não é apenas sobre recuperação de dados. Também é uma ferramenta poderosa para transformar dados. Usando um LINQ a consulta, você pode usar uma seqüência de origem, como entrada e modificá-lo de várias maneiras para criar uma nova seqüência de saída. Você pode modificar a seqüência sem modificar os próprios elementos pela classificação e agrupamento. Mas talvez o mais poderoso recurso de LINQ consultas é a capacidade de criar novos tipos. Isso é realizado da Selecionar cláusula. Por exemplo, você pode executar as seguintes tarefas:

  • Mescle várias seqüências de entrada em uma seqüência de saída simples tem um novo tipo.

  • Crie seqüências de saída, cujos elementos consistem em apenas um ou vários de propriedades de cada elemento da seqüência de origem.

  • Crie seqüências de saída, cujos elementos consistem nos resultados das operações realizadas nos dados de origem.

  • Para criar seqüências de saída em um formato diferente. Por exemplo, você pode transformar os dados de linhas SQL ou arquivos de texto em XML.

Esses são apenas alguns exemplos. Obviamente, essas transformações podem ser combinadas de várias maneiras na mesma consulta. Além disso, a seqüência de saída de uma consulta pode ser usada como a seqüência de entrada para uma nova consulta.

Ingressando em várias entradas em uma saída seqüência

Você pode usar um LINQ consulta para criar uma seqüência de saída que contém elementos de mais de uma seqüência de entrada. O exemplo a seguir mostra como combinar as duas estruturas de dados na memória, mas os mesmos princípios que podem ser aplicados para combinar dados de origens XML ou SQL ou DataSet. Considere os seguintes tipos de dois classe:

class Student
{
    public string First { get; set; }
    public string Last {get; set;}
    public int ID { get; set; }
    public string Street { get; set; }
    public string City { get; set; }
    public List<int> Scores;
}

class Teacher
{
    public string First { get; set; }
    public string Last { get; set; }
    public int ID { get; set; } 
    public string City { get; set; }
}

O exemplo a seguir mostra a consulta:

class DataTransformations
{
    static void Main()
    {
        // Create the first data source.
        List<Student> students = new List<Student>()
        {
            new Student {First="Svetlana",
                Last="Omelchenko", 
                ID=111, 
                Street="123 Main Street",
                City="Seattle",
                Scores= new List<int> {97, 92, 81, 60}},
            new Student {First="Claire",
                Last="O’Donnell", 
                ID=112,
                Street="124 Main Street",
                City="Redmond",
                Scores= new List<int> {75, 84, 91, 39}},
            new Student {First="Sven",
                Last="Mortensen",
                ID=113,
                Street="125 Main Street",
                City="Lake City",
                Scores= new List<int> {88, 94, 65, 91}},
        };

        // Create the second data source.
        List<Teacher> teachers = new List<Teacher>()
        {                
            new Teacher {First="Ann", Last="Beebe", ID=945, City = "Seattle"},
            new Teacher {First="Alex", Last="Robinson", ID=956, City = "Redmond"},
            new Teacher {First="Michiyo", Last="Sato", ID=972, City = "Tacoma"}
        };

        // Create the query.
        var peopleInSeattle = (from student in students
                    where student.City == "Seattle"
                    select student.Last)
                    .Concat(from teacher in teachers
                            where teacher.City == "Seattle"
                            select teacher.Last);

        Console.WriteLine("The following students and teachers live in Seattle:");
        // Execute the query.
        foreach (var person in peopleInSeattle)
        {
            Console.WriteLine(person);
        }

        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    The following students and teachers live in Seattle:
    Omelchenko
    Beebe
 */

Para obter mais informações, consulte <>cláusula de associação de>(TRANSLATION FROM VPE FOR CSHARP Reference) e Selecione a cláusula (referência de TRANSLATION FROM VPE FOR CSHARP).

Selecionar um subconjunto de cada elemento de origem

Há duas maneiras principais de selecionar um subconjunto de cada elemento da seqüência de origem:

  1. Para selecionar apenas um membro de um elemento de origem, use a operação de ponto. O exemplo a seguir, suponha que um Customer objeto contém várias propriedades públicas, incluindo a seqüência de caracteres denominada City. Quando executada, essa consulta produzirá uma seqüência de saída de cadeias de caracteres.

    var query = from cust in Customers
            select cust.City;

  2. Para criar elementos que contêm mais de uma propriedade do elemento de origem, você pode usar um inicializador de objeto com um objeto nomeado ou de um tipo anônimo. O exemplo a seguir mostra o uso de um tipo anônimo para encapsular as duas propriedades de cada Customer elemento:

    var query = from cust in Customer
            select new {Name = cust.Name, City = cust.City};

Para obter mais informações, consulte Objeto e coleção inicializadores (guia de programação TRANSLATION FROM VPE FOR CSHARP) e Tipos anônimos (guia de programação TRANSLATION FROM VPE FOR CSHARP).

A transformação de objetos em memória em XML

LINQconsultas, facilitam a transformar dados entre as estruturas de dados na memória, bancos de dados SQL, ADO.NET fluxos XML e conjuntos de dados ou documentos. O exemplo a seguir transforma os objetos em uma estrutura de dados na memória em elementos XML.

class XMLTransform
{
    static void Main()
    {            
        // Create the data source by using a collection initializer.
        List<Student> students = new List<Student>()
        {
            new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores = new List<int>{97, 92, 81, 60}},
            new Student {First="Claire", Last="O’Donnell", ID=112, Scores = new List<int>{75, 84, 91, 39}},
            new Student {First="Sven", Last="Mortensen", ID=113, Scores = new List<int>{88, 94, 65, 91}},
        };

        // Create the query.
        var studentsToXML = new XElement("Root",
            from student in students
            let x = String.Format("{0},{1},{2},{3}", student.Scores[0],
                    student.Scores[1], student.Scores[2], student.Scores[3])
            select new XElement("student",
                       new XElement("First", student.First),
                       new XElement("Last", student.Last),
                       new XElement("Scores", x)
                    ) // end "student"
                ); // end "Root"

        // Execute the query.
        Console.WriteLine(studentsToXML);

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}

O código produz a saída XML a seguir:

< Root>
  <student>
    <First>Svetlana</First>
    <Last>Omelchenko</Last>
    <Scores>97,92,81,60</Scores>
  </student>
  <student>
    <First>Claire</First>
    <Last>O'Donnell</Last>
    <Scores>75,84,91,39</Scores>
  </student>
  <student>
    <First>Sven</First>
    <Last>Mortensen</Last>
    <Scores>88,94,65,91</Scores>
  </student>
</Root>

Para obter mais informações, consulte Creating XML Trees in C# (LINQ to XML).

Executar operações de elementos de origem

Uma seqüência de saída não pode conter quaisquer elementos ou propriedades do elemento da seqüência de origem. A saída em vez disso, pode ser uma seqüência de valores é calculada usando os elementos de origem como argumentos de entrada. A seguinte consulta simple, quando ele é executado, gera uma seqüência de cadeias de caracteres cujos valores representam um cálculo com base na seqüência de origem dos elementos do tipo double.

ObservaçãoObservação

Chamar métodos em expressões de consulta não é suportado se a consulta será convertida em algum outro domínio. Por exemplo, você não pode chamar um método comum de C# LINQ to SQL porque SQL Server não tem contexto para o proprietário. No entanto, você pode mapear procedimentos armazenados para métodos e chamar aqueles. Para obter mais informações, consulte Stored Procedures (LINQ to SQL).

 
class FormatQuery
{
    static void Main()
    {            
        // Data source.
        double[] radii = { 1, 2, 3 };

        // Query.
        IEnumerable<string> query =
            from rad in radii
            select String.Format("Area = {0}", (rad * rad) * 3.14);

        // Query execution. 
        foreach (string s in query)
            Console.WriteLine(s);

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    Area = 3.14
    Area = 12.56
    Area = 28.26
*/

Consulte também

Tarefas

Como: Combinar Dados com LINQ usando Joins Visual Basic)

Referência

Selecione a cláusula (referência de TRANSLATION FROM VPE FOR CSHARP)

Conceitos

<>>Expressões de consulta do LINQ (guia de programação TRANSLATION FROM VPE FOR CSHARP)

Outros recursos

LINQ (consulta integrada à linguagem)

LINQ to SQL

LINQ to DataSet

LINQ to XML