var

[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

[Judah Gabriel Himango]

Ninja-the-Nerd wrote:

Why not just make all your own custom types 7 characters long;

Length isn't the issue.

Ninja-the-Nerd wrote:

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.

Me too. But var doesn't work for fields in a class. Only works for locals.

Religiously blogging on the intarwebs since the early 21st century: Kineti L'Tziyon Judah Himango

[grgran]

There is another side to this. That the example you gave of var foo = factory.CreateAFoo() and lets assume that CreateAFoo returns a IFoo interface. Now assume that at some point you add a new method to the interface can create a IFoo2 interface. You don't have to change your code. I like var ... less typing and if I can't easily figure out the type, then that tells me that the code needs a comment :-)

[JasonPSage]

Perhaps I'm daft, but you do need to indicate a consturctor - so as to call the default constructor and possibly others (with parameters or different name). However I do agree that var foo = some-type could cause default constructor invokation/object creation while the second example from the factory would work without new because you're in theory returning a pointer to an instanced object. Ultimately New does seem redundant to me, but you still need a clear semantic/syntax to be able to indicate default and potentially other constructor invocation for class/object creation --Jason

Know way too many languages... master of none!

[PIEBALDconsult]

Keywords like abstract not only show the intent, but enforce it as well.

James Curran wrote:

none of those affects the generated IL at all

Then how are they enforced when you refer to something in an assembly?

[PIEBALDconsult]

Hear hear!