Orderby et NullReferenceException

Version imprimable

Bonjour,

Je me suis souvent posé cette question : pourquoi linq ne fonctionne pas comme le SQL ? Pourquoi dans une requête SQL un order by a travers une jointure de table met les résultat non lié a la fin et linq lui lève une exception ?

Exemple :
Code:

1 2 3 4 5 6 7 var users = new List<User>{ new User{UserName= "Pierre"}, new User{UserName = "Anthyme", Address = new Address{PostalCode ="95023"}}, new User{UserName = "Paul", Address = new Address{PostalCode ="75010"}}, }; var usersOrdered = users.OrderBy(u => u.Address.PostalCode).ToList();
J'aimerai récupérer comme résultat une liste de user dans cet ordre : Paul, Anthyme, Pierre. Sans exception !

Est ce que quelqu'un connait une solution ?

Merci :)

Lorsque je crée les tables suivantes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
create table [User]
(
	UserId int not null,
	UserName varchar(50)
);
 
alter table [User] add constraint pkUser primary key( UserId );
 
create table Address
(
	AddressId int not null,
	UserId int not null,
	PostalCode varchar(10)
);
 
alter table Address add constraint pkAddress primary key (AddressId);
 
alter table Address add constraint fkAddress_User foreign key ( UserId ) references [User] ( UserId );

Avec le contenu suivant :

Code:

1
2
3
4
5
6
7
 
insert into [User] ( UserId, UserName ) values ( 1, 'Pierre' );
insert into [User] ( UserId, UserName ) values ( 2, 'Anthyme' );
insert into [User] ( UserId, UserName ) values ( 3, 'Paul' );
 
insert into Address( AddressId, UserId, PostalCode ) values ( 1, 2, '95023' );
insert into Address( AddressId, UserId, PostalCode ) values ( 2, 3, '75010' );

Le résultat de la requete :

Code:

1
2
3
4
5
6
7
8
9
10
 
select
	[User].*
from
	[User]
	left join Address on (
		Address.UserId = [User].UserId 
	)
order by
	Address.PostalCode;

Est : Pierre, Paul, Anthyme

C'est à dire que les résultats non liés sont au début. (le NULL est plus petit que tout)

Ensuite, avec LINQPad http://www.linqpad.net/

Code:

1
2
3
4
 
from u in Users
orderby u.Addresses.First().PostalCode
select u.UserName

Donne : Pierre, Paul, Anthyme

Comme SQL... non ?

17/02/2010, 11h19
anthyme

Je parle de manipulations avec linq to object

Par contre c'est étrange quand je fais des requêtes sur ma base oracle les null sont a la fin ...

Tu peux faire quelque chose comme ça :

Code:

var usersOrdered = users.OrderBy(u => u.Address != null ? u.Address.PostalCode : "99999").ToList();

("99999" pour être sûr que ce soit supérieur à tous les autres)

Pour rendre l'écriture (un peu) plus lisible, j'ai créé une méthode d'extension comme ça :
Code:

1 2 3 4 5 6 7 public static TResult IfNotNull<TSource, TResult>(this TSource source, Func<TSource, TResult> selector, TResult defaultValue) where TSource : class { if (source != null) return selector(source); return defaultValue; }
Ca s'utilise comme ça :

Code:

var usersOrdered = users.OrderBy(u => u.Address.IfNotNull(a => a.PostalCode, "99999")).ToList();

Avec du code largement copié/collé de ton (sympathique) blog :ccool:, et sous LinqPad, le bout de source ci-dessous donne le même résultat que les requetes sous Sql Server :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 class User { public string UserName { get; set; } public Address Address { get; set; } public void SetUserName(string newUserName) { UserName = newUserName; } } class Address { public string Street { get; set; } public string PostalCode { get; set; } } void Main() { var users = new List<User>{ new User{UserName= "Pierre"}, new User{UserName = "Anthyme", Address = new Address{PostalCode ="95023"}}, new User{UserName = "Paul", Address = new Address{PostalCode ="75010"}}, }; var usersOrdered = users.OrderBy(u => u.Address == null ? "" : u.Address.PostalCode).ToList(); usersOrdered.Dump(); var userNameOrdered = from u in users orderby u.Address == null ? "" : u.Address.PostalCode select u.UserName; userNameOrdered.Dump(); }
C'est à dire : Pierre, Paul, Anthyme

Maintenant, s'agissant d'Oracle, je n'ai pas de base pour tester, mais si le NULL est considéré différemment dans une clause ORDER BY, c'est moche... et très surprenant... Que dit la norme (SQL 92?)

Merci pour vos interventions c'est vraiment intéressant ! :)

Maintenant je vais encore élever un peu le chalenge :

J'utilise System.Linq.Dynamic pour faire mes orderby dynamiquement via des string, voici quelques exemples :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 users.OrderBy("Address.PostalCode"); //Equivalent à users.OrderBy(u => u.Address.PostalCode); users.OrderBy("Address.PostalCode, UserName"); //Equivalent à users.OrderBy(u => u.Address.PostalCode).ThenBy(u => u.UserName); users.OrderBy("Address.PostalCode desc, UserName"); //Equivalent à users.OrderByDescending(u => u.Address.PostalCode).ThenBy(u => u.UserName); //etc
J'ai donc le même problème de null référence exception avec la version dynamique, est ce que vous avez une idée de comment je pourrais pallier ce problème tout en conservant la flexibilité de mes string ?

19/02/2010, 12h31
tomlev

Ce que tu appelles System.Linq.Dynamic, c'est ce qui est décrit ici ?

J'ai jamais utilisé cette lib, mais ça a l'air sympa :)

D'après la doc, ça supporte l'opérateur conditionnel, donc tu peux faire pareil :

Code:

users.OrderBy("Address != null ? Address.PostalCode : @0", String.Empty);
19/02/2010, 13h41
anthyme

Oui c'est cette lib ... un vrai petit miracle ! Le temps que j'ai gagné sur mes appli Web MVC avec des tableaux classables par colonne :)

Merci encore pour le coup de pouce, Je vais tester ton code quand j'aurais un moment ... Mais je vais avoir une sacré moulinette a faire : je peux recevoir une string qui peut avoir n'importe quel nombre de OrderBy - ThenBy qui chacun ont une profondeur de sous élements illimité :mrgreen: :aie:

Citation:

Envoyé par anthyme

Mais je vais avoir une sacré moulinette a faire : je peux recevoir une string qui peut avoir n'importe quel nombre de OrderBy - ThenBy qui chacun ont une profondeur de sous élements illimité :mrgreen: :aie:

Ca doit pouvoir se faire en travaillant au niveau de l'expression tree... genre, en réécrivant l'expression en remplaçant chaque noeud du type MemberExpression ou MethodCallExpression par un ConditionalExpression.

Au final, l'idée serait de pouvoir faire quelque chose comme ça :

Code:

var baz = myObject.SafeEval(x => x.Foo.Bar.Baz, defaultValue);

et que ce soit évalué comme ça :
Code:

1 2 3 4 5 6 7 8 9 if (x == null) return defaultValue; var foo = x.Foo; if (foo == null) return defaultValue; var bar = foo.Bar; if (bar == null) return defaultValue; return bar.Baz;
J'avais essayé de le faire une fois, mais c'est pas évident du tout et j'avais fini par laisser tomber...

20/02/2010, 01h55
tomlev

Citation:

Envoyé par tomlev

Ca doit pouvoir se faire en travaillant au niveau de l'expression tree... genre, en réécrivant l'expression en remplaçant chaque noeud du type MemberExpression ou MethodCallExpression par un ConditionalExpression.

...

J'avais essayé de le faire une fois, mais c'est pas évident du tout et j'avais fini par laisser tomber...

Bon, ben comme ça me travaillait, j'ai insisté un peu et j'ai réussi :)
Si ça t'intéresse, j'ai publié un billet à ce propos sur mon blog
http://tomlev.wordpress.com/2010/02/...ressions-linq/

Par contre ça risque de pas être génial au niveau des perfs... c'est plus un POC qu'un code réellement utilisable

Je m'étais déjà fait un getter safe en fait mais je n'avais pas pensé a cette valeur par défaut et donc cela ne marchait pas ...

Par contre le miens était bien plus simple :

Code:

1
2
3
4
5
6
7
8
9
10
11
public static TReturn get<T, TReturn>(this T obj, Func<T, TReturn> keySelector)
{
    try
    {
        return keySelector.Invoke(obj);
    }
    catch (NullReferenceException)
    {
        return default(TReturn);
    }
}

J'ai rajouté maintenant celui ci :

Code:

1
2
3
4
5
public static TReturn get<T, TReturn>(this T obj, Func<T, TReturn> keySelector, TReturn defaultValue)
{
    var value = get(obj, keySelector);
    return value.IsEquals(default(TReturn)) ? defaultValue : value;
}

Et ça marche nickel ;)

Effectivement, c'est l'option la plus simple... mais c'est pas génial non plus pour les perfs, et c'est moche d'utiliser un try/catch pour une NullReferenceException :aie:

Sinon, pour tes deux surcharges (avec ou sans valeur par défaut), j'aurais plutôt fait comme ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public static TReturn get<T, TReturn>(this T obj, Func<T, TReturn> keySelector, TReturn defaultValue) { try { return keySelector(obj); } catch (NullReferenceException) { return defaultValue; } } public static TReturn get<T, TReturn>(this T obj, Func<T, TReturn> keySelector) { return obj.get(keySelector, default(TReturn)); }
A mon avis il vaut mieux faire comme ça, parce que le fait de récupérer default(TReturn) n'indique pas forcément qu'il y a eu une NullReferenceException, ça peut être une valeur tout à fait valide...

22/02/2010, 22h13
anthyme

exact c'est bien mieux ... faut vraiment que j'aille dormir ... :zzz:

Pour les perf faudrait que je fasse quelques tests mais je pense qu'on doit quand même être bien plus rapide qu'avec des manipulation sur les expression linq ... A voir ...
22/02/2010, 22h27
tomlev

Citation:

Envoyé par anthyme

Pour les perf faudrait que je fasse quelques tests mais je pense qu'on doit quand même être bien plus rapide qu'avec des manipulation sur les expression linq ... A voir ...

Probable... en fait, si la NullReferenceException ne se produit pas, le try/catch n'a pas d'impact sur les perfs. C'est seulement quand il se produit que c'est plus long...