Le || (ou) l'Exploitant de Linq avec C#

Avoir une lecture de cette documentation qui explique comment linq et c# est ce que l'expérience d'une déconnexion.

Depuis des expressions Linq devrait être réduit à quelque chose d'autre que la plaine de méthodes que vous pouvez trouver que ce code des pauses si plus tard il est utilisé dans certains pays non Linq to Objects contexte.

Que dit

String.IsNullOrEmpty(fromname) || 
(   !String.IsNullOrEmpty(fromname) && 
    msg.FromName.ToLower().Contains(fromname.ToLower())
)

Est mal formé, car il devrait vraiment être

String.IsNullOrEmpty(fromname) || 
msg.FromName.ToLower().Contains(fromname.ToLower())

qui la rend agréable et clair que vous êtes en s'appuyant sur le msg et msg.FromName à la fois d'être non null.

Pour rendre votre vie plus facile en c# vous pouvez ajouter la chaîne suivante de la méthode d'extension

public static class ExtensionMethods
{
    public static bool Contains(
        this string self, string value, StringComparison comparison)
    {
        return self.IndexOf(value, comparison) >= 0;
    }

    public static bool ContainsOrNull(
        this string self, string value, StringComparison comparison)
    {
        if (value == null)
            return false;
        return self.IndexOf(value, comparison) >= 0;
    }
}

Alors utiliser:

var messages = (from msg in dc.MessageItems
where  msg.FromName.ContainsOrNull(
    fromname, StringComparison.InvariantCultureIgnoreCase)
select msg);

Cependant, ce n'est pas le problème. Le problème est que le Linq to SQL aspects du système essayez d'utiliser la fromname valeur de construire le requête qui est envoyé au serveur.

Depuis fromname est une variable le mécanisme de traduction s'éteint et fait ce qui est demandé (la production d'une plus faible représentation de fromname même si elle est nulle, ce qui déclenche l'exception).

dans ce cas, vous pouvez faire ce que vous avez déjà découvert: garder la requête est aussi, mais assurez-vous que vous pouvez toujours créer un non-nulle de fromname de la valeur avec le comportement souhaité, même si elle est nulle.

Peut-être mieux serait:

IEnumerable<MessageItem> results;
if (string.IsNullOrEmpty(fromname))
{ 
    results = from msg in dc.MessageItems 
    select msg;    
}
else
{
    results = from msg in dc.MessageItems 
    where msg.FromName.ToLower().Contains(fromname) 
    select msg;    
}

Ce n'est pas si grand qu'il la requête contenue d'autres contraintes, et donc d'impliquer plus de duplication, mais pour la requête simple fait devrait entraîner plus lisible et maintenable code. C'est une douleur si vous êtes en s'appuyant sur les types anonymes, mais j'espère que ce n'est pas un problème pour vous.

OriginalL'auteur ShuggyCoUk

Si vous êtes à l'aide de LINQ to SQL, vous ne peut pas s'attendre à la même C# court-circuit comportement de SQL Server. Voir cette question sur court-circuit WHERE clauses (ou son absence) dans SQL Server.

Aussi, comme je l'ai mentionné dans un commentaire, je ne crois pas que vous êtes l'obtention de cette exception dans LINQ to SQL, car:

1. Méthode String.IsNullOrEmpty(String) n'a pas pris en charge la traduction de SQL, de sorte que vous ne pouvez pas l'utiliser dans LINQ to SQL.
2. Vous ne seriez pas obtenir le NullReferenceException. C'est une exception géré, il se produirait uniquement côté client, pas dans SQL Server.

Êtes-vous sûr de ne pas passer par LINQ to Objects quelque part? Êtes-vous en faveur ToList() ou ToArray() sur la source ou référence à elle comme un IEnumerable<T> avant l'exécution de cette requête?

---

Mise à jour: Après lecture de vos commentaires, j'ai testé à nouveau et réalisé certaines choses. Je me suis trompé sur vous pas l'utilisation de LINQ to SQL. Vous ne recevaient pas les "String.IsNullOrEmpty(String) has no supported translation to SQL" exception parce que IsNullOrEmpty() est appelé sur une variable locale, pas une colonne SQL, donc il est exécutant côté client, même si vous êtes en utilisant LINQ to SQL (pas de LINQ to Objects). Depuis qu'il est en cours d'exécution côté client, vous peut obtenir un NullReferenceException sur cet appel de méthode, car il n'est pas traduit à SQL, où vous ne pouvez pas obtenir un NullReferenceException.

Une façon de rendre votre solution semble moins hacky est résoudre fromname'"null-ness" à l'extérieur de la requête:

string lowerfromname = String.IsNullOrEmpty(fromname) ? fromname : fromname.ToLower();

var messages = from msg in dc.MessageItems
               where String.IsNullOrEmpty(lowerfromname) || msg.Name.ToLower().Contains(lowerfromname)
               select msg.Name;

Noter que ce ne sera pas toujours être traduit à quelque chose comme (à l'aide de vos commentaires à titre d'exemple):

SELECT ... FROM ... WHERE @theValue IS NULL OR @theValue = theValue

Sa traduction sera décidé au moment de l'exécution, selon que fromname est null ou pas. Si elle est nulle, il sera de traduire sans WHERE clause. Si elle n'est pas null, il sera de traduire avec un simple "WHERE @theValue = theValue", sans nul vérifier en T-SQL.

Donc en fin de compte, la question de savoir s'il court-circuit dans SQL ou non n'est pas pertinent dans ce cas parce que le LINQ to SQL runtime émettent différentes requêtes T-SQL si fromname est null ou pas. Dans un sens, elle est court-circuitée côté client avant d'interroger la base de données.

OriginalL'auteur Lucas

Comme Brian dit, je regarde si le msg.FromName est null, avant de faire la ToLower().Contient(fromname.ToLower()))

OriginalL'auteur Nordes