Duck typing in the C# compiler

by

There’s nothing special about IDisposable here – but there is something special about iterators.

Before C# 2, using this duck type on foreach was the only way you could implement a strongly-typed iterator, and also the only way of iterating over value types without boxing. I suspect that if C# and .NET had had generics to start with, foreach would have required IEnumerable<T> instead, and not had the duck typing.

Now the compiler uses this sort of duck typing in a couple of other places I can think of:

  • Collection initializers look for a suitable Add overload (as well as the type having to implement IEnumerable, just to show that it really is a collection of some kind); this allows for flexible adding of single items, key/value pairs etc
  • LINQ (Select etc) – this is how LINQ achieves its flexibility, allowing the same query expression format against multiple types, without having to change IEnumerable<T> itself
  • The C# 5 await expressions require GetAwaiter to return an awaiter type which has IsCompleted / OnCompleted / GetResult

In both cases this makes it easier to add the feature to existing types and interfaces, where the concept didn’t exist earlier on.

Given that IDisposable has been in the framework since the very first version, I don’t think there would be any benefit in duck typing the using statement. I know you explicitly tried to discount the reasons for having Dispose without implementing IDisposable from the discussion, but I think it’s a crucial point. There need to be good reasons to implement a feature in the language, and I would argue that duck typing is a feature above-and-beyond supporting a known interface. If there’s no clear benefit in doing so, it won’t end up in the language.

More Related Contents:

  1. Proper use of the IDisposable interface
  2. Should I call Close() or Dispose() for stream objects?
  3. implicit operator using interfaces
  4. Should you implement IDisposable.Dispose() so that it never throws?
  5. Dispose, when is it called?
  6. How do I dispose my filestream when implementing a file download in ASP.NET?
  7. Async network operations never finish
  8. Delegate caching behavior changes in Roslyn
  9. What happens if i return before the end of using statement? Will the dispose be called?
  10. yield return statement inside a using() { } block Disposes before executing
  11. How does creating a instance of class inside of the class itself works?
  12. Questions about Entity Framework Context Lifetime
  13. Does foreach automatically call Dispose?
  14. C# compiler bug? Why doesn’t this implicit user-defined conversion compile?
  15. Is it possible to force the use of “using” for disposable classes?
  16. What is IDisposable for?
  17. Could not load file or assembly … The parameter is incorrect
  18. When should I use GC.SuppressFinalize()?
  19. Who should call Dispose on IDisposable objects when passed into another object?
  20. What is the difference between using and await using? And how can I decide which one to use?
  21. ‘CompanyName.Foo’ is a ‘namespace’ but is used like a ‘type’
  22. When or if to Dispose HttpResponseMessage when calling ReadAsStreamAsync?
  23. Guidelines For Dispose() and Ninject
  24. TargetedPatchingOptOut: “Performance critical to inline across NGen image boundaries”?
  25. Why is the binary output not equal when compiling again?
  26. Why can’t I use the array initializer with an implicitly typed variable?
  27. Why does this (null || !TryParse) conditional result in “use of unassigned local variable”?
  28. C# – Value Type Equals method – why does the compiler use reflection?
  29. C# Compiler should give warning but doesn’t?
  30. Is it possible to install a C# compiler without Visual Studio?

Leave a Comment