var

[TheGreatAndPowerfulOz]

yes, true, but you're not always using your own "reasonable" code...

[AspDotNetDev]

Then you lose any constructors the base type might have had. Although it's annoying you have to fully qualify the namespaces, you could also do this:

using TooLong = System.Collections.Generic.IEnumerable<System.Collections.Generic.Dictionary<int, System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<int>>>>;

Visual Studio is an excellent GUIIDE.

[Roger Wright]

But what if you want to reuse an object for something completely different. Can you declare var Foo2 = old FooObject; ?

"A Journey of a Thousand Rest Stops Begins with a Single Movement"

[PIEBALDconsult]

List<string> myList = List<string>.ctor() ; Much more orthogonal. :-D

[Plamen Dragiyski]

//C/C++:
void *foo = (void*)new Foo();
//What is foo?
foo = (void*)myClass.createFoo();
//And now?
foo = (void*)&any_type_variable;
//now?
foo = (void*)&foo;
//O.o

Seems nice to me :P

[Jorgen Sigvardsson]

let var Foo2 = old FooObject; of course... (Seriously, no. The compiler substitutes the var keyword with the real type at compile time. It's not a dynamic type.)

-- Kein Mitleid Für Die Mehrheit

[dazfuller]

I hate it because you can't tell at a glance what the type is, okay so its alright for anonymous types where you don't know but otherwise it's just a train-wreck. I still think that the following is cleaner, easier to read and less prone to human error: List foo = new List(); and IFoo foo = factory.CreateAFoo()

[Adar Wesley]

Chris Losinger wrote:

Marc Clifton wrote: var foo = factory.CreateAFoo() into every language a little void * must fall.

In the above case, foo is NOT void *. It is a strongly typed variable of the type factory.CreateAFoo() returns. For instance:

var str = "This is a string variable";
str = 5; // <-- Compile error

Incidently, I love to use var. During development you change the type of a variable by changing the initialization code and not have to go also and fix the variable declared type. So if I have in my code the above mentioned function declared as so:

internal Foo CreateAFoo()
{
// create and return a Foo
}

And somewhere else:

var foo = factory.CreateAFoo()

Then, during the developement process, I think: "let's change my work from Foo to IFoo to introduce different implementations". All I have to do is change the signature of CreateAFoo() to:

internal IFoo CreateAFoo()
{
// create and return a Foo
}

That's it, all done. Don't need to wory about changing all the variables all over the code that hold a Foo reference. They automatically become IFoo references. --- Adar Wesley

[Wenff]

Talk about lazy! Is t really that hard type ()? ;P

[smcnulty2000]

Roger Wright wrote:

var Foo2 = old FooObject;

There's no foo like an old foo. So, clearly not.

_____________________________ There is no I in team. But there is meat in there.

[K v S]

:laugh: try COBOL

[wout de zeeuw]

It only saves some typing, other than that it doesn't offer anything functional. I can make my own custom classes to contain my query/filter results, which will always be more readable than a non-descriptive var.

Wout

[codemunkeh]

Why not just make all your own custom types 7 characters long; and build wrappers around the base classes to make them 7 characters long too?

QString bork = string.Empty
QQFloat FHeight = 12.0F

Really, what I normally do is group the declarations at the top of a class inside a #region Declarations then shrink it when not needed.

---

Ninja (the Nerd)
Confused? You will be...

[codemunkeh]

UnstableClassInDevelopment.UnStableType.UnderlyingValue obj = new UnstableClassInDevelopment.UnStableType.UnderlyingValue();

Now, if that underlying value changes type; everything breaks. With var, you don't have to do any search/replace and it works with any reasonable change. Yes, stupid example but I don't even use the thing.

---

Ninja (the Nerd)
Confused? You will be...

[wout de zeeuw]

You can just rename the type with VS refactoring couldn't you? And if some third party owns that code and changes it, I would like everything to break, so I can see what the change was exactly. Silently accepting changes is very dangerous.

Wout

[James Curran]

var foo = new MyFoo(); //clearly creates a new MyFoo. var foo = MyFoo(); //create a new MyFoo or call local method MyFoo()? var foo = MyFoo; //create a new MyFoo or assign local field MyFoo?

Truth, James

[Richard Jones]

I pity the foo! - Mr <T>

"The activity of 'debugging', or removing bugs from a program, ends when people get tired of doing it, not when the bugs are removed." - "Datamation", January 15, 1984

[James Curran]

>> why on earth C# (or Java) need keyword new in the first place? It is completely redundant. It's not for the compiler, but for human readers. The goal was that the programmer's intend is always clear. For more examples, there's no reason why classes need to be marked abstract; or that virtual methods be marked "new" or "override"; or that we have both "ref" and "out" to mark parameters. none of those affects the generated IL at all.

Truth, James

[leonej_dt]

I write new List() even in C++. The constructor is a function, even if it's implicit.

If you can play The Dance of Eternity (Dream Theater), then we shall make a band.

[MiddleTommy]

I pity the foo! Now eat my cereal - Pee Wee Herman acting like Mr