var

[Michael Dunn]

Stuart Dootson wrote:

Does the 'crusty old' relate to you or C++?

It works either way. :-D

Stuart Dootson wrote:

(((crusty old) C++) guy)!

Do we allow Lisp in here now? ;)

--Mike-- Dunder-Mifflin, this is Pam

[wout de zeeuw]

Yes.

Wout

[Nish Nishant]

Marc Clifton wrote:

var foo = factory.CreateAFoo() That's where I despise seeing a "var"!

Well if both the variable and the factory method are named properly, I don't think there'd be any confusion here. If they are not, then using var would be the least of the issues here.

Regards, Nish

---

Nish’s thoughts on MFC, C++/CLI and .NET (my blog)
My latest book : C++/CLI in Action / Amazon.com link

[TheGreatAndPowerfulOz]

no, the point was more to be able to have anonymous types and also in foreach and other like constructs where the type info can be combersomely unwieldy to have something more readable and understandable.

[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