Le fait de déclarer un vide Queryable?

Comment dois-je déclarer une 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

OriginalL'auteur Shai | 2012-06-07

  1. 34
    IQueryable<type of p> fData = null;

    Si vous souhaitez utiliser la requête ultérieurement (oie après la fi):

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

    Mise à jour:

    Maintenant pour l'utilisation avec les types anonymes:

    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);

    Mise à jour 2:

    Comme l'a souligné, le ci-dessus ne fait pas le travail, comme le prédicat de Where ne connaissez pas le type. Vous pourriez refactoriser un peu plus d'inclure les prédicats dans les paramètres, par exemple:

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

    Mise à jour 3: (peut-être hacky)

    var fData = rData.Take(0); //should be cheap.
    Merci pour ça, il ne l'aide, voir mon montage pour une clarification
    Pour les types anonymes, n'est pas facilement possible, mais peut en fait en partie par un peu de refactoring du reste de la méthode.
    J'ai ajouté un exemple de ce que je voulais dire dans mon commentaire précédent.
    merci mais ça ne compile pas, comme RestOfMethod ne sais pas laquelle les membres u contient...
    Vous avez raison, et à refactoriser plus, sera en désordre 🙁

    OriginalL'auteur leppie

  2. 2

    Bien, la solution suivante peut être mauvais (et même contenir certains indésirables généraux), mais, il travaille:

    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 => ...));

    OriginalL'auteur Shai

  3. -1

    Vous pouvez le déclarer comme un IQueryable au lieu d'un var. La raison pour laquelle vous ne pouvez pas déclarer fData comme un var est parce que "var" besoins de déduire le type au cours de déclaration. Si vous connaissez le type à l'avance, vous pouvez le déclarer juste fine.

    IQueryable fData = null;

    Encore mieux, si vous connaissez le type de p, vous pouvez faire fortement typé avec la forme générique de la IQueryable:

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

    Notez que cela affecte null! Si vous essayez de l'utiliser, vous obtiendrez une référence nulle exception. Si vous voulez vraiment un vide Queryable objet, puis utilisez leppie de la suggestion, et de créer un vide de la collection à l'aide de la Énumérable.Empty().AsQueryable() la méthode de la chaîne.

    Je doute fortement de la volonté de travail (ou même de la compilation), à moins que vous lancez p à l'objet.
    Vous n'avez pas besoin de cast p de l'objet; tout est .NET est implicitement convertible objet.
    Il pourrait travailler .NET 4 en raison de la covariance, mais il va certainement échouer .NET 3.5.

    OriginalL'auteur BTownTKD