Compartilhar via

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

  • Artigo

LINQ (Consulta Integrada à Linguagem) é não somente sobre recuperar dados.Também é uma ferramenta poderosa para transformar dados.Usando uma consulta de LINQ , você pode usar uma sequência de origem como entrada e modificá-lo de várias maneiras para criar uma nova sequência de saída.Você pode alterar a sequência própria sem alterar os elementos próprios classificação e pooling. Mas talvez o recurso mais eficiente de consultas de LINQ é a capacidade de criar novos tipos.Isso é feito na cláusula de selecione .Por exemplo, você pode executar as seguintes tarefas:

  • Sequências de entrada de mesclagem várias em uma única saída arranjam em sequência que tenha um novo tipo.

  • Crie as sequências de saída cujos elementos consistem de um ou somente as várias propriedades de cada elemento em sequência de origem.

  • Crie as sequências de saída cujos elementos consistem nos resultados das operações executadas nos dados de origem.

  • Crie sequências de saída em um formato diferente.Por exemplo, você pode transformar dados das linhas ou arquivos de texto SQL em XML.

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

Vários entradas de combinação em uma sequência de saída

Você pode usar uma consulta de LINQ para criar uma sequência de saída que contém os elementos de mais de uma sequência de entrada.O exemplo a seguir mostra como combinar duas estruturas de dados na memória, mas os mesmos princípios podem ser aplicados para combinar dados de fontes XML ou do SQL ou dataset.Suponha os dois seguintes tipos de 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 JOIN (referência de C#) e (referência de C#) da cláusula Select.

Selecionando um subconjunto de cada elemento de origem

Há duas maneiras principais de selecionar um subconjunto de cada elemento em sequência de origem:

  1. Para selecionar apenas um membro do elemento de origem, use a operação de ponto.No exemplo, suponha que um objeto de Customer contém várias propriedades públicas que incluem uma cadeia de caracteres chamada City.Quando executada, esta consulta irá gerar uma sequê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 chamado ou um tipo anônimo.O exemplo a seguir mostra o uso de um tipo anônimo encapsular duas propriedades de cada elemento de Customer :

    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 do C#) e Tipos anônimos (guia de programação do C#).

Transformando objetos na memória em XML

consultas deLINQ facilitam transformar dados entre estruturas de dados na memória, bancos de dados SQL, datasets de ADO.NET e fluxos ou documentos XML.O exemplo transforma 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.
        // The Student class was defined previously in this topic.
        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 seguinte saída XML:

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

Executando operações em elementos de origem

Uma sequência de saída não pode conter qualquer elementos ou propriedades do elemento de sequência de origem.A saída em vez disso pode ser uma sequência dos valores que é calculada apenas usando elementos de origem como argumentos de entrada.A seguinte consulta simples, embora seja executada, a saída que uma sequência de cadeias de caracteres cujos valores representam um cálculo com base em sequência da fonte dos elementos de tipo double.

ObservaçãoObservação

Os métodos de em expressões de consulta não são suportados se a consulta será convertida em algum outro domínio.Por exemplo, você não pode chamar um método comum C# em LINQ to SQL porque o SQL Server não tem qualquer contexto para ele.No entanto, você pode mapear procedimentos armazenados para chamar os métodos e.Para obter mais informações, consulte Stored Procedures: Mapping and Calling (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 associações (Visual Basic)

Referência

(referência de C#) da cláusula Select

Conceitos

Expressões de consulta do LINQ (guia de programação do C#)

Outros recursos

LINQ (consulta integrada à linguagem)

LINQ to SQL

LINQ to DataSet

LINQ to XML