Declarar un consultable vacío?

Question

¿Cómo declaro tal variable?

  var rData = from nc in ctx.NEWSLETTER_CLIENTS 
         join ni in ctx.NEWSLETTER_INDICES on nc.INDEX_NUM 
                  equals ni.INDEX_NUM 
         select new 
         { 
          ClientID = nc.CLIENT_ID, 
          Email = nc.CLIENT_EMAIL_ADDRESS, 
          Index = nc.INDEX_NUM, 
          MainClass = ni.MAIN_CLASS, 
          SubClass = ni.SUB_CLASS, 
          App1 = ni.VALUE_1, 
          App2 = ni.VALUE_2, 
          App3 = ni.VALUE_3, 
          App4 = ni.VALUE_4 
         }; 

     // Now I need to declare on a variable named fData under the function scope, 
     // so I can later use it: 

     var fData = ...; //What do I declare here? 

     if(x) 
      fData = fData.Concat(rData.Where(u => ...)); 
     if(y) 
      fData = fData.Concat(rData.Where(u => ...)); 
     // etc 

Answer 1

IQueryable<type of p> fData = null; 

Si desea utilizar la consulta más tarde (OIA después de que el caso):

var fData = Enumerable.Empty<type of p>().AsQueryable(); 

Actualización:

Ahora para usar con los tipos anónimos:

IQueryable<T> RestOfMethod<T>(IQueryable<T> rData) 
{ 
    var fData = Enumerable.Empty<T>().AsQueryable(); // or = rData; 

    if(x) 
    fData = fData.Concat(rData.Where(u => ...)); 
    if(y) 
    fData = fData.Concat(rData.Where(u => ...)); 

    return fData; 
} 

// original code location 
var rData = some query; 
var fData = RestOfMethod(rData); 

Actualización 2:

Como se señaló, el anterior no funcionan realmente, como el predicado de Where no sabe el tipo. Se podría refactorizar un poco más para incluir los predicados en los parámetros, ejemplo:

IQueryable<T> RestOfMethod<T>(IQueryable<T> rData, 
    Expression<Func<T,bool>> pred1, 
    Expression<Func<T,bool>> pred2) 
{ ... } 

Actualización 3: (quizá hacky)

var fData = rData.Take(0); // should be cheap. 

Answer 2

puede declararlo como un IQueryable en lugar de a var. La razón por la que no se puede declarar como ▶ DATA var se debe a que "var" tiene que inferir el tipo durante la declaración. Si conoce el tipo con anticipación, puede declarar que está bien.

IQueryable fData = null; 

Aún mejor, si se conoce el tipo de p, que puede hacer que sea inflexible con la forma genérica de IQueryable:

IQueryable<type-of-p> fdata = null; 

Tenga en cuenta que este asigna nula! Si intenta usarlo, obtendrá una excepción de referencia nula. Si realmente se desea que un objeto consultables vacío, a continuación, utilizar la sugerencia de leppie, y crear una colección vacía mediante el Enumerable.Empty(). AsQueryable() método cadena.

Answer 3

Bueno, la siguiente solución puede ser malo (e incluso contener algo de sobrecarga no deseada), pero, funciona:

var fData = from p in rData 
      where 0 == 1 
      select p; 

if(x) 
    fData = fData.Concat(rData.Where(u => ...)); 
if(y) 
    fData = fData.Concat(rData.Where(u => ...));