Conversion between collection interface types

[satyajit]

Hi All,

I have a class that has a property returning IList. For example,

class A
{
public IList<stringMyList
{
get { return _list; }
set { _list = new List<string>(value); }
}

private List<string_list;
}

Now, I have a method that has an IEnumerable and tries to set MyList
property of an object of type A. Here is how I have done it:

void f(A a, IEnumerable<stringlist)
{
a.MyList = new List<string>(list);
}

The above works fine, but I think there must be a better way to
achieving this rather than create temporary List<stringobjects. This
happens twice - 1) While converting from IEnumerable<to IList<>, and
2) While converting from IList<to List<Last thing I would want is
to change the return type of the property or the signature of f(). Any
suggestions?

On side notes, how bad is it performance wise?

- Satyajit

[Jon Skeet [C# MVP]]

satyajit <sa*********@gmail.comwrote:

<snip>

The above works fine, but I think there must be a better way to
achieving this rather than create temporary List<stringobjects. This
happens twice - 1) While converting from IEnumerable<to IList<>, and
2) While converting from IList<to List<Last thing I would want is
to change the return type of the property or the signature of f(). Any
suggestions?

Two options:

1) Have an extra setter in A which takes an IEnumerable<string>
2) Create a lightweight implementation of IList<Twhich accepts (and
retains) an IEnumerable<Tand does the bare minimum needed by the List
<Tconstructor.

On side notes, how bad is it performance wise?

Well, it'll be at least O(n), but possibly worse because of the copying
that will occur when the internal buffer fills up. Unfortunately I'm
too tired to work out whether that makes it O(n log n) or O(n^2). The
former, I suspect, because the copying will only happen O(log n) times
assuming the internal buffer size goes up proportionally (eg doubling)
rather than linearly.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[satyajit]

On May 23, 3:34 pm, Jon Skeet [C# MVP] <[e-mail]:

<snip>

The above works fine, but I think there must be a better way to
achieving this rather than create temporary List<stringobjects. This
happens twice - 1) While converting from IEnumerable<to IList<>, and
2) While converting from IList<to List<Last thing I would want is
to change the return type of the property or the signature of f(). Any
suggestions?

Two options:

1) Have an extra setter in A which takes an IEnumerable<string>

Do you mean that I write one more property (say MyList1) that takes an
IEnumerable<>?

2) Create a lightweight implementation of IList<Twhich accepts (and
retains) an IEnumerable<Tand does the bare minimum needed by the List
<Tconstructor.

Would any of the classes provided by the .NET class library (closest)
fit in here?

Thanks.

[Jon Skeet [C# MVP]]

satyajit <sa*********@gmail.comwrote:

Two options:

1) Have an extra setter in A which takes an IEnumerable<string>

Do you mean that I write one more property (say MyList1) that takes an
IEnumerable<>?

I wouldn't write a whole extra property - just a single method.

2) Create a lightweight implementation of IList<Twhich accepts (and
retains) an IEnumerable<Tand does the bare minimum needed by the List
<Tconstructor.

Would any of the classes provided by the .NET class library (closest)
fit in here?

I don't know of any, I'm afraid.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too