Edit: Je changé le code pour utiliser le constructeur Tuple au lieu de Tuple.Create. Il ne fonctionne actuellement que pour 8 valeurs maximum, mais ajouter 'Tuple stacking' devrait être trivial.
Ceci est un peu délicat et l'implémentation dépend en quelque sorte de la source de données. Pour donner une impression, j'ai créé une solution en utilisant une liste de types anonymes comme source. Comme l'a dit Elion, nous devons créer dynamiquement un arbre d'expression pour l'appeler par la suite. La technique de base que nous utilisons est appelée projection.
Nous devons obtenir à l'exécution les informations de type et créer un ConstructorInfor du constructeur Tuple (...) en fonction du nombre de propriétés. Ceci est dynamique (bien qu'il soit nécessaire d'être le même par enregistrement) pour chaque appel.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
class Program
{
static void Main(string[] args)
{
var list = new[]
{
//new {Name = "ABC", Id = 1},
//new {Name = "Xyz", Id = 2}
new {Name = "ABC", Id = 1, Foo = 123.22},
new {Name = "Xyz", Id = 2, Foo = 444.11}
};
var resultList = DynamicNewTyple(list);
foreach (var item in resultList)
{
Console.WriteLine(item.ToString());
}
Console.ReadLine();
}
static IQueryable DynamicNewTyple<T>(IEnumerable<T> list)
{
// This is basically: list.Select(x=> new Tuple<string, int, ...>(x.Name, x.Id, ...);
Expression selector = GetTupleNewExpression<T>();
var expressionType = selector.GetType();
var funcType = expressionType.GetGenericArguments()[0]; // == Func< <>AnonType..., Tuple<String, int>>
var funcTypegenericArguments = funcType.GetGenericArguments();
var inputType = funcTypegenericArguments[0]; // == <>AnonType...
var resultType = funcTypegenericArguments[1]; // == Tuple<String, int>
var selects = typeof (Queryable).GetMethods()
.AsQueryable()
.Where(x => x.Name == "Select"
);
// This is hacky, we just hope the first method is correct,
// we should explicitly search the correct one
var genSelectMi = selects.First();
var selectMi = genSelectMi.MakeGenericMethod(new[] {inputType, resultType});
var result = selectMi.Invoke(null, new object[] {list.AsQueryable(), selector});
return (IQueryable) result;
}
static Expression GetTupleNewExpression<T>()
{
Type paramType = typeof (T);
string tupleTyneName = typeof (Tuple).AssemblyQualifiedName;
int propertiesCount = paramType.GetProperties().Length;
if (propertiesCount > 8)
{
throw new ApplicationException(
"Currently only Tuples of up to 8 entries are alowed. You could change this code to allow stacking of Tuples!");
}
// So far we have the non generic Tuple type.
// Now we need to create select the correct geneeric of Tuple.
// There might be a cleaner way ... you could get all types with the name 'Tuple' and
// select the one with the correct number of arguments ... that exercise is left to you!
// We employ the way of getting the AssemblyQualifiedTypeName and add the genric information
tupleTyneName = tupleTyneName.Replace("Tuple,", "Tuple`" + propertiesCount + ",");
var genericTupleType = Type.GetType(tupleTyneName);
var argument = Expression.Parameter(paramType, "x");
var parmList = new List<Expression>();
List<Type> tupleTypes = new List<Type>();
//we add all the properties to the tuples, this only will work for up to 8 properties (in C#4)
// We probably should use our own implementation.
// We could use a dictionary as well, but then we would need to rewrite this function
// more or less completly as we would need to call the 'Add' function of a dictionary.
foreach (var param in paramType.GetProperties())
{
parmList.Add(Expression.Property(argument, param));
tupleTypes.Add(param.PropertyType);
}
// Create a type of the discovered tuples
var tupleType = genericTupleType.MakeGenericType(tupleTypes.ToArray());
var tuplConstructor =
tupleType.GetConstructors().First();
var res =
Expression.Lambda(
Expression.New(tuplConstructor, parmList.ToArray()),
argument);
return res;
}
}
Si vous souhaitez utiliser un DataReader ou une entrée CVS, vous devrez réécrire la fonction GetTupleNewExpression. Je ne peux pas parler de la performance, bien qu'elle ne devrait pas être beaucoup plus lente qu'une implémentation native de LINQ car la génération de l'expression LINQ ne se produit qu'une seule fois par appel. Si c'est trop lent, vous pouvez aller sur la route de générer du code (et le garder dans un fichier) par exemple en utilisant Mono.Cecil.
Je ne pouvais pas encore tester cela en C# 4.0 et cela devrait fonctionner. Si vous voulez l'essayer dans 3,5 C# vous avez besoin le code suivant ainsi:
public static class Tuple
{
public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
{
return new Tuple<T1, T2>(item1, item2);
}
public static Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
{
return new Tuple<T1, T2, T3>(item1, item2, item3);
}
}
public class Tuple<T1, T2>
{
public Tuple(T1 item1, T2 item2)
{
Item1 = item1;
Item2 = item2;
}
public T1 Item1 { get; set;}
public T2 Item2 { get; set;}
public override string ToString()
{
return string.Format("Item1: {0}, Item2: {1}", Item1, Item2);
}
}
public class Tuple<T1, T2, T3> : Tuple<T1, T2>
{
public T3 Item3 { get; set; }
public Tuple(T1 item1, T2 item2, T3 item3) : base(item1, item2)
{
Item3 = item3;
}
public override string ToString()
{
return string.Format(base.ToString() + ", Item3: {0}", Item3);
}
}
Il existe une limite au nombre de membres dans un Tuple. Que devrait faire le code s'il y a trop de membres? – Eilon
Il n'y a pas de limite - Tuple de 8 éléments est conçu de manière à avoir un 8ème élément comme un autre Tuple – Yurik
Hmno, il n'y a aucun avantage à taper dynamiquement des données non typées. Vous choisirez dynamiquement le mauvais type. –