.NET 2.0 features
-
Chris Maunder wrote:
Nullable types? I want to since they match up with nullable fields in databases so nicely, but the effort involved in retrofitting what I currently have just makes me cringe. It'll happen next clean-up iteration, but not today.
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.
Chris Maunder wrote:
They let you get something done quickly and without needing to bother anyone else, but they just scream out "quick and dirty" to me. Give the code the respect of at least having a name and a place to live.
*grin* That's exactly how I've always felt, but like I said, this one time I realised they fit my need, because the code in the method where they are created has scope for the method, and the timer needed to find, remove and destroy a control that the calling method had created. So, it made my code a fair bit simpler. I've always thought iterators where the best of the new features, but, like you, I've not needed them yet, excepting for one time I needed a method to randomise a collection. I'm surprised that's not in there ( or is it ? )
Christian Graus - Microsoft MVP - C++ Metal Musings - Rex and my new metal blog
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:
-
I like to know when the garbageman comes
Better him than the postman (who always ring three times, when you're not at home!)
-- Behold, for I am THE CORRUPTOR!
-
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
Judah Himango wrote:
I've found some interesting uses for them.
Those are a couple good examples. Thanks! Marc
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 -
I'm interested ( in light of the post below ) to know how many people have taken to the new 2.0 features ? We all use typed containers, I am sure, but how often do you use an anonymous method or iterators ? As I said on that thread, I used my first anonymous method, because it struck me as the ideal solution as I worked on it, before it's never seemed appropriate. I wonder if I'm just not in the habit yet, or this was truly the first time they were the right tool for the job. I love the idea of iterators, but I don't think I've used them in production code yet, and I imagine I need to look out for chances to change my mindset to be using them. How about you ?
Christian Graus - Microsoft MVP - C++ Metal Musings - Rex and my new metal blog
-
Better him than the postman (who always ring three times, when you're not at home!)
-- Behold, for I am THE CORRUPTOR!
no postman in my neighborhood, so no doorbell overuse :)
-
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 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
-
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
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
-
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
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 -
I'm interested ( in light of the post below ) to know how many people have taken to the new 2.0 features ? We all use typed containers, I am sure, but how often do you use an anonymous method or iterators ? As I said on that thread, I used my first anonymous method, because it struck me as the ideal solution as I worked on it, before it's never seemed appropriate. I wonder if I'm just not in the habit yet, or this was truly the first time they were the right tool for the job. I love the idea of iterators, but I don't think I've used them in production code yet, and I imagine I need to look out for chances to change my mindset to be using them. How about you ?
Christian Graus - Microsoft MVP - C++ Metal Musings - Rex and my new metal blog
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.
-
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 constraintThanks for the clarification! Much obliged. :)
-- Touch eyeballs to screen for cheap laser surgery