What is a collection?

Community Convergence VII

Charlie Calvert's Community Blog — Tue, 17 Oct 2006 19:51:23 GMT

The C# team needs your help debugging the new Visual Studio 2005 Service Pack 1 Beta . I've written about

What is a collection?

DotNetKicks.com — Tue, 17 Oct 2006 19:57:02 GMT

You've been kicked (a good thing) - Trackback from DotNetKicks.com

re: What is a collection?

Wesner Moise — Wed, 18 Oct 2006 13:38:30 GMT

>> A collection is a type that implements IEnumerable and has a public Add method.

Hmmm!

What if the type derives from ICollection<T> but has a non-public Add method, which is also an explicit interface method.

In such cases, the type might actually use a differently named Add method or require an explicit interface cast. (Eg, priority queue or stack can have enqueue or push, for example.)

re: What is a collection?

Wesner Moise — Wed, 18 Oct 2006 13:41:04 GMT

Another advantage to examining the interface method if possible is the ability for non-English developers to construct friendlier native language methods for their objects.

Community Convergence VIII

Charlie Calvert's Community Blog — Mon, 23 Oct 2006 09:03:54 GMT

Welcome to the eighth installment of Community Convergence . This week let's focus on two C# Wikis available

re: What is a collection?

Omer van Kloeten — Fri, 27 Oct 2006 22:51:27 GMT

>> If an entry in the list consists of multiple arguments to an Add method, these are enclosed in { curly braces }.

To me, curly brackets have always said one of two things in c#: array contents and code blocks.

So it's a bit confusing to me why you chose curly brackets to indicate parameter tuples being sent to a method, when clearly the logical choice would have been the simple parenthesis:

Plurals myPlurals = new Plurals { “collection”, ( “query”, “queries” ), new KeyValuePair(“child”, “children”) };

re: What is a collection?

madstorgersen — Wed, 01 Nov 2006 01:28:09 GMT

Thank you for these comments. A comment related to Wesner's was also given to me offline: since we have syntax for calling with multiple arguments we could have special support not only for ICollection<T> but also for IDictionary<K,T>. It adds to the complexity but may capture some good scenarios. We'll certainly revisit it in the design group.

As for the curly syntax for multiple arguments, let it be no secret that parentheses and curlies were both strong candidates. Both are also already overloaded. Omer's comment outlines that clearly for curlies; however, parentheses are also already heavily used; for grouping, invoking, casting etc. Curlies have the advantage of not falsely suggesting that we have tuples in the language.

re: What is a collection?

Sepilin Uzah — Wed, 01 Nov 2006 02:46:36 GMT

Which tools I need to play with LINQ?

re: What is a collection?

Tommy Carlier — Wed, 01 Nov 2006 11:22:16 GMT

You could make it a lot cleaner by implementing a KeyValuePair operator, that creates a KeyValuePair-instance, like in Smalltalk:

var pair = key -> value;

// same as: var pair = new KeyValuePair(key, value);

Then you can remove the curly braces from your initializer:

var p = new Plurals { "mouse" -> "mice", "child" -> "children", "fish" -> "fish" };

re: What is a collection?

Omer van Kloeten — Wed, 01 Nov 2006 11:25:18 GMT

>> parentheses are also already heavily used; for grouping, invoking, casting etc.

You mention invoking and this is exactly the situation here - you're invoking an overload. You can say that the pure mathematical definition of a function dictates that the above pair is a tuple and that the language doesn't have them, but the fact remains that this is a method call and not a type initialization (I'm talking about only the query/queries part) which would make the use of curly brackets inconsistent with the rest of the language (which uses curly brackets for initialization: anonymous types, collection initializers, array initializers, anonymous methods, etc.).

re: What is a collection?

Gordon Nanninga — Thu, 02 Nov 2006 18:16:14 GMT

When implenting ICollection<T> I have also been adding AddNew(T t). This takes the passed item and makes a new copy to put in the array. It would seem this is preferable for a constuction call as I would assume the braced items could be changed later. If the litorals were added with the normal Add() then the complier should complain when the program attemps to change a read only value.

re: What is a collection?

Aaron Erickson — Fri, 03 Nov 2006 16:51:08 GMT

Curious, why not just inherit your collection class (or the abstract version of your collection, if so inclined) from List<T> - and get all this IEnumerable related cool stuff for basically free?

re: What is a collection?

JD — Tue, 07 Nov 2006 00:22:04 GMT

When you identified the 'collections' in your framework that did not implement ICollection<T>... why didn't you fix that?

Is it because inheriting and implementing ICollection<T> is too costly/breaking?

re: What is a collection?

commenter — Tue, 07 Nov 2006 15:20:20 GMT

Interesting article.

[syntax niggle]

[question w obvious answer]

Hope this comment proved my cleverness!

Opinion: Collection Initializers Syntax

Omer van Kloeten's .NET Zen — Tue, 14 Nov 2006 23:50:40 GMT

Mads Torgersen (have I got it right? you never wrote your full name) wrote last month in his weblogabout

Opinion: Collection Initializers Syntax

עומר.נט — Tue, 14 Nov 2006 23:50:45 GMT

Mads Torgersen (have I got it right? you never wrote your full name) wrote last month in his weblog about

Are you sure?

David — Thu, 16 Nov 2006 06:29:37 GMT

I hate to be negative, but this is a terrible idea. Has Microsoft been looking for community feedback on this?

I can understand now wanting to limit the application of this feature to ICollection<T>, since that interface requires a Remove method, which may not always be appropriate. But, as has already been mentioned, what if I don't want to use Add as the name of the method to add new items? For example, the Queue<T> class does not implement ICollection<T>, presumably because the Remove method as defined in that interface has no meaning for a queue. And its "Add" method is called Enqueue. But clearly a Queue has the ability to be initialized from a list of items. But since you are only looking for ICollection (and maybe IDictionary), the Queue class will completely miss out on this functionality.

Also, what if I have an IEnumerable class which implements an Add method for another purpose? Imagine if the string class had methods "string Add(char)" and "string Add(string)", that functioned like the + operator. Based on that, the compiler would allow syntax like

new string {"a", 'b', "cde"}

But the result would be an empty string. The same would be true for any class which was designed to be immutable but wanted to use an Add method to return combined objects (think something similar to MulticastDelegate). Talk about non-intuitive!

This article indicates that the reason this approach is necessary is because many collection classes don't implement ICollection<T>. Queue is a good example. It seems to me that the real problem here is that there is an entire set of logical types, such as Queue, to which items can be arbitrarily added but not removed. These types should also be able to participate in this pattern, since there's nothing about the pattern that requires the ability to arbitrarily remove items. However, these types are missing interface representation in the framework, resulting in the need for the approach described in this article. Instead of hacking up some behind-the-scenes signature binding, shouldn't this be fixed? You're already admitted that ICollection was a mistake; can you go a little farther and fix the real hole in this scenario, instead of trying to mask it?

It seems to me that the core of the problem is that the compiler is attempting to assign semantic meaning to a particular member name. C-style programming has never included this concept; the GetEnumerator example cited in this article is the only other example I can think of (the fact that the author notes that most developers don't even know about this is evidence of how foreign the concept is to most C-style developers). Even the using keyword insists on the IDisposable interface; it doesn't go looking for a Dispose method all on its own.

This is not simply resistence to change; semantics of member names should remain soley at the discretion of the developer, to determine the best name to use in a particular context (such as Queue.Enqueue). Microsoft should seek community feedback on this issue, and seriously reconsider whether this is the best thing for the future of the C# language.

As a side note, while I don't feel as strongly about it, I tend to agree with Omer, that parentheses make more sense in context than braces.

re: What is a collection?

oli — Thu, 16 Nov 2006 22:54:42 GMT

Why not create a new interfaces ICollector<T> and ICollector defining only a Add Method. Existing collection interfaces (including ICollection<T>)and classes (including Queue) implementing some kind of add-functionality could be changed to implement ICollector<T> or ICollector. This would not break existing code.

What is a collection? The answered could be: It is a class implementing ICollector<T> or ICollector.

An IPairCollector<T> interface could be used in the same way.

re: What is a collection?

Soby Zacharia — Mon, 20 Nov 2006 14:14:20 GMT

This Is really nice But Need More Examples

re: What is a collection?

Mike Brown — Mon, 20 Nov 2006 21:49:39 GMT

Are you sure that GetInterfaceTypes walks up the inheritance tree? Because if it doesn't and I implement IList<T>, then even though IList<T> implements ICollection<T>, my class won't show in that query.

I can tell you that we EXTENSIVELY use generic collections here.

re: What is a collection?

oli — Wed, 22 Nov 2006 23:06:41 GMT

Here some examples to my prevoius e-mail:

namespace Test.Normal {

// Sample interfaces and classes without special handling of add-functionality

interface ICollection<T> {

void Add(T item);

bool Remove(T item);

}

class NomalCollection<T> : ICollection<T> {

public void Add(T item) { }

public bool Remove(T item) { return true; }

}

class NormalQueue<T> {

public void Enqueue(T item) { }

public T Dequeue() { return default(T); }

}

namespace Test.Enhanced {

// Sample interfaces and classes with special handling of add-functionality intoducing ICollector<T>

interface ICollector<T> {

void Add(T item);

}

interface ICollection<T> : ICollector<T> {

bool Remove(T item);

}

class EnhancedCollection<T> : ICollection<T> {

public void Add(T item) { }

public bool Remove(T item) { return true; }

}

class EnhancedQueue<T> : ICollector<T> {

public void Enqueue(T item) { }

public T Dequeue() { return default(T); }

void ICollector<T>.Add(T item) { Enqueue(item); }

}

------------------------------------

using System;

namespace Test {

class Program {

static bool IsICollector(object o)

{ // The test "o is ICollector<>" with empty generic type parameter is not possible.

// This method does it using Reflection.

Type[] interfaces;

Type iCollectorType;

if (o == null)

return false;

interfaces=o.GetType().GetInterfaces();

iCollectorType = typeof(Enhanced.ICollector<>);

foreach (Type t in interfaces){

if (t.IsGenericType && t.GetGenericTypeDefinition() == iCollectorType)

return true;

}

return false;

}

static void Main(string[] args)

{

Normal.ICollection<int> normColl1 = new Normal.NomalCollection<int>();

Normal.NomalCollection<int> normColl2 = new Normal.NomalCollection<int>();

Enhanced.ICollection<int> enhColl1 = new Enhanced.EnhancedCollection<int>();

Enhanced.EnhancedCollection<int> enhColl2 = new Enhanced.EnhancedCollection<int>();

normColl1.Add(1); normColl2.Add(2);

enhColl1.Add(3); enhColl2.Add(4);

Console.WriteLine("normColl1 IS ICollector: {0}", IsICollector(normColl1)); // ==> false

Console.WriteLine("normColl2 IS ICollector: {0}", IsICollector(normColl2)); // ==> false

Console.WriteLine("enhColl1 IS ICollector: {0}", IsICollector(enhColl1)); // ==> true

Console.WriteLine("enhColl2 IS ICollector: {0}", IsICollector(enhColl2)); // ==> true

Normal.NormalQueue<int> normQueue = new Normal.NormalQueue<int>();

Enhanced.ICollector<int> enhQueue1 = new Enhanced.EnhancedQueue<int>();

Enhanced.EnhancedQueue<int> enhQueue2 = new Enhanced.EnhancedQueue<int>();

normQueue.Enqueue(1);

((Enhanced.EnhancedQueue<int>)enhQueue1).Enqueue(2); enhQueue1.Add(3);

enhQueue2.Enqueue(4); ((Enhanced.ICollector<int>)enhQueue2).Add(5);

Console.WriteLine("normQueue IS ICollector: {0}", IsICollector(normQueue)); // ==> false

Console.WriteLine("enhQueue1 IS ICollector: {0}", IsICollector(enhQueue1)); // ==> true

Console.WriteLine("enhQueue2 IS ICollector: {0}", IsICollector(enhQueue2)); // ==> true

Console.ReadLine();

}

re: What is a collection?

Andres Cartin — Thu, 23 Nov 2006 02:13:30 GMT

How about using attributes for this? Then you could use an [CollectionAddMethod] and [CollectionRemoveMethod] for example instead of looking for an actual implementation of an ICollection...

Add extension method?

Colin — Sat, 25 Nov 2006 01:47:25 GMT

Would an Add extension method (new feature in C# 3.0) that was in scope also be accepted by the compiler for collection initialization?

For example (bear with me - I'm new to this stuff), assume there exists a Queue<> class which is IEnumerable<> but not ICollection<> and has an Enqueue method but no Add method. If the following extension method was defined:

public static void Add<T>(this Queue<T> queue, T item)

{

queue.Enqueue(item);

}

would that work? I know in this case it seems an unnecessary method call because Add just wraps Enqueue, but taking it further, it would allow any number of custom Add methods to be added to any collection type and participate in the collection initialization syntax.

Despre iniţializarea unei colecţii

Small place on earth — Mon, 27 Nov 2006 02:39:01 GMT

Nu ştiu câţi dintre voi au păstrat setarea standard a Visual Studio, şi anume aceea de a-ţi deschide

re: What is a collection?

cgh — Mon, 27 Nov 2006 18:50:59 GMT

I like Andres Cartin's suggestion for Attributes. Feels more flexible.

re: What is a collection?

Tom — Tue, 28 Nov 2006 02:28:41 GMT

With curly braces...hmmm looks like PERL!

re: What is a collection?

Donald Mull — Tue, 28 Nov 2006 17:42:54 GMT

About the collection initializer: Couldn't the same thing be accomplished with a constructor like this:

public Collection(params T[] items)

and not have to introduce new syntax?

Collection<String> myStrings =

new Collection<String>("One", "Two", "Three");

re: What is a collection?

ramooon — Fri, 01 Dec 2006 15:42:26 GMT

Andres Cartin's suggestion is great !

re: What is a collection?

Mike — Sat, 02 Dec 2006 04:56:44 GMT

It looks like Microsoft has taken a big step backwards with LINQ. The syntax/semantics are counter-intuitive and makes readability a great challenge.

re: What is a collection?

Bob Falooley — Sun, 03 Dec 2006 18:19:20 GMT

Querying function names for the correct funciton to call is a bad idea. I think you should just fix the collections you have found with this query with one of the suggested methods above. What this artical does do is show the power of LINQ, and how its power can be used with reflection for analysis of source code. I think developers are more interested in this power then saving a few lines of code when initializing a collection.

--Falooley

re: What is a collection?

Topcoder — Mon, 04 Dec 2006 14:00:47 GMT

there might be a bit of stupidity in every revolutionary thing but I as a database freak for the last 10-12 years am thinking that LINQ is the worst I've seen from MS. it is refering to object data (fields) as if they are relational data(columns). this comes to confuse the already confused c# developer about everything he is supposed to do with a database. well, their RELATIONAL database. we've got tons of rubbish sql from our web developers anyway and this now will make things even worse!

Collection Initializers and Duck Typing

Technical Articles — Fri, 08 Dec 2006 09:49:09 GMT

Recently I came across a blog post by Mads Torgersen , the project manager for the C# language team at

re: What is a collection?

madstorgersen — Tue, 23 Jan 2007 22:27:43 GMT

Thanks again for all your comments. Many of you suggest that we introduce some mechanism (new interface, attributes, special methods etc) to better mark the fact that something "is a collection" and how it should be initialized with a collection initializer.

This does not address the problem we set out to solve, which is to make collection initialization possible on a number of existing classes without modification. The only suggestion I've seen that does that is the one about allowing colleciton initializers to make use of Add methods added as extension methods.

We will look at that, but as it is, we are currently finishing up the last bits of coding for Orcas, and can hardly fit any more changes in. Heck we gotta ship at some point. Luckily this is the kind of limitations that we can lift in the next version if the need is there; we are not designing ourselves out of it.

Community Convergence XIX

Charlie Calvert's Community Blog — Wed, 24 Jan 2007 03:51:00 GMT

Welcome to the nineteenth Community Convergence. I'm Charlie Calvert, the C# Community PM, and this is

re: What is a collection?

damien morton — Thu, 25 Jan 2007 23:07:14 GMT

Why do you microsft guys go public with your language design issues just as you go into lockdown. Surely it would be more meaningful to engage the community at a point where their input can make a difference.

re: What is a collection?

madstorgersen — Fri, 26 Jan 2007 01:24:27 GMT

LINQ and C# 3.0 have been public since PDC in september 2005, with active forums, blogs, website etc. We got a ton of useful input from the community which has made quite a difference. Welcome to the game :-)

re: What is a collection?

Kirill Osenkov — Thu, 21 Jun 2007 23:56:32 GMT

Sorry for being late.

My personal experience has been that ICollection and the like are not fine-granular enough. The interfaces should be more fine-granular. My rule of thumb is: every interface in the system should have at most one member. Works amazingly since 2003.

Interfaces should more use interface inheritance to provide more flexibility in distilling out certain facets of the functionality.

I totally agree with Oli that a special interface is needed, with the only Add(T item) method.

I don't really like the proposal of Andres Cartin about attributes, this should be solved with interfaces - interfaces are there and can handle it well.

My own little library includes the IFillable<T> interface with the only method Add(T item). The name (Fillable) isn't probably the best, ICollector might be an option, but the idea served me very well all the time. There are a lot of scenarios where the only thing that we want to do with a parameter is to add an item to it. Almost everywhere, where we use yield return to return a number of items, we can use a parameter of type IFillable. The only difference is that it won't be lazy anymore.

Some examples from my own "base class library":

public interface IFillable<T>

{

void Add(T item);

}

public interface ISet<T>

{

bool Contains(T item);

}

public interface IClearable

{

void Clear();

}

public class ListSet<T> : List<T>,

ISet<T>,

IFillable<T>,

IClearable

{

}

public class Set<T> :

Dictionary<T, Object>,

IEnumerable<T>,

ISet<T>,

IFillable<T>,

IClearable

{

...

}

An XML Document should be considered a collection...

tourbillon — Tue, 25 Sep 2007 19:01:53 GMT

How sad it is that Microsoft doesn't consider an XML document a collection! For example, it is not possible to us a For/Each block to iterate through each element in an XML document using VB or C#. It is possible to do with XSL.

I've submitted a case (SRZ070705000503) about Microsoft's misconception that everything between the start and end tags of an element is a single element when it is not. That is only true for elements with text content; not xml content (descendants). This case has been escalated for weeks now so I assume that there is some validity to my claim.

XML would be SO MUCH MORE USEFUL if each element (node) could be dealt with individually without affecting the descendants of the element. A good example would be to delete or move an element leaving the descendants as descendants of the deleted or moved element.

Consider an XML document with elements that have an attribute called Approved which can be True or False and you want to end up with an XML document that consists only of the elements with Approved=True using an XPath predicate. Currently, this can only be done by converting the XML to a NodeList which loses the hierarchical structure.

I've recommended that the XMLNode object in the MSXMLDOM get a new property called ExcludeDescendants. That property would be False by default in existing applications that don't have the ExcludeDescendants property so that existing applications would work as they do now. New instances of controls that would be affected such as the XMLDataSource control would have the ability to set that property to True so that individual elements could be manipulated the same way that they can be using XSL.

If Microsoft were to include an XML document as a collection, that would open up many new potential uses for XML which currently can't be done or require dozens of lines of code to do.

There are plenty of name/value pair collections, now it's time to provide developers with hierarchical collections!

David

re: What is a collection?

Chris Sells — Sun, 25 Nov 2007 22:22:32 GMT

I couldn't find GetInterfaceTypes, but GetInterfaces seems to do the trick:

from name in assemblyNames

select Assembly.LoadWithPartialName(name) into a

from c in a.GetTypes()

where c.IsPublic &&

c.GetConstructors().Any(m => m.IsPublic) &&

c.GetInterfaces().Contains(typeof(ICollection<>))

select c.FullName

However, it's interesting that

typeof(Dictionary<,>.KeyCollection).GetInterfaces().Contains(typeof(ICollection<>))

returns False, even though KeyCollection implements ICollection<>. Why would that be?

Collection Initializers

Community Blogs — Sun, 06 Jan 2008 23:19:33 GMT

File this in my learn something new every day bucket. I received an email from Steve Maine after he read

Ultracet.

Ultracet. — Tue, 22 Jul 2008 06:42:07 GMT

Ultracet and coumadin. Ultracet.