CODEWITHSUNDEEP
c#linqgenerics
xandi1987
xandi1987

Reputation: 519

Linq anonymous properties over parameter

Is it possible select an anonymous type via list of properties as parameter. The method should look like:

public void TestLinq(List<"Properties"> properties, List<Data> data)
{
    var dat = from d in data select new { properties };
}

I know the description sounds clumsy but I hope I get some help.

It would be important to know the term I have to look for this topic.

Upvotes: 1

Views: 466

Answers (4)

xandi1987
xandi1987

Reputation: 519

I am sorry for the confusion. The outcome should be a csv that's right. The user should be able to define the order of the columns. But for me it was very difficult to formulate a good question. I am looking for a solution with expresisons not with reflection. My Idea was to generate a List of anonymous objects (with the right order) and out of them I wanted to create the csv. So I know the following is working: 

public void Get(List<Value> data,Expression<Func<Value, T>> converter)
{
    var dat = from d in data
     select
         new
         {
               converter
         };
}

Is it possible to safe the Expression> converter in a property and combine many of them to one? So I would get the corret order

Upvotes: 0

Rob
Rob

Reputation: 10248

Here you go, this is based on this answer https://stackoverflow.com/a/5310828/491950

List<string> properties = new List<string>() { {"ResultPrefix"}, {"ProfileResult"}};

foreach (dynamic d in ListProperties(properties, cellValues))
{
     Console.WriteLine(d.ResultPrefix);
}


public static List<dynamic> ListProperties(List<string> properties, List<ChemistryResult> chemistryResults)
{
    List<dynamic> output = new List<dynamic>();

    foreach (ChemistryResult chemistryResult in chemistryResults)
    {
        IDictionary<string, Object> result = new ExpandoObject();

        foreach (string property in properties)
        {
            PropertyInfo propertyInfo = typeof(ChemistryResult).GetProperty(property);

            result[property] = propertyInfo.GetValue(chemistryResult);
        }

        output.Add(result);
    }

    return output;
}

Upvotes: 1

casperOne
casperOne

Reputation: 74530

You can use the Dynamic LINQ query library (download the sample) to create the list of properties in your projection, like so:

public dynamic TestLinq(IEnumerable<Data> data, IEnumerable<string> properties)
{
    // Validate parameters.
    if (properties == null) throw new ArgumentNullException("properties");
    if (data == null) throw new ArgumentNullException("data");

    // Construct the field list.
    var fields = new StringBuilder();
    foreach (string p in properties) fields.AppendFormat("{0},", property);

    // Throw an exception if there are no items.
    if (fields.Length == 0) throw new ArgumentException(
        "The properties enumeration contains no elements.", "properties");

    // Remove the last comma.
    fields.Length--;

    // Select the items and return.  Create the
    // projection here.
    return data.Select("new(" + fields + ")");
}

Note that the return type is of type dynamic, so you'll have no compile-time checking, and unless you're duck-typing, you probably won't have much knowledge of the fields.

You might be better off creating strong types for this, depending on your needs (if this is based on user-input, then you can't obviously).

Upvotes: 1

cadrell0
cadrell0

Reputation: 17307

You cannot use anonymous types in a method signature. It cannot be used as a parameter or the return type.

What you could do, is declare the parameter as dynamic, but dynamic can get really sticky, so I recommend avoiding it. You could have a List<dynamic> parameter, then you will be able to access members of the type, but you will not get type checking at compile time.

Another option it to use IEnumerable or IList. Using either of these will allow you to access the members of the collection without knowing the type. This is safer, as you have all of your compile time checks, but will not allow you to access members or the anonymous type.

But really, you should just convert your anonymous type into a real class so you can make your life easier.

Upvotes: 0

Related Questions