ilist

I'm trying to deserialize json to an object model where the collections are represented as IList<T> types. The actual deserializing is here: JavaScriptSerializer serializer = new JavaScriptSerializer(); return serializer.Deserialize<IList<Contact>>( (new StreamReader(General.GetEmbeddedFile("Contacts.json")).ReadToEnd())); Before i post the exception i'm getting you should know what the implicit conversions are. This is the Contact type: public class Contact { public int ID { get; set; } public string Name { get; set; } public LazyList<ContactDetail> Details { get; set; } //public List

Is there a lock-free & thread-safe data structure that implements IList? Naturally by lock-free I mean an implementation that makes no use of locking primitives in .NET but rather uses interlocked operations / atomic operations to achieve thread safety... There isn't one, apparently under the concurrent data structures... Has anyone seen one floating around? I've seen a java one implemented in amino-cbbs , called LockFreeVector but nothing for .NET so far. Any ideas? Well, I couldn't find such a class anywhere; so I gave it a shot . The source code for my ConcurrentList<T> class is available

Is there a limit of elements that could be stored in a List ? or you can just keeping adding elements untill you are out of memory ? The current implementation of List<T> uses Int32 everywhere - to construct its backing array, for its Count property, as an indexer and for all its internal operations - so there's a current theoretical maximum of Int32.MaxValue items ( 2^31-1 or 2147483647 ). But the .NET framework also has a maximum object size limit of 2GB, so you'll only get anywhere near the items limit with lists of single-byte items such as List<byte> or List<bool> . In practice you'll

I have an IList<string> returning from a function (as variable lst) and I set and then I this.dataGridView1.DataSource = lst; The datagrid adds one column labelled Length and then lists the length of each string. How do I make it just list the strings? You really need a list of objects that have a string property. With .NET 3.5 you could cheat: .DataSource = list.Select(x=>new {Value = x}).ToList(); Otherwise create a dummy class and copy the data in manually... This is because DataGridViews show properties of the object. In this case the List only has one property "Length", therefore it can

I have written a method which is public List<List<object>> Fetch(string data) , inside I create List<List<object>> p = new List<List<object>>(); my boss now wants to return a IList<IList<object>> instead of List<List<object>> ie public IList<IList<object>> Fetch(string data) , so when I try do return (IList<IList<object>>) p; //throws an exception How do I convert List<List<object>> to IList<IList<object>> and back to List<List<object>> Thanks. You can't perform that conversion via straight casting - it wouldn't be safe. Instead, you should use: IList<IList<object>> ret = new List<IList<object

I am trying to cast IList type to List type but I am getting error every time. List<SubProduct> subProducts= Model.subproduct; Model.subproduct returns IList<SubProduct> . Try List<SubProduct> subProducts = new List<SubProduct>(Model.subproduct); or List<SubProduct> subProducts = Model.subproducts as List<SubProduct>; How about this: List<SubProduct> subProducts = Model.subproduct.ToList(); In my case I had to do this, because none of the suggested solutions were available: List<SubProduct> subProducts = Model.subproduct.Cast<SubProduct>().ToList(); Webleeuw List<SubProduct> subProducts= (List

What is the difference between IEnumerable and IEnumerable<T> ? I've seen many framework classes implementing both these interfaces, therefore I would like to know what advantages one get by implementing both? Please have a look how they've been defined: public interface IEnumerable { [DispId(-4)] IEnumerator GetEnumerator(); } public interface IEnumerable<T> : IEnumerable { IEnumerator<T> GetEnumerator(); } As we see, IEnumerable<T> derives from IEnumerable , that means whatever IEnumerable has, IEnumerable<T> inherits, then why do we implement both instead of just IEnumerable<T> ? Is