1 Introducción
Artículos anteriores se describen algunos métodos de soporte de Lambda y LINQ. Este es un artículo que trato de describir lo que LINQ utilizar dos formas de buscar mediante la simulación de escenarios de negocio específicos.
Se ha de mencionar consulta LINQ se divide en dos, un método consiste en formar la cadena, el título oficial es el streaming de consulta; el otro es similar a las instrucciones de consulta SQL, similar a SQL consulta me ha llamado antes, pero algunos documento llamado la expresión de consulta.
Nota En esta parte se necesita leer los "Fundamentos de la serie C # -7", y hay algunos objetos básicos y colecciones.
1.1 Preparación de datos:
Debido a este contenido implicará múltiples fuentes de datos, por lo que necesita para preparar algunas clases y los datos, los datos siguientes es puramente ficticio, no relacionados con la realidad.
/// <summary>
/// 学生
/// </summary>
public class Student
{
/// <summary>
/// 学号
/// </summary>
public long StudentId { get; set; }
/// <summary>
/// 姓名
/// </summary>
public string Name { get; set; }
/// <summary>
/// 年龄
/// </summary>
public int Age { get; set; }
/// <summary>
/// 班级
/// </summary>
public string Class { get; set; }
}
/// <summary>
/// 科目
/// </summary>
public class Subject
{
/// <summary>
///
/// </summary>
public long SubjectId { get; set; }
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 年级
/// </summary>
public string Grade { get; set; }
/// <summary>
/// 教师
/// </summary>
public string Teacher { get; set; }
}
/// <summary>
/// 考试
/// </summary>
public class Exam
{
/// <summary>
/// 考试编号
/// </summary>
public long ExamId { get; set; }
/// <summary>
/// 科目编号
/// </summary>
public long SubjectId { get; set; }
/// <summary>
/// 学生编号
/// </summary>
public long StudentId { get; set; }
/// <summary>
/// 分数
/// </summary>
public double Score { get; set; }
/// <summary>
/// 考试时间：年-月 如202004 表示2020年04月
/// </summary>
public int Time { get; set; }
}
Fuente de datos:
List<Student> students = new List<Student>();// 学生列表，忽略数据来源
List<Subject> subjects = new List<Subject>();// 科目列表，忽略数据来源
List<Exam> exams = new List<Exam>();// 考试列表，忽略数据来源
Consulta 2 Demo
Anteriormente introdujo un concepto, C # hay un tipo llamado un tipo anónimo. Debido a que C # Todo es un objeto de petición, una clase Jie objeto, cada objeto o tipos de datos están todos en el soporte de la espalda. Pero a veces necesitar algo de una sola vez de sólo lectura escribir, esta vez para declarar una clase completa un poco más daño que bien. ¿Qué es una sola vez de sólo lectura escribir, es decir, sólo nos importa qué atributos que tiene, no importa qué método, y la clase de objeto correspondiente sólo se puede dar a la asignación de propiedad en otras ocasiones no puede ser reasignado durante la inicialización, y este tipo sólo dentro del método utilizado, después de la finalización de esta variable se utiliza este tipo ha perdido su significado, este tipo es lo que llamamos una sola vez de sólo lectura escribir.
Entonces, ¿cómo este tipo de declaración? El primero no es urgente, primera re-introducir una palabra clave var. Esta palabra clave tiene ningún lugar especial? varrepresentación implícita del "tipo", lo que significa que una varvariable declarada su propio compilador necesita la inferencia de tipos en el contexto, lo que significa que los usuarios sean conscientes y declaran el tipo de variable, pero no lo dice.
Entonces, ¿por introducir varél? La razón es que vares la base de objetos anónimos. Debido objeto anónimo no se puede utilizar objecta las variables de declarar, hay dos razones, en primer lugar, una variable declarada como objeto Después de eso, necesitamos propiedad no puede ser utilizado, en segundo lugar, el objeto de un tipo anónimo no se puede convertir directamente al tipo de objeto. Por lo tanto, quiero que el uso normal de los tipos anónimos, debe ser utilizado var.
Lo que sigue es una breve presentación de la declaración y el uso de los tipos anónimos:
var obj = new
{
Name = "萧三",
Age = 20
};
// obj.Name 萧三
// obj.Age 20
Este es el tipo anónimo, declarar un objeto tiene un nombre y edad propiedades de este objeto que saber qué propiedades tiene, pero no sabe qué tipo sí.
Después de la introducción a los conocimientos necesarios para aprobar la situación real de comparar las consultas de flujo y de consulta de expresiones dos usos.
2.1 simple consulta
-
clase de consulta es un grupo de tres años para todos los estudiantes
// 流式查询 var results = students.Where(t=>t.Class=="三年一班"); // 查询表达式 var results = from s in students where s.Class == "三年一班" select s;Ambas estructuras de consulta son IEnumerable <T>.
-
Obtener todos los estudiantes del plantel de Zhang
// 流式查询 var results = students.Where(t=>t.Name.StartWith("张")); // 查询表达式 var results = from s in students where s.Name.StartWith("张") select s; -
Los estudiantes son agrupados por clases reciben cada lista de la clase
// 流式查询 var results = students.GroupBy(t => t.Class); // 查询表达式 var results = from s in students group s by s.Class; // 注明：完整的写法如下： // var results = from s in students group s by s.Class into g select g;Tenga en cuenta que, si el resultado es el resultado de una agrupación, entonces no seleccionar una.
-
La edad promedio de cada clase de consultas
// 流式查询 var results = students.GroupBy(t => t.Class) .Select(t => new {Class = t.Key, AveAge = t.Average(p => p.Age)}); // 查询表达式 var results = from s in students group s by s.Class into g select new {Class = g.Key, AveAge = g.Average(t => t.Age)};No hay expresiones de consulta de palabras clave investigación estadística, sólo se pueden obtener por el método, mientras que la consulta es una expresión de conjunto devuelto, por lo que no se puede resumir directamente a través de la expresión de consulta, de promedio, y así sucesivamente.
-
Todos los estudiantes se clasifican en orden descendente de edad
// 流式查询 var results = students.OrderByDescending(t => t.Age); // 查询表达式 var results = from s in students orderby s.Age descending select s; -
Todos los estudiantes de pequeño a grande están ordenadas por edad
// 流式查询 var results = students.OrderBy(t => t.Age); // 查询表达式 var results = from s in students orderby s.Age select s; -
A continuación, pulse las edades especie ordenar Nombre
// 流式查询 var results = students.OrderBy(t => t.Age).ThenBy(t=>t.Name);//ThenByDescending 是降序版的ThenBy // 查询表达式 var results = from s in students orderby s.Age //descending 如果是降序则增加这个关键字 , s.Name select s;
2.2 consultas complejas
La primera parte describe las consultas simples, esta sección describe combinar múltiples fuentes de datos para una serie de consultas.
-
Consultas de los sujetos del lenguaje de tercer grado en todos los grados en los exámenes realizados en el mes de 202 004
// 流式查询 var results = subjects.Join(exams, s => s.SubjectId, e => e.StudentId, (s, e) => new { s.Name, s.Grade, e.Score, e.Time }).Where(t=>t.Grade == "三年级" && t.Name =="语文" && t.Time == 202004).Select(t=>t.Score); // 查询表达式 var results = from s in subjects join e in exams on s.SubjectId equals e.SubjectId where e.Time == 202004 && s.Grade == "三年级" && s.Name == "语文" select e.Score; -
Agrupados por categorías, cada grado las puntuaciones de lenguaje consulta
// 流式查询 var results = subjects.Where(p => p.Name == "语文") .Join(exams, s => s.SubjectId, e => e.SubjectId, (s, e) => new {s.Grade, e.Score}) .GroupBy(t => t.Grade); // 查询表达式 var results = from s in subjects join e in exams on s.SubjectId equals e.SubjectId where s.Name == "语文" group e.Score by s.Grade into g select g; -
Puntuación media para cada examen sujeto y piden a todos los grados más alta anterior de puntuación y la puntuación más baja
//流式查询 var results = subjects.Join(exams, s => s.SubjectId, e => e.SubjectId, (s, e) => new { s.Grade, s.Name, e.Score }).GroupBy(t => t.Grade).Select(t => new { Grade = t.Key, Subjects = t.GroupBy(p => p.Name).Select(p => new { Name = p.Key, Max = p.Max(r => r.Score), Min = p.Min(r => r.Score), Average = p.Average(r => r.Score) }) }); //查询表达式 var results = from s in subjects join e in exams on s.SubjectId equals e.SubjectId let o = new {s.Grade, s.Name, e.Score} group o.Score by new {o.Grade, o.Name} into o let p = new { o.Key.Grade, Subject = new {o.Key.Name, Max = o.Max(), Min = o.Min(), Average = o.Average()} } group p.Subject by p.Grade into g select new { Grade = g.Key, Subjects = g.AsEnumerable() };Probablemente un poco más que introducir el uso de LINQ, es obvio que se puede ver, la transmisión de consultas y expresiones de consulta sobre la legibilidad de la diferencia es aún muy grande. Para las personas que están familiarizados con SQL, consulta expresión puede ser productivo con mayor rapidez, para mí, más acostumbrado a la transmisión de consulta, pero cuando múltiples fuentes de datos combinados, tiendo a escribir la expresión de consulta. Estos son los fundamentos de la totalidad del contenido de LINQ.
Más atención debe estar agradecido a mi blog
