Entender la sintaxis de LINQ

Question

estoy realmente confundido entender su sintaxis LINQ interna de trabajo Esto se

string[] test = new test[] { "abc", "", "cd", "", "aa" }; 
test = test.Where(x => !string.IsNullOrEmpty(x)).ToArray(); 

Me gustaría saber donde sintaxis cómo se gestiona. ¿Se pone toda la matriz en x? En caso afirmativo, ¿cómo gestiona x valor nulo?

o

Si no, entonces los valores de matriz de ensayo ponen uno por uno en la x?

Answer 1

Deberías considerar el resto de las respuestas, son bastante precisas, lo que quiero mostrarte y quizás esto te ayude a entender la sintaxis es que este tipo de consulta realmente puede representarse en una sintaxis de consulta como esta:

string[] test=new test[]{"abc","","cd","","aa"}; 

// this is the equivalent to your code 
// added explicit type to make it clearer, it's optional 
var a = from (string)x in test 
     where !string.IsNullOrEmpty(x) 
     select x; 

si está familiarizado con SQL, se encuentra esta sintaxis más fácil de leer, incluso cuando usted no lo sepa, esta sintaxis es más limpio.

Cuando se compila el código, esta sintaxis consulta se traduce automáticamente a la sintaxis del método C#, con el fin de generar la IL, así que si dissasmbly una DLL verá la sintaxis método en lugar de la sintaxis de consulta

una breve explicación acerca de este código:

• Como se puede ver una variable x fue declarado y es de tipo string. ¿Por qué?porque la matriz es una matriz de cadenas

• El in test indica la fuente IEnumerable<> iterar - la matriz, en este caso

• El where es bastante explicativo, simplemente selecciona las cadenas de todo no nulos de la matriz

• Y finalmente selecciona lo que en realidad es una proyección de los datos.

Y todo esto es equivalente a su código

Ahora usted podría estar preguntando ... ¿Cuándo debo utilizar una sintaxis o el otro? Bueno, son equivalentes, pero los operadores de sintaxis de consulta son limitados, lo que significa que la mayoría de las operaciones se realizan con la sintaxis del método en lugar de la sintaxis de la consulta. Lo que siempre hago es tratar de escribir el código más fácil de leer. Algunos códigos son más fáciles de entender si están escritos con una sintaxis de consulta.

Acerca de la sintaxis del método, la sintaxis del x => ... se conoce como expresión lambda, pueden parecer extrañas si es la primera vez que se trabaja con ellas, pero finalmente las adorará.

Básicamente lambdas son accesos directos a los delegados, así que lo que están haciendo con:

x => !string.IsNullOrEmpty(x) 

va a crear un método anónimo y se le ha asignado el método para el parámetro delegado. El x representa el string variable.

Este tema es muy extenso para tratar de explicarlo aquí, pero espero que esto te haya dado una idea de lo que hay detrás.

Por cierto se puede combinar la sintaxis de la siguiente manera:

// this is the equivalent to your code 
// added explicit type to make it clearer, it's optional 
var a = (from (string)x in test 
     where !string.IsNullOrEmpty(x) 
     select x).ToArray(); 

Si google LINQ es como googlear porm lol la web está plagada de artículos de LINQ, muestras, etc.

Un buen punto de inicio serían las 101 muestras de Microsoft

http://code.msdn.microsoft.com/101-LINQ-Samples-3fb9811b

EDITAR

voy a tratar de emular el método en el que para que pueda tener un mejor ejemplo de la expresión lambda

// this is basically the declaration of one overload of the Where method 
// the this in the parameter declaration, indicates this is an extension method which will be available to all IEnumerable<> objects 
// the Func<T, bool> is the interesting part, it is basically a delegate (as a reminder, the last parameter of the Func object indicates the type that must be returned, in this case is a bool) 
// the delegate is simply a pointer to a function 
public IEnumerable<T> Where<T>(this IEnumerable<T> source, Func<T, bool> predicate) 
{ 

    ...some logic 




    ... yielding back the reuslts 
    foreach(var r in res) 
    { 
     // here is the delegate in action 
     if(predicate(r)) 
      yield return r; 
    } 
} 

Como se puede ver el delegado fue llamado como una función (delegados son puntero a funciones) Butt ¿Qué función?el que declaran en su código

• x => !string.IsNullOrEmpty(x) y la x indica el parámetro pasa de nuevo a partir del método Donde el código externo, donde se puede inspeccionar y lo utilizan para filtrar los resultados

• El x => es una abreviatura para declarar un delegado

• ! String.IsNullOrEmpty (x) este es el cuerpo de su m anónima ethod y como puede ver que cumple los requisitos del Func<T, bool> devuelve un bool (el predicado para filtrar los elementos de la matriz) y como parámetro, recibió el genérico T que en este caso es una cadena de su matriz

Otra manera de declarar la expresión lambda es:

test = test.Where(
      (string) x => 
      { 
       return !string.IsNullOrEmpty(x) 
      }) 
      .ToArray(); 

con esta sintaxis es fácil demostrar que en realidad son métodos (métodos anónimos)

Answer 2

EDITAR

Lee este artículo seguramente obtendrá una buena idea acerca de que ha writtnen ......

C# 3.0 New Language Features (Part 1)

C# 3.0 New Language Features (Part 2)

---

que es de de extenstion method + lambda experssion parte de C# 3.0

aquí en este código

test=test.Where(x => !string.IsNullOrEmpty(x)).ToArray(); 

where - es un método extesion

x => !string.IsNullOrEmpty(x) - se expresion lambda, que es el reemplazo de la función anónima

toda esta acción, compruebe el que cada elemento de la matriz ... es decir, la expresión de lamdaba comprueba que cada elemento de la matriz satisfaga la condición que se escribe y que finalmente vuelve la matriz de esos elementos que cumplen la condición

Answer 3

que podemos tomar la státem ent aparte y examinar las piezas una a la vez

x => !string.IsNullOrEmpty(x) es definir básicamente una función como el siguiente

bool Filter(string x){ 
    return !string.IsNullOrEmpty(x) 
} 

y crea un predicado sobre la base de esa función. Un predicado es solo un delegado, una función que puede pasar en una variable.

.Where es un método de extensión que por simplicidad se podría definir

IEnumerable<T> Where<T>(this IEnumerable<T> sequence,Predicate<T> pred){ 
    foreach(var elem in sequence){ 
     if(pred(elem)){ 
      yield return elem; 
     } 
    } 
} 

tenían que haya definido la función como Filter se ha definido anteriormente en lugar de utilizar un lambda su estado de cuenta se vería así

test = test.Where(Filter).ToArray(); 

por lo tanto, al invocar este método de extensión en su matriz y pasar el predicado anterior, iterará sobre todos los elementos de la matriz y devolverá todos los elementos que coincidan con el predicado (es decir, los que son neithe). r nula ni tienen el valor de la cadena vacía)

Por último se llama al método de extensión .ToArray() lo que convierte .Where devuelto (un IEnumerable<string>) en una matriz