principiantes - operadores linq c#

Consulta de selección LINQ con tipo anónimo y tipo definido por el usuario

Question

La clase anónima solo ha leído propiedades en c #. Lo que a menudo se usa para declarar en linq select query para obtener valores particulares de la base de datos. En mi código tengo la siguiente consulta. Lo que me confundió al seleccionar un nuevo objeto de clase anónima usando una nueva declaración. Tuve una clase modelo de StudentClerkshipsLogModel . Cuando uso el nombre del modelo, el resultado de la consulta permite la edición.

var query = (from entity in _tblStudentClerkshipsLog.GetQueryable()
where entity.StudentID == intStudentID
select new StudentClerkshipsLogModel
{
StudentClerkshipID = entity.StudentClerkshipID,
StudentID = entity.StudentID,
ClerkshipID = entity.ClerkshipID,
}).ToList();

Cuando no mencioné el tipo después de new en la declaración de select , no puedo salir. compilador elevar un error. El objeto enónimo es de solo lectura.

var query = (from entity in _tblStudentClerkshipsLog.GetQueryable()
where entity.StudentID == intStudentID
select new
{
StudentClerkshipID = entity.StudentClerkshipID,
StudentID = entity.StudentID,
ClerkshipID = entity.ClerkshipID,
}).ToList()

mi pregunta es cómo linq se unen a la consulta sobre dos de manera diferente. Ambas consultas tienen enlace dinámico o la primera es estática.

Gracias

Answer 1

El error que está recibiendo realmente no tiene nada que ver con LINQ. Puedes ver lo mismo sin usar LINQ en absoluto:

var anonymous = new { Name = "Fred" };
anonymous.Name = "Joe"; // Error, as properties of anonymous types are read-only

Por lo tanto, si desea modificar los objetos recuperados por su consulta LINQ, no debe usar tipos anónimos. Pero ambas consultas LINQ están vinculadas estáticamente: los tipos anónimos aún se conocen completamente en tiempo de compilación, y el compilador les aplica restricciones de tipo normal. Por ejemplo:

var anonymous = new { Name = "Fred" };
Console.WriteLine(anonymous.Foo); // Error: no property Foo
int bar = anonymous.Name; // Error: no conversion from string to int

Answer 2

Encontré la siguiente diferencia con el resultado de tipo anónimo de un resultado de LINQ.

1. El resultado no es editable, por ejemplo, si asignamos valor a una vista de cuadrícula, será de solo lectura.

2. Problema con el alcance de un objeto anónimo. No podemos pasar el tipo a otro método. define un parámetro de tipo var; var siempre debe ir seguido de una expresión de inicialización.

Si necesita resultados solo en el contexto actual para fines de solo lectura, utilice una consulta anónima. Si necesita resultados en otra función, debe definir el tipo de objeto. el tipo de objeto después de new se creará con las propiedades que desea obtener de la definición de resultado y luego entre llaves {} . No es necesario inicializar todo el valor de la clase del modelo.

Answer 3

Si te entiendo correctamente, te estás preguntando, ¿cómo el proveedor de LINQ puede establecer las propiedades de un objeto anónimo, ya que son propiedades de solo lectura "verdaderas" (no hay ningún private set , pero solo se get )?

Cuando llama al método de extensión Select para IQueryable<T> , acepta una expresión de tipo Expression<Func<T, TResult> . Si escribirá un código auxiliar para Select , puede buscar en la expresión generada, utilizando el depurador:

public static class MyExtensions
{
public static void MySelect<T, TResult>(this IQueryable<T> query, Expression<Func<T, TResult>> projection)
{
System.Diagnostics.Debug.WriteLine(projection);
}
}

La diferencia está en cómo el compilador genera expresiones lambda para tipos nombrados y tipos anónimos. Cuando llamas a Select para el tipo con nombre, la expresión se verá así:

{_ => new Person() {Id = _.Id, Name = _.Name}}

Es decir, primero se construirá un nuevo objeto Person , y luego se inicializarán los miembros (expresión MemberInit ).

Pero cuando llama a Select para un tipo anónimo, la expresión se creará como una llamada de constructor ( New expresión):

{_ => new <>f__AnonymousType0`2(a = _.Id, b = _.Name)}

El proveedor de LINQ compila estos lambdas en delegados, al materializar los resultados de la consulta, y en última instancia simplemente llama al constructor para el tipo anónimo.