.NET 2.0 features

[Christian Graus]

Marc Clifton wrote:

Are these things you've written, or using the visualizers already in the debugger?

Hah !!! The ones provided are useless. Why no bitmap visualiser ?

Christian Graus - Microsoft MVP - C++ Metal Musings - Rex and my new metal blog

[Judah Gabriel Himango]

CG, I have a huge library of classes that work on generic IEnumerable<T> and ICollection<T>; the whole library depends heavily on anonymous methods, in particular, Action<T> or Predicate<T> anonymous methods, and heavily relies on yield return iterators. Those things are so dang cool; the delayed execution opens up some interesting possibilities that didn't previously exist. I use the things for flattening hierarchies (yield returning the whole hierarchy recursively), returning an unknown set of results (say, any number matching some criteria specified by a Predicate<T> ), lots of cool stuff. :cool: So for me, of course generics is the great enabler and tops my usage list. Shortly after comes anonymous methods, then yield returns. All excellent features very useful in their current state. C# 3 builds heavily on these by introducing things like LINQ, lambda expressions, both of which use anonymous methods and yield returns under the hood.

Tech, life, family, faith: Give me a visit. I'm currently blogging about: And in this corner, the Party of Allah The apostle Paul, modernly speaking: Epistles of Paul Judah Himango

Last modified: Monday, August 14, 2006 9:39:31 PM --

[Judah Gabriel Himango]

Jörgen Sigvardsson wrote:

it still has to "copy" for each new instantiation of the generic

Actually that's not true for .NET generics. For performance reasons, it will create a new instantiation for each value type (IntList, DoubleList, BoolList, etc) but for reference types (StringList, ObjectList, MyFooList) it uses only a single in-memory instantiation that works on reference types. :cool:

Tech, life, family, faith: Give me a visit. I'm currently blogging about: And in this corner, the Party of Allah The apostle Paul, modernly speaking: Epistles of Paul Judah Himango

[Judah Gabriel Himango]

click.ok wrote:

Now I wish a collection of MyBox objects, but I can't.

I agree with Jorgen, this really isn't an issue if you use generics/templates correctly IMO.

click.ok wrote:

Another problem is the ?? operator and the Nullable notation (int?, string?, etc). How I can have problems using these together, I ever use Nullable instead...

I'm not sure what you're talking about. int? and double? is the same as Nullable<int> and Nullable<double>. You can use the ?? syntax on any nullable type, including Nullable and reference types.

click.ok wrote:

I will use iterators when I have nothing more important to do...

Man, you're missing out my friend. :) yield return rocks, and allows one to achieve things previously very difficult to do. If you haven't checked them out, I'd love to show you some cool possibilities yield return opens up for you.

Tech, life, family, faith: Give me a visit. I'm currently blogging about: And in this corner, the Party of Allah The apostle Paul, modernly speaking: Epistles of Paul Judah Himango

[Super Lloyd]

I think I use them all regularly. At least I'm using lots of: - generic (I had an unpleasant surprise a while ago: MyClass and MyClass have nothing in common! other than that they are cool). - anonymous delegate are great! (in fact I get used to the like of them in Java 2.0) - iterator. real cool once I understood I was not limited to GetEnumerator() but can be used to define all sorts of methods - myEvent += myMethod or myEvent += delegate(){..} (omitting the new EventHandler()) is great! - I use Nullable type quite less often, but they do come handy sometimes. And, most of all, I love the new Managed C++ 2.0, much less ambiguous and verbose than C++ cli 1.0 That's it... did I miss something? :~

[Judah Gabriel Himango]

Jörgen Sigvardsson wrote:

Do you know if yield can handle non-linear collections such as dictionaries?

Yeah, you can iterate over any IEnumerable, including Dictionary<T>, and yield return anything you want from them. Iterators are actually very cool; they're somewhat a form of continuations the functional programming world knows well. Basically they let you return pieces of information on-demand rather than upfront: for example, you could yield return all even numbers. The beauty is that the code itself doesn't get executed until actually needed; so instead of waiting for a function to create a huge array containing all even numbers, consumers simply start iterating over your function's result and immediately get a result back. Each iteration will go to the next yield return; thus allowing all sorts of amazing possibilities previously unique to functional programming. IMO, iterators are a great feature in the language. Very cool stuff. :cool:

Tech, life, family, faith: Give me a visit. I'm currently blogging about: And in this corner, the Party of Allah The apostle Paul, modernly speaking: Epistles of Paul Judah Himango

[Judah Gabriel Himango]

Marc Clifton wrote:

Nullable types are utterly useless

I've found some interesting uses for them. One recent thing I've been throwing around is lazy initialization of a value type. Say you've some integer that is only retrieved once, but that one-time retrieval requires a lot of work. So you get the value and store it later, right? Without nullables, you might do something like:

bool hasRetrievedFoo;
int foo;

...

public int Foo
{
get
{
if(!hasRetrievedFoo)
{
this.foo = DoSomeWorkToGetFoo();
this.hasRetrievedFoo = true;
}
return this.foo;
}
}

It's not much, but with nullable we can eliminate the need for the boolean field.

int? foo;
...
public int Foo
{
get
{
if(foo == null)
{
foo = DoSomeWorkToGetFoo();
}
return foo.Value;
}
}

The code is now more concise with fewer lines to accomplish the same task. Another thing I've found them useful for is in my data layer, calling stored procedures that take nullable parameters or returns nullable fields. Unfortunately you have to map DBNull to Nullable<T>, but that's better than the hack we used to have to do without nullables.

Tech, life, family, faith: Give me a visit. I'm currently blogging about: And in this corner, the Party of Allah The apostle Paul, modernly speaking: Epistles of Paul Judah Himango

[Steve Echols]

Judah Himango wrote:

yield return rocks, and allows one to achieve things previously very difficult to do. If you haven't checked them out, I'd love to show you some cool possibilities yield return opens up for you.

Excuse my ignorance, but what does "yield return" mean and why does it rock?

---

- S 50 cups of coffee and you know it's on!

[Steve Echols]

Judah Himango wrote:

Basically they let you return pieces of information on-demand rather than upfront: for example, you could yield return all even numbers. The beauty is that the code itself doesn't get executed until actually needed; so instead of waiting for a function to create a huge array containing all even numbers, consumers simply start iterating over your function's result and immediately get a result back. Each iteration will go to the next yield return; thus allowing all sorts of amazing possibilities previously unique to functional programming.

Ah, I get it now, never mind - I should've read this whole post, before posting above. That does sound pretty cool. I can think of some date/time recurrency functions where this could be useful.

---

- S 50 cups of coffee and you know it's on!

[AntonGogolev]

Something like that: using System; using System.Collections.Generic; namespace ConsoleApplication1 { class Program { public static IEnumerable GetAllDivisibleBy(int denominator, int maximumValue) { for(int value = 1; value < maximumValue; ++value) if(value % denominator == 0) yield return value; } static void Main(string[] args) { foreach(int value in GetAllDivisibleBy(7, 61)) Console.WriteLine(value); } } } And the output is 7, 14, 21, and so forth. What is really interesting, is how it looks like in the compiled code (fire up Reflector and take a look). Here's an extract: [CompilerGenerated] private sealed class d__0 : IEnumerable, IEnumerable, IEnumerator, IEnumerator, IDisposable { // Methods [DebuggerHidden] public d__0(int <>1__state); private bool MoveNext(); [DebuggerHidden] IEnumerator IEnumerable.GetEnumerator(); [DebuggerHidden] IEnumerator IEnumerable.GetEnumerator(); [DebuggerHidden] void IEnumerator.Reset(); void IDisposable.Dispose(); // Properties int IEnumerator.Current { [DebuggerHidden] get; } object IEnumerator.Current { [DebuggerHidden] get; } // Fields private int <>1__state; private int <>2__current; public int <>3__denominator; public int <>3__maximumValue; public int 5__1; public int denominator; public int maximumValue; }

[S Douglas]

Christian Graus wrote:

Yeah, I use them a fair bit, for situations where my own code holds a number, but would otherwise need a 'magic' non-valid value like -1.

I was just beginning to wonder if I was on the wrong path. Gladly I can see I'm not the only one to initialize to an invalid number and check for that (not that I use any managed code).

---

I'd love to help, but unfortunatley I have prior commitments monitoring the length of my grass. :Andrew Bleakley:

[Jorgen Sigvardsson]

Better him than the postman (who always ring three times, when you're not at home!)

-- Behold, for I am THE CORRUPTOR!

[Marc Clifton]

Judah Himango wrote:

I've found some interesting uses for them.

Those are a couple good examples. Thanks! Marc

XPressTier

Some people believe what the bible says. Literally. At least [with Wikipedia] you have the chance to correct the wiki -- Jörgen Sigvardsson
People are just notoriously impossible. --DavidCrow
There's NO excuse for not commenting your code. -- John Simmons / outlaw programmer

[Member 96]

Just the new collection classes so far, but I went to 2 in the middle of a big project started in 1.1. For anything new I'll embrace as much of it as makes sense.

[RC_Sebastien_C]

no postman in my neighborhood, so no doorbell overuse :)

[Jorgen Sigvardsson]

Judah Himango wrote:

it uses only a single in-memory instantiation that works on reference types. :cool:

Ah, yes, the Object root. I keep forgetting about it. (Probably because I use C++ everyday :))

-- If not entertaining, write your congressman

[Jorgen Sigvardsson]

Hmmmmm! Wait a minute. How can that work? Suppose I have this: (bear with me, I'm not fluent in generics syntax)

template <typename T> class SomeClass {
public void DoSomething(T obj) {
obj.SomeMethod();
}
}

class X {
public void SomeMethod() { }
}

class Y {
public void SomeMethod() { }
}

SomeClass<X> anObject = new SomeClass<X>();
anObject.DoSomething(new X());
SomeClass<Y> yetAnotherObject = new SomeClass<X>();
anObject.DoSomething(new Y());

Since classes X and Y are not directly related, how does SomeClass.DoSomething() call the correct method? Are method calls in MSIL made by method name lookup?

-- This Episode Has Been Modified To Fit Your Primitive Screen

[Judah Gabriel Himango]

Jörgen Sigvardsson wrote:

how does SomeClass.DoSomething() call the correct method? Are method calls in MSIL made by method name lookup?

In short, in CLR generics, I can only put a SomeMethod call in there if T is guaranteed to have a SomeMethod() method. I can guarantee such by using interfaces (kind of like C++ pure abstract classes, except no implementation). This is a key difference between C++ templates and CLR generics; one reason why C++ templates are more powerful simply because they are a compile-time mechanism (which is fine, since C++ doesn't interop templates with other languages, since they get compiled down to real class instances with the real object in place of T), whereas CLR generics are more limiting because they are runtime-instantiated and are supported across disparate languages; they don't get compiled down to new SomeClass instances, with your type replacing T. Such deep runtime support of generics has some benefits: - we can do things like expose generic instances, say a List<int> to all other .NET assemblies, be they C#, VB.NET, IronPython, C++/CLI, etc. - we can use reflection to investigate, at runtime, the type of a List<T> instance and it will correctly give back a List<int> type in this case. This is something Java's generics fail to do, since Java generics are entirely syntax candy, no runtime support. But putting generics in the runtime also has some limitations: In C++, if there isn't SomeMethod on the template instance you've instantiated, you get a compile-time error. But for CLR generics, the compiler simply will not let you put in a method call into a generic class if the type doesn't support that method. And since the generic class type is, by default, System.Object as you mentioned, there is no SomeMethod on System.Object. To get around this, the CLR has what's called a constraint. You can constrain the T in the generic class to any object that supports some interface, that inherits from some type, or has a default constructor, or is a value type, and so on. Lots of constraint possibilities. If I wanted to achieve what you posted in the above C++ code, you'd do it like this:

interface ISomeMethod
{
void DoSomething();
}

class SomeClass<T>
where T : ISomeMethod // Only allow this generics class to be used with an object that implements the ISomeMethod interface.
{
void DoSomething(T obj)
{
obj.DoSomething(); // this works, because of the constraint

[Stuart Dootson]

Well - I don't use .NET, I use C++ with Boost[^], but I make use of the Boost equivalents of iterators[^] and anonymous functions[^]. Iterators are for anything that has a concept of enumerability (mostly files of wacky formats for me). As an example - I have an application where I have to read a big-endian file. So, I wrap up a file iterator and a byte reverser together and I get an iterator that gives me little endian results (joy!). I use anonymous methods pretty much wherever I use Standard Template Library algorithms. Also, in conjunction with generic function objects[^] - customising some functionality by passing in an adapted function.

[Jorgen Sigvardsson]

Thanks for the clarification! Much obliged. :)

-- Touch eyeballs to screen for cheap laser surgery