从多个不同的列表创建通用列表

Question

I am writing a Silverlight and WCF project.

I have used the Entity Framework in Silverlight to get the data from the database, I have multiple pages where I use EF.

Now, I have more than 100 types of entity class and hence multiple known list types.

In my WCF interface I want to create one generic function where I can accept all this list types as one generic parameter.

So my WCF function should be like

public string TestBadal(List<Object> list)
    {
        return "test";

    }

My question here is, how can I cast all the known lists to List. I am fairly new to this so any help will be much appreciated.

Thank you.

Answer 1

you can use T

public static List<T> o<T>(List<T> a)
        {
             return a = new List<T>();
        }

Answer 2

As Sophex states you can write a generic function to process a List<> or better still an IList<> of anything.

So your example would become,

public string TestBadal<T>(IList<T> list)
{
    return "test";
}

This is very generic and requires and implies little about T . This may be sufficient for the processing you want to perform but, you don't say.

In general, you should view your method signature as a promise that the caller has to make to the function. You should limit the promise to only what is required for your function to do its job. This way, the promise is easier to make and your function can get reused more with less commitment from the caller.

Your function as it stands, doesen't actually need a parameters and would be better defined as a string const but say, all you wanted to do was enumerate the items you could use,

public string TestBadal<T>(IEnumerable<T> entities)
{
    foreach(T entity in entities)
    {
        ...
    }
}

If your processing is especially related to the EF nature of the data source you could do,

public string TestBadal<TEntity>(EntitySet<TEntity> entities)
    where TEntity : class
{
    ...
}

If you need to know somthing about the type in the list then you have two sensible options. Either you require the types to implement a certain interface, this essentialy makes your function non-generic and could be awkward with in conjunction with EF.

public string TestBadal(IEnumerable<IDefinedType> definedTypeInstances)
{
    foreach(IDefinedType instance in definedTypeInstances)
    {
       var x = instance.SomeDefinedProperty;
    }
}

Or, you can take the non generic parts of the function as a typed delegate parameter, keeping the function generic, possibly somthing like this.

public string TestBadal<T>(
        IList<T> list,
        Func<T, string> stringSelector)
{
    var result = new StringBuilder();

    for(var i = 0; i < list.Count; i++)
    {
        result.AppendLine(stringSelector(list[i])
    }

    return result.ToString();
}

You could call this function with a lambda expression somthing like this,

var result = TestBadal(entities, e => e.SomeStringProperty);

I hope this answer both gives you some ideas and illustrates my point that the right answer depends on what you want your function to achieve.