

C# has var now? - jebblue
https://msdn.microsoft.com/en-us/library/bb383973.aspx

======
thelastguy
Var just makes it harder to read C# code. For example, the difference
between...

int foo = object.GetSomething() vs var foo = object.GetSomething()

The int makes it easy for you to instantly identify that foo is an integer. In
the var example, what the fuck is foo? A string? A class? An integer? To find
out, you must rely on Visual Studio's Intellisense and hover your mouse over
foo for a few secons, before Visual Studio will tell you what type foo is.
This slows your code reading considerably. And if you don't have Visual
Studio, then you have to go waste time reading the documentation to figure out
what type foo is.

Sure, it save your typing time, but, it waste other developer's reading time.

~~~
louthy
I see comments like this on var all the time, and I just don't understand the
problem. It just means that 'foo' and 'GetSomething' are poorly named. If you
had something like:

    
    
       var name = GetFullName();  
    

Then it's clear what's going on. If the code you're working with is so opaque
that you can't understand what's going on without looking everything up, then
the code is at fault, not a language feature. Especially as var is locally
scoped.

I personally use var all the time, as does my team. We never complain about
it. If you use something like F# where a lot of the time the types are
'invisible' then you'd see how powerful type inference can be. I for one hope
that C# goes much further with it; being so explicit about specifying types is
a major annoyance when the compiler knows what your intent is.

> And if you don't have Visual Studio, then you have to go waste time reading
> the documentation to figure out what type foo is.

Which you'd have to do nearly all the time anyway if you were using anything
that doesn't provide 'intellisense'. If you choose to use a text editor with
any language you need to look up the contract before use.

And lastly, it's needed if you're going to work with anonymous types.

Of course this is optional, so if there are times when there may be confusion
it's easy to be explicit. But most of the time there is no need.

~~~
thelastguy
Even in your "name = GetFullName();" example, there is still have the problem
of not knowing if object being returned is a Name object, or, a string,
because that method could have still returned an object of Name type, which
will have different methods from an object of string type. And then the
compiler complained when you try to pass the Name object into a method that
takes a string type, thinking that the Name object is a string.

Of course, as a programmer, you're suppose to read all the documentations,
etc. But the reason C# is attractive to me is the productivity gained in
ability to read source code very fast, due to the fact that C# enforced types,
making it very easy for me to know what type an object is at first glance,
without having to rely on Intellisence, even when the other programmers named
their methods badly.

------
jebblue
I'm trying my hand at getting back into some C# coding and found that
apparently the language now has var. My first thought was why would a
professional, statically typed language have var. Checking out the page I
linked to in the submission, you can also do this cool if not slightly funky
looking thing where it looks like an SQL predicate just reading from an
ordinary array.

~~~
louthy
The 'cool but funky' thing is LINQ. Language Integrated Query. It can be used
to query in-memory lists and arrays as well as build SQL to query a DB, or
even query XML files.

It is C#'s support for monads.

In terms of var. It's best not to think of it as dynamic like javascript. You
can't do this for example:

    
    
        var a = 123;
        a = "Hello";
    

The second line will throw an exception because 'a' is not a string, it's an
int. So it's not dynamic like JS. It simply infers the type when it can so
that you don't have to type it, otherwise its exactly the same.

Interestingly C# does have a dynamic aspect too, and that's with the 'dynamic'
keyword.

    
    
        dynamic x = 123;
        x = "Hello";
    

That will work where the var example wouldn't. It's a rarely used feature, but
comes in useful to avoid boilerplate when dealing with external 'stuff', like
XML files, JSON, or REST responses.

