28 ms·

.NET Framework – What's New in C# 7.0

234 points by kukx 10y ago

muterad_murilax 10y ago
Minor nitpick: the title is (edit: was) missing a leading dot.
netcraft 10y ago
So, lets say someone had never worked with C# or .net before and works on a mac - where would you go to get started building a small server application? I assume you would use the .net core stuff? and visual studio code? Any good tutorials for noob-to-the-ecosystem but someone that has programming experience?
- annerajb 10y ago
  Microsoft has great .net core tutorials Here is one just for your usecase: https://docs.microsoft.com/en-us/aspnet/core/tutorials/your-first-mac-aspnet https://docs.microsoft.com/en-us/aspnet/core/tutorials/your-...
- te_platt 10y ago
  Get Xamarin. You can start doing OS X apps with C# right away. They have a lot of tutorials on their website.
- merb 10y ago
  > https://www.visualstudio.com/vs/visual-studio-mac/ https://www.visualstudio.com/vs/visual-studio-mac/ It bundles everything you need. And for the tutorial you can check links from other people.
- stdgy 10y ago
  This is what I've run through: https://docs.microsoft.com/en-us/aspnet/core/tutorials/your-first-mac-aspnet https://docs.microsoft.com/en-us/aspnet/core/tutorials/your-... It's nice. I went on to modify and hack with what I created to form it into a back end for a mobile app I'm playing around with. There are still some warts in the process (Namely just figuring out how everything fits together and which packages to import) but I've been pleasantly surprised. It looks like the new Visual Studio for Mac (ie An updated Xamarin Studio) has an ASP.Net Core template. At least I thought I saw that on the live stream earlier today. Might want to check that out!
- ldev 10y ago
  I'm using https://www.jetbrains.com/rider/ https://www.jetbrains.com/rider/ for an IDE in macOS. It's early access preview, but each build fixes a lot of bugs and is usable.
alexro 10y ago
Are we back to the 90-ties with no code highlights in text?
- mattmanser 10y ago
  Yeah, it's particularly bad on mobile too as the code is auto-wrap so the code 's utterly illegible. Nice blog post, shame about the bloody awful presentation.
- jdmichal 10y ago
  The markup actually does have coloring. However, there's a CSS rule that's overriding them all back to black. How strange.
  - redwards510 10y ago
    Yeah, I just came to say this. Here's the code, with obvious color markers. http://i.imgur.com/91dFyRr.png http://i.imgur.com/91dFyRr.png
    - redwards510 10y ago
      fix: .codeSnippetContainer span { /* color: #000 !important; */ }
louthy 10y ago
Throw expressions are particularly welcome. I'd previously dealt with that issue by creating a static method that returned the expected type, but just threw an exception [1][2] I'm not sure it's explicit in the blog, but it seems the deconstructor will be useful for pattern-matching using 'is'. Tuples. Yay! Finally! Pattern-matching-switch-statement: Not an expression. That's a bad call. We have expression based ternary, throws, method bodies, and LINQ; switches are the last and most painful omission. Local functions: Fantastic for libraries like mine, which is trying to bring functional programming to the C# world, but takes a hit with the allocation of delegates for common operations [3] It should be a boon for anything LINQ based (implementations, rather than usage). Return by ref and out parameters: I'd be happy if they just removed them from the language. Ugly, error magnets. All in all, good progress. Hopefully they can make more progress on facilitating expression-based programming, and bring in record types for the next release. The pain of creating immutable types is truly tedious. And I'd desperately like to see partial generic parameter specifying (for when one of the generic arguments can't be inferred by the type-system, so you then end up having to specify them all). [1] https://github.com/louthy/language-ext/blob/master/LanguageExt.Core/Prelude.cs#L209 https://github.com/louthy/language-ext/blob/master/LanguageE... [2] https://github.com/louthy/language-ext/blob/master/LanguageExt.Core/Prelude.cs#L182 https://github.com/louthy/language-ext/blob/master/LanguageE... [3] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Core/TypeClasses/Monad/Monad.Prelude.cs#L70 https://github.com/louthy/language-ext/blob/type-classes/Lan...
- moogly 10y ago
  Fully agreed on pattern matching not being an expression. I really dislike that syntax overall. I get the reluctance to introduce new keywords (though this did introduce 'when', but I suppose it's contexual at least), but trying to shoehorn pattern matching into the, um, let's be nice and call it "venerable", old switch/case does not look very ergonomic at all. And I don't know about you, but I rarely switch over polymorphic types these days, I mostly switch over values, so the pattern matching overall is way less useful to me without records/discriminated unions. I guess you can't really remove 'ref' and 'out' due to interop. Maybe the ref returns stuff will be nice if we get more performant string/array views in the next version, and I do like the inline 'var out'. I also want type inference for field declaration+initialization, but I think Eric Lippert once explained why that was a difficult problem to solve, albeit I can't remember the reason.
JamesBarney 10y ago
Kinda surprised me Microsoft doesn't have better syntax highlighting on msdn. The lack of coloration and gray background gave me a little bit of a headache.
- Analemma_ 10y ago
  It's especially baffling because they clearly have a great web formatting library for code (Monaco): http://www.typescriptlang.org/play/ http://www.typescriptlang.org/play/. Why not use it?
- msbarnett 10y ago
  Coupled with the wrapping, paucity of line breaks, and (near lack of) indentation, the examples are damn near unreadable.
- jdmichal 10y ago
  The markup actually does have coloring. However, there's a CSS rule that's overriding them all back to black. How strange.
- mathw 10y ago
  It is rather baffling. They have an amazing online code browsing tool they use for the reference source of the .NET Framework (enormously useful for figuring out all the details they don't bother to document and the type system can't express), but they aren't applying that tech more universally. The blog platform particularly suffers for it.
- ungzd 10y ago
  MSDN (web version, maybe desktop app still exists, I don't know) still has very poor usability. Recently I decided to try .NET and was surprised how painful MSDN is (compared to almost any other documentation website). Page load times of 5-10 seconds, poor navigation (2-3 link clicks just to get to list of class methods). Does anyone know any alternative .NET documentation viewers (usable without Visual Studio and Windows)?
redwards510 10y ago
Can someone give an example of a use case for a Deconstructor?
- SloopJon 10y ago
  var (r, g, b, a) = pixel
  - sergiotapia 10y ago
    Looks a lot like Elixir's pattern matching to extract values from maps. someMap = {1, 2} {foo, bar} = someMap foo # 1 bar # 2
    - int_19h 10y ago
      This is destructuring assignment, as practiced by many languages before. Pretty much anything in the ML family, for example.
- Leszek 10y ago
  var (ret, err) = Foo(); if (err != null) { ... }
  - taco_emoji 10y ago
    So Foo() has to return a class which has a destructor? Seems like just returning a Tuple would be better in that case.
    - truncate 10y ago
      Tuple in C# is a class IIRC. Without destructor, you will have to pull out individual members separately. For example for a tuple of form <Int, Int, Int>, you will do something like `var r = c.getFirst(); var g = c.getSecond();`. With deconstructor, you can do the same via `var (r, g, b) = color;`. In other words, you can say that tuples are way to combine data, while deconstructors tell how to explode it. Since these deconstructors are themselves functions, you can do computation each time, and get different results due to side-effects (probably not good idea). EDIT: I don't know C#, so syntax is definitely not right.
markatkinson 10y ago
It puts a smile on my beak that I am a budding (sort of) .Net and C# developer. Microsoft seems to be really jacked up and introducing some very forward thinking functionality into their ecosystem. Been playing with Azure Service Fabric. It is super impressive.
- xorxornop 10y ago
  Yeah, Service Fabric is super awesome! I'm refactoring out company's infrastructure to run on it currently - the older stuff runs on MVC 5 on Azure Cloud Service. I'm refactoring it to ASP.NET Core on Service Fabric. Getting about 50x better real-world performance. Yes, that much. It's insane. Currently on Windows as Service Fabric on Linux is in preview (not comfortable using it in production), but I imagine I'll move it over once that's stable ️ A great time to be a .NET developer! Makes me happy I stuck with it.
jdmichal 10y ago
I'm a little disappointed that pattern matching doesn't simply narrow the variable, and instead requires a new variable name to hold the narrowed type. Even TypeScript narrows the variable in-place!
- louthy 10y ago
  You may want to deconstruct the value and use the original base value. This seems entirely logical, and consistent with most implementations in functional languages (and I'd say makes TypeScript's implementation the poor one - although I haven't seen it myself to have an opinion on).
  - naasking 10y ago
    > You may want to deconstruct the value and use the original base value. I think this is exactly right. Members can be declared visible only when viewing an object through a particular supertype, and you may simultaneously need to invoke methods from the supertype and the subtype.
  - int_19h 10y ago
    Thing is, in most cases, you don't want to do that. You just want to narrow the type. It's unfortunate that this isn't readily possible even by explicitly reusing the name - C# shadowing rules for locals preclude it. So you can't do something like `if (x is int x) { ... }`.
- dested 10y ago
  I believe this would cause a change in the CLR as opposed to just syntax sugar. It's less of an issue for typescript since all type information is erased at runtime.
  - ygra 10y ago
    The CLR doesn't care, it doesn't see the C# code and the compiler could just as well emit another local for the narrowed variable. The language semantics here don't really depend on what the CLR does.
zilchers 10y ago
Is it just me, or is C# basically becoming Scala (or, insert your favorite functional language here). Don't get me wrong, this is awesome, .net on Linux, dockerized, is all good, but these moves definitely show Microsoft responding to market changes in a way they didn't used to.
- stupidcar 10y ago
  C# first introduced lambdas and LINQ in v3, back in 2007. It was the first mainstream OO language to really push a more functional/mixed-paradigm approach. This is definitely an area where Microsoft has lead the market, not followed it.
  - louthy 10y ago
    They may have been the first, and LINQ was (and is) a truly great feature (I'd love it if they'd expand the grammar, or allow computation expressions like F#); but the problem I've found with trying to do functional programming in C# is that there's no BCL support. Whereas F# has its functional prelude. I haven't spent much time with Scala, but I get the impression that a lot of the functional stuff is there by default (or at least easily accessibly via Scalaz) and therefore less inertia is needed to write functionally in Scala. Even with LINQ most C# programmers think it's just for querying databases or XML files, they don't realise they have built in monad semantics. I found that I'd have an immutable collections library over there, that wasn't aware of the Option type in that library over there. (So Map.Find(key) couldn't return an Option<V> for example - this makes composition more difficult). So although the language has been steadily going in the right direction, there has been less of a concerted effort on the library front. And therefore C# is still behind IMHO. This is something I've been trying to rectify, by essentially building a functional BCL [1]. I welcome the increased pace of functional features recently. Although sometimes it's frustrating seeing the direction they're going and wishing they'd get there much quicker (expressions everywhere, sum-types, record-types, better type inference). It's interesting that often C# is held up for its inability to do type-classes or ad-hoc polymorphism. But it is in fact possible with C# today [2] [3], and with zero cost (i.e. no reflection, additional memory allocations, or side-stepping of the type-system). It just causes a massive head-ache of manually provided generic arguments... [4] [5] I'd love it if the Roslyn team took some time to deal with the generic parameters inference story. It would help bring ad-hoc polymorphic types to C#, but it would just be awesome in general. [1] https://github.com/louthy/language-ext https://github.com/louthy/language-ext [2] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Tests/TypeClassMonad.cs https://github.com/louthy/language-ext/blob/type-classes/Lan... [3] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Tests/TypeClassMonoid.cs https://github.com/louthy/language-ext/blob/type-classes/Lan... [4] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Core/TypeClasses/Monad/Monad.Prelude.cs#L70 https://github.com/louthy/language-ext/blob/type-classes/Lan... [5] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Core/DataTypes/Option/Option.cs#L780 https://github.com/louthy/language-ext/blob/type-classes/Lan...
stuartd 10y ago
'goto case' is a thing? I'm so going to have fun with that
- int_19h 10y ago
  It has always been a thing. The original C# design was to take the C switch statement as is, but tighten it up to avoid crazy stuff like Duff's device, and to make non-obvious implicit things explicit. Consequently, C# requires that control flow provably cannot reach the end of any non-empty case block (to avoid implicit fallthrough that normally happens in C, Java etc). Normally this means that you must use `break` (or something else that transfers control, like `continue`, `throw` or `return`). But fallthrough is actually useful sometimes, and `goto case` provides you with a way to request it explicitly - and then ramps it power up a notch, because why not? Amusingly, this is something that C doesn't have, even though its case labels are true labels (allowing for Duff's device and similar tricks). If you want to goto them, you need to add an explicit named label there.
bobcostas55 10y ago
Why such a verbose syntax for pattern matching?
- junkyarddog 10y ago
  It still has to look C#ish.
gigatexal 10y ago
I was a die-hard python guy and now I'm a die-hard python guy who appreciates .Net. (Forced to because I work in a .Net shop, but it has chops)
ryenus 10y ago
Possible to use variable placeholders on the left side of a deconstructor assignment?
- mathw 10y ago
  There's a plan to allow wildcards in deconstruction patterns, but it doesn't look like it's ready in time for C# 7. So hopefully that will appear in C# 8. It would look something like: var (first, second, *) = ReturnsFourThings(foo);
keithnz 10y ago
more improvements that allows more concise code and that looks functional in nature. Which is great, I have to do a lot in C# and really like it as a OO / with functional abilities type language. But I keep wondering why F# doesn't really take off given a lot of peoples fascination with the functional world. It does functional nicely while still being able to bridge back to the OO world which allows you to easily leverage a LARGE amount of libraries in the .net world. It has a really good community, and F# specific frameworks for various things as well. It's like a hidden gem that people pass over as they look at functional languages with much much smaller ecosystems.
- bad_user 10y ago
  I only played with F#, but my day job is writing FP code in Scala, so let me answer this: > I keep wondering why F# doesn't really take off given a lot of peoples fascination with the functional world As a matter of fact there aren't that many people interested in FP, mostly due to a lack of education on the matter. Even many people talking about FP are confused about what FP is. And the problem with the FP ecosystem are the abstractions, which tend to be extremely high level and very productive, however these aren't taught in school and the cost of entry is high. So let me throw this question right back at you: why F# and not Haskell? And note that the answer you give is going to be applicable to C# versus F# and at the same time flawed ;-) And you see, raising the abstraction is one way humanity has always tackled complexity, however this is essentially about vertical scalability of talent - or in other words enabling the same people to handle more challenging problems by giving them better tools. But the trouble is that this is incompatible with horizontal scalability, which is about growing by hiring more and more people, i.e. building assembly lines. So going back to your question, the reason for why not FP is actually simple, but hard to swallow: the software industry is growing due to huge demand, as a consequence a majority of people working in this field are beginners and when the industry has a choice between quality and quantity, it will go for quantity at the expense of quality. On the other hand the good news is that with the proper education, mindset and tools, as a small team, you can still build products that compete with big companies having virtually unlimited resources.
  - 10y ago
setq 10y ago
I'm interested to see what the production story is for some of these language features. I usually get left a festering minidump with a number of threads, a pile of stacks and some line numbers if I'm lucky these days. It's quite hard determining which dereference or call is the one that triggered the problem in a method body with so many things now compacted into a tight expression. Granted there should be assertions to prevent these conditions occurring but not everyone on the team is perfect 100% of the time. Sometimes an edge case slides in as well and you have to heavily assert everything and push to test/production to reproduce which isn't ideal.
zamalek 10y ago
I'm very disappointed that ref returns were not implemented as syntactic sugar for out params. A bit of history: game developers have been crying for a solution to the matrix operator problem. A 4x4 matrix is 64 bytes of data. Implement the mathematical operators using C# operators and you're looking at 192 bytes copied per invocation. The workaround is the fake ref operator: void Add(ref Matrix, ref Matrix, out Matrix). The problem is that this results in code smell at the call sites. The ref return was the first compromise, allowing that method to become: ref Matrix Add(...). The ultimate solution would be to allow ref returns and ref parameters on operators, but you need ref returns first. This feature misses all of that. Maybe we'll get out returns, but the argument against it would be language bloat, and even I'd agree. Sigh. /rant
- deleted 10y ago
  [deleted]
- kukx 10y ago
  The Add method signature could be simplified from void Add(ref Matrix, ref Matrix, out Matrix) to Matrix Add(ref Matrix, ref Matrix). Also, could you elaborate what you mean by out returns? Normal returns could be considered "out returns", no?
  - bad_user 10y ago
    If Matrix is a value type, then no, that's not the same thing, because with "out Matrix" it is passing it by reference, instead of by value.
    - kukx 10y ago
      Isn't it in this case just an implementation detail without any meaningful consequences (apart from interop)? - I'm trying to find a way to benefit from it. I wrote some code to compare the two approaches and see what's going on underneath.[0] I'm not familiar with IL, but it seems like the memory usage is the same and the simple return function requires less ops. [0] http://tryroslyn.azurewebsites.net/#f:>ilr/A4VwRgNglgxgBDCBDAziuBhOBvAUHAuUSWOFAFwCcQZy4BlHfQl46eKAOzoA0BuZgQC+gouHZwAbgHsoAEzgB5EOQAU0lQzgAPAJRMWLbXAC8cTgFMA7luxwepuAEY4QgSxGtxpRgCULavp4hoSUASCUnObWtvaOAByu7oSehGykMvJwALKqQaIsjNrJIcpqGnR6JYbGZv6B1SJCQA== http://tryroslyn.azurewebsites.net/#f:>ilr/A4VwRgNglgxgBDCBD...
batina 10y ago
Pattern Matching with Is Expressions Awesome! Greatly reduces "ugly" boilerplate code like this: if (control is TextBox) { var textBox = (TextBox)control; textBox... } Also, it would be great if Microsoft could make full properties in another way so that you do not have to write a backing field for it. Something like this: public string LastName { get; set { if (value == "Batina") RaisePropertyChanged(); } } It would make code more cleaner.
- taspeotis 10y ago
  For your second example: just use Fody.PropertyChanged and forget about writing boilerplate.
  - batina 10y ago
    I know about Fody but I don't think it would help with custom logic inside setter (not just PropertyChanged call).
- jsingleton 10y ago
  I think if you're writing property accessors manually then there should be an explicit private backing field. Otherwise there is just too much magic going on. Normal auto-implemented properties are fine: public string LastName {get; set;} As are read-only ones: public string LastName {get; private set;} Yet, I feel that if you are writing logic in there then you should fully control it. Or else there is too much being done that is non-obvious and could cause problems down the line (for others or your future self). However, they might be able to achieve something with data annotations that wouldn't be too magic. For example: [RaisePropertyChanged("Batina")] public string LastName {get; set;} Tip: In VS you can just type "prop" then press tab to auto-generate the code for a class property. You can then easily auto-change this to a fully implemented version. This also works for "for" and "foreach" loops etc. I haven't done much Java in a while but do you still have to write out all of your property accessors fully? Might not be too bad if the IDE can generate this code.
  - 10y ago
duke360 10y ago
major part of these new features are very cool but i'm afraid they could compromise future evolution of the Language. some implementation details scares me, maybe i'll become used to them, i only hope that these doesn't result in a boomerang for future versions. Deconstruction implementation is scary, i would prefer to have a special symbol (like the desctrutor) and duples that ignores names are ok but sounds very error prone, maybe i just have to try them to understand, also order sensitive case makes my dev sense tingle...
shaydoc 10y ago
removal of pre-declaration of out parameters = win!
dpen2016 10y ago
Just a note: This article published yesterday refers to VS 15 Preview 5 as unreleased but VS 2017 RC (the next Preview on) was also released yesterday.

234 points by kukx 10y ago

Minor nitpick: the title is (edit: was) missing a leading dot.

So, lets say someone had never worked with C# or .net before and works on a mac - where would you go to get started building a small server application? I assume you would use the .net core stuff? and visual studio code? Any good tutorials for noob-to-the-ecosystem but someone that has programming experience?

annerajb 10y ago
Microsoft has great .net core tutorials Here is one just for your usecase: https://docs.microsoft.com/en-us/aspnet/core/tutorials/your-first-mac-aspnet https://docs.microsoft.com/en-us/aspnet/core/tutorials/your-...
te_platt 10y ago
Get Xamarin. You can start doing OS X apps with C# right away. They have a lot of tutorials on their website.
merb 10y ago
> https://www.visualstudio.com/vs/visual-studio-mac/ https://www.visualstudio.com/vs/visual-studio-mac/ It bundles everything you need. And for the tutorial you can check links from other people.
stdgy 10y ago
This is what I've run through: https://docs.microsoft.com/en-us/aspnet/core/tutorials/your-first-mac-aspnet https://docs.microsoft.com/en-us/aspnet/core/tutorials/your-... It's nice. I went on to modify and hack with what I created to form it into a back end for a mobile app I'm playing around with. There are still some warts in the process (Namely just figuring out how everything fits together and which packages to import) but I've been pleasantly surprised. It looks like the new Visual Studio for Mac (ie An updated Xamarin Studio) has an ASP.Net Core template. At least I thought I saw that on the live stream earlier today. Might want to check that out!
ldev 10y ago
I'm using https://www.jetbrains.com/rider/ https://www.jetbrains.com/rider/ for an IDE in macOS. It's early access preview, but each build fixes a lot of bugs and is usable.

alexro 10y ago

Are we back to the 90-ties with no code highlights in text?

mattmanser 10y ago
Yeah, it's particularly bad on mobile too as the code is auto-wrap so the code 's utterly illegible. Nice blog post, shame about the bloody awful presentation.
jdmichal 10y ago
The markup actually does have coloring. However, there's a CSS rule that's overriding them all back to black. How strange.
- redwards510 10y ago
  Yeah, I just came to say this. Here's the code, with obvious color markers. http://i.imgur.com/91dFyRr.png http://i.imgur.com/91dFyRr.png
  - redwards510 10y ago
    fix: .codeSnippetContainer span { /* color: #000 !important; */ }

louthy 10y ago

Throw expressions are particularly welcome. I'd previously dealt with that issue by creating a static method that returned the expected type, but just threw an exception [1][2] I'm not sure it's explicit in the blog, but it seems the deconstructor will be useful for pattern-matching using 'is'. Tuples. Yay! Finally! Pattern-matching-switch-statement: Not an expression. That's a bad call. We have expression based ternary, throws, method bodies, and LINQ; switches are the last and most painful omission. Local functions: Fantastic for libraries like mine, which is trying to bring functional programming to the C# world, but takes a hit with the allocation of delegates for common operations [3] It should be a boon for anything LINQ based (implementations, rather than usage). Return by ref and out parameters: I'd be happy if they just removed them from the language. Ugly, error magnets. All in all, good progress. Hopefully they can make more progress on facilitating expression-based programming, and bring in record types for the next release. The pain of creating immutable types is truly tedious. And I'd desperately like to see partial generic parameter specifying (for when one of the generic arguments can't be inferred by the type-system, so you then end up having to specify them all). [1] https://github.com/louthy/language-ext/blob/master/LanguageExt.Core/Prelude.cs#L209 https://github.com/louthy/language-ext/blob/master/LanguageE... [2] https://github.com/louthy/language-ext/blob/master/LanguageExt.Core/Prelude.cs#L182 https://github.com/louthy/language-ext/blob/master/LanguageE... [3] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Core/TypeClasses/Monad/Monad.Prelude.cs#L70 https://github.com/louthy/language-ext/blob/type-classes/Lan...

moogly 10y ago
Fully agreed on pattern matching not being an expression. I really dislike that syntax overall. I get the reluctance to introduce new keywords (though this did introduce 'when', but I suppose it's contexual at least), but trying to shoehorn pattern matching into the, um, let's be nice and call it "venerable", old switch/case does not look very ergonomic at all. And I don't know about you, but I rarely switch over polymorphic types these days, I mostly switch over values, so the pattern matching overall is way less useful to me without records/discriminated unions. I guess you can't really remove 'ref' and 'out' due to interop. Maybe the ref returns stuff will be nice if we get more performant string/array views in the next version, and I do like the inline 'var out'. I also want type inference for field declaration+initialization, but I think Eric Lippert once explained why that was a difficult problem to solve, albeit I can't remember the reason.

JamesBarney 10y ago

Kinda surprised me Microsoft doesn't have better syntax highlighting on msdn. The lack of coloration and gray background gave me a little bit of a headache.

Analemma_ 10y ago
It's especially baffling because they clearly have a great web formatting library for code (Monaco): http://www.typescriptlang.org/play/ http://www.typescriptlang.org/play/. Why not use it?
msbarnett 10y ago
Coupled with the wrapping, paucity of line breaks, and (near lack of) indentation, the examples are damn near unreadable.
jdmichal 10y ago
The markup actually does have coloring. However, there's a CSS rule that's overriding them all back to black. How strange.
mathw 10y ago
It is rather baffling. They have an amazing online code browsing tool they use for the reference source of the .NET Framework (enormously useful for figuring out all the details they don't bother to document and the type system can't express), but they aren't applying that tech more universally. The blog platform particularly suffers for it.
ungzd 10y ago
MSDN (web version, maybe desktop app still exists, I don't know) still has very poor usability. Recently I decided to try .NET and was surprised how painful MSDN is (compared to almost any other documentation website). Page load times of 5-10 seconds, poor navigation (2-3 link clicks just to get to list of class methods). Does anyone know any alternative .NET documentation viewers (usable without Visual Studio and Windows)?

redwards510 10y ago

Can someone give an example of a use case for a Deconstructor?

SloopJon 10y ago
var (r, g, b, a) = pixel
- sergiotapia 10y ago
  Looks a lot like Elixir's pattern matching to extract values from maps. someMap = {1, 2} {foo, bar} = someMap foo # 1 bar # 2
  - int_19h 10y ago
    This is destructuring assignment, as practiced by many languages before. Pretty much anything in the ML family, for example.
Leszek 10y ago
var (ret, err) = Foo(); if (err != null) { ... }
- taco_emoji 10y ago
  So Foo() has to return a class which has a destructor? Seems like just returning a Tuple would be better in that case.
  - truncate 10y ago
    Tuple in C# is a class IIRC. Without destructor, you will have to pull out individual members separately. For example for a tuple of form <Int, Int, Int>, you will do something like `var r = c.getFirst(); var g = c.getSecond();`. With deconstructor, you can do the same via `var (r, g, b) = color;`. In other words, you can say that tuples are way to combine data, while deconstructors tell how to explode it. Since these deconstructors are themselves functions, you can do computation each time, and get different results due to side-effects (probably not good idea). EDIT: I don't know C#, so syntax is definitely not right.

markatkinson 10y ago

It puts a smile on my beak that I am a budding (sort of) .Net and C# developer. Microsoft seems to be really jacked up and introducing some very forward thinking functionality into their ecosystem. Been playing with Azure Service Fabric. It is super impressive.

xorxornop 10y ago
Yeah, Service Fabric is super awesome! I'm refactoring out company's infrastructure to run on it currently - the older stuff runs on MVC 5 on Azure Cloud Service. I'm refactoring it to ASP.NET Core on Service Fabric. Getting about 50x better real-world performance. Yes, that much. It's insane. Currently on Windows as Service Fabric on Linux is in preview (not comfortable using it in production), but I imagine I'll move it over once that's stable ️ A great time to be a .NET developer! Makes me happy I stuck with it.

jdmichal 10y ago

I'm a little disappointed that pattern matching doesn't simply narrow the variable, and instead requires a new variable name to hold the narrowed type. Even TypeScript narrows the variable in-place!

louthy 10y ago
You may want to deconstruct the value and use the original base value. This seems entirely logical, and consistent with most implementations in functional languages (and I'd say makes TypeScript's implementation the poor one - although I haven't seen it myself to have an opinion on).
- naasking 10y ago
  > You may want to deconstruct the value and use the original base value. I think this is exactly right. Members can be declared visible only when viewing an object through a particular supertype, and you may simultaneously need to invoke methods from the supertype and the subtype.
- int_19h 10y ago
  Thing is, in most cases, you don't want to do that. You just want to narrow the type. It's unfortunate that this isn't readily possible even by explicitly reusing the name - C# shadowing rules for locals preclude it. So you can't do something like `if (x is int x) { ... }`.
dested 10y ago
I believe this would cause a change in the CLR as opposed to just syntax sugar. It's less of an issue for typescript since all type information is erased at runtime.
- ygra 10y ago
  The CLR doesn't care, it doesn't see the C# code and the compiler could just as well emit another local for the narrowed variable. The language semantics here don't really depend on what the CLR does.

zilchers 10y ago

Is it just me, or is C# basically becoming Scala (or, insert your favorite functional language here). Don't get me wrong, this is awesome, .net on Linux, dockerized, is all good, but these moves definitely show Microsoft responding to market changes in a way they didn't used to.

stupidcar 10y ago
C# first introduced lambdas and LINQ in v3, back in 2007. It was the first mainstream OO language to really push a more functional/mixed-paradigm approach. This is definitely an area where Microsoft has lead the market, not followed it.
- louthy 10y ago
  They may have been the first, and LINQ was (and is) a truly great feature (I'd love it if they'd expand the grammar, or allow computation expressions like F#); but the problem I've found with trying to do functional programming in C# is that there's no BCL support. Whereas F# has its functional prelude. I haven't spent much time with Scala, but I get the impression that a lot of the functional stuff is there by default (or at least easily accessibly via Scalaz) and therefore less inertia is needed to write functionally in Scala. Even with LINQ most C# programmers think it's just for querying databases or XML files, they don't realise they have built in monad semantics. I found that I'd have an immutable collections library over there, that wasn't aware of the Option type in that library over there. (So Map.Find(key) couldn't return an Option<V> for example - this makes composition more difficult). So although the language has been steadily going in the right direction, there has been less of a concerted effort on the library front. And therefore C# is still behind IMHO. This is something I've been trying to rectify, by essentially building a functional BCL [1]. I welcome the increased pace of functional features recently. Although sometimes it's frustrating seeing the direction they're going and wishing they'd get there much quicker (expressions everywhere, sum-types, record-types, better type inference). It's interesting that often C# is held up for its inability to do type-classes or ad-hoc polymorphism. But it is in fact possible with C# today [2] [3], and with zero cost (i.e. no reflection, additional memory allocations, or side-stepping of the type-system). It just causes a massive head-ache of manually provided generic arguments... [4] [5] I'd love it if the Roslyn team took some time to deal with the generic parameters inference story. It would help bring ad-hoc polymorphic types to C#, but it would just be awesome in general. [1] https://github.com/louthy/language-ext https://github.com/louthy/language-ext [2] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Tests/TypeClassMonad.cs https://github.com/louthy/language-ext/blob/type-classes/Lan... [3] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Tests/TypeClassMonoid.cs https://github.com/louthy/language-ext/blob/type-classes/Lan... [4] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Core/TypeClasses/Monad/Monad.Prelude.cs#L70 https://github.com/louthy/language-ext/blob/type-classes/Lan... [5] https://github.com/louthy/language-ext/blob/type-classes/LanguageExt.Core/DataTypes/Option/Option.cs#L780 https://github.com/louthy/language-ext/blob/type-classes/Lan...

stuartd 10y ago

'goto case' is a thing? I'm so going to have fun with that

int_19h 10y ago
It has always been a thing. The original C# design was to take the C switch statement as is, but tighten it up to avoid crazy stuff like Duff's device, and to make non-obvious implicit things explicit. Consequently, C# requires that control flow provably cannot reach the end of any non-empty case block (to avoid implicit fallthrough that normally happens in C, Java etc). Normally this means that you must use `break` (or something else that transfers control, like `continue`, `throw` or `return`). But fallthrough is actually useful sometimes, and `goto case` provides you with a way to request it explicitly - and then ramps it power up a notch, because why not? Amusingly, this is something that C doesn't have, even though its case labels are true labels (allowing for Duff's device and similar tricks). If you want to goto them, you need to add an explicit named label there.

bobcostas55 10y ago

Why such a verbose syntax for pattern matching?

junkyarddog 10y ago
It still has to look C#ish.

gigatexal 10y ago

I was a die-hard python guy and now I'm a die-hard python guy who appreciates .Net. (Forced to because I work in a .Net shop, but it has chops)

ryenus 10y ago

Possible to use variable placeholders on the left side of a deconstructor assignment?

mathw 10y ago
There's a plan to allow wildcards in deconstruction patterns, but it doesn't look like it's ready in time for C# 7. So hopefully that will appear in C# 8. It would look something like: var (first, second, *) = ReturnsFourThings(foo);

keithnz 10y ago

more improvements that allows more concise code and that looks functional in nature. Which is great, I have to do a lot in C# and really like it as a OO / with functional abilities type language. But I keep wondering why F# doesn't really take off given a lot of peoples fascination with the functional world. It does functional nicely while still being able to bridge back to the OO world which allows you to easily leverage a LARGE amount of libraries in the .net world. It has a really good community, and F# specific frameworks for various things as well. It's like a hidden gem that people pass over as they look at functional languages with much much smaller ecosystems.

bad_user 10y ago
I only played with F#, but my day job is writing FP code in Scala, so let me answer this: > I keep wondering why F# doesn't really take off given a lot of peoples fascination with the functional world As a matter of fact there aren't that many people interested in FP, mostly due to a lack of education on the matter. Even many people talking about FP are confused about what FP is. And the problem with the FP ecosystem are the abstractions, which tend to be extremely high level and very productive, however these aren't taught in school and the cost of entry is high. So let me throw this question right back at you: why F# and not Haskell? And note that the answer you give is going to be applicable to C# versus F# and at the same time flawed ;-) And you see, raising the abstraction is one way humanity has always tackled complexity, however this is essentially about vertical scalability of talent - or in other words enabling the same people to handle more challenging problems by giving them better tools. But the trouble is that this is incompatible with horizontal scalability, which is about growing by hiring more and more people, i.e. building assembly lines. So going back to your question, the reason for why not FP is actually simple, but hard to swallow: the software industry is growing due to huge demand, as a consequence a majority of people working in this field are beginners and when the industry has a choice between quality and quantity, it will go for quantity at the expense of quality. On the other hand the good news is that with the proper education, mindset and tools, as a small team, you can still build products that compete with big companies having virtually unlimited resources.
- 10y ago

setq 10y ago

I'm interested to see what the production story is for some of these language features. I usually get left a festering minidump with a number of threads, a pile of stacks and some line numbers if I'm lucky these days. It's quite hard determining which dereference or call is the one that triggered the problem in a method body with so many things now compacted into a tight expression. Granted there should be assertions to prevent these conditions occurring but not everyone on the team is perfect 100% of the time. Sometimes an edge case slides in as well and you have to heavily assert everything and push to test/production to reproduce which isn't ideal.

zamalek 10y ago

I'm very disappointed that ref returns were not implemented as syntactic sugar for out params. A bit of history: game developers have been crying for a solution to the matrix operator problem. A 4x4 matrix is 64 bytes of data. Implement the mathematical operators using C# operators and you're looking at 192 bytes copied per invocation. The workaround is the fake ref operator: void Add(ref Matrix, ref Matrix, out Matrix). The problem is that this results in code smell at the call sites. The ref return was the first compromise, allowing that method to become: ref Matrix Add(...). The ultimate solution would be to allow ref returns and ref parameters on operators, but you need ref returns first. This feature misses all of that. Maybe we'll get out returns, but the argument against it would be language bloat, and even I'd agree. Sigh. /rant

deleted 10y ago
[deleted]
kukx 10y ago
The Add method signature could be simplified from void Add(ref Matrix, ref Matrix, out Matrix) to Matrix Add(ref Matrix, ref Matrix). Also, could you elaborate what you mean by out returns? Normal returns could be considered "out returns", no?
- bad_user 10y ago
  If Matrix is a value type, then no, that's not the same thing, because with "out Matrix" it is passing it by reference, instead of by value.
  - kukx 10y ago
    Isn't it in this case just an implementation detail without any meaningful consequences (apart from interop)? - I'm trying to find a way to benefit from it. I wrote some code to compare the two approaches and see what's going on underneath.[0] I'm not familiar with IL, but it seems like the memory usage is the same and the simple return function requires less ops. [0] http://tryroslyn.azurewebsites.net/#f:>ilr/A4VwRgNglgxgBDCBDAziuBhOBvAUHAuUSWOFAFwCcQZy4BlHfQl46eKAOzoA0BuZgQC+gouHZwAbgHsoAEzgB5EOQAU0lQzgAPAJRMWLbXAC8cTgFMA7luxwepuAEY4QgSxGtxpRgCULavp4hoSUASCUnObWtvaOAByu7oSehGykMvJwALKqQaIsjNrJIcpqGnR6JYbGZv6B1SJCQA== http://tryroslyn.azurewebsites.net/#f:>ilr/A4VwRgNglgxgBDCBD...

batina 10y ago

Pattern Matching with Is Expressions Awesome! Greatly reduces "ugly" boilerplate code like this: if (control is TextBox) { var textBox = (TextBox)control; textBox... } Also, it would be great if Microsoft could make full properties in another way so that you do not have to write a backing field for it. Something like this: public string LastName { get; set { if (value == "Batina") RaisePropertyChanged(); } } It would make code more cleaner.

taspeotis 10y ago
For your second example: just use Fody.PropertyChanged and forget about writing boilerplate.
- batina 10y ago
  I know about Fody but I don't think it would help with custom logic inside setter (not just PropertyChanged call).
jsingleton 10y ago
I think if you're writing property accessors manually then there should be an explicit private backing field. Otherwise there is just too much magic going on. Normal auto-implemented properties are fine: public string LastName {get; set;} As are read-only ones: public string LastName {get; private set;} Yet, I feel that if you are writing logic in there then you should fully control it. Or else there is too much being done that is non-obvious and could cause problems down the line (for others or your future self). However, they might be able to achieve something with data annotations that wouldn't be too magic. For example: [RaisePropertyChanged("Batina")] public string LastName {get; set;} Tip: In VS you can just type "prop" then press tab to auto-generate the code for a class property. You can then easily auto-change this to a fully implemented version. This also works for "for" and "foreach" loops etc. I haven't done much Java in a while but do you still have to write out all of your property accessors fully? Might not be too bad if the IDE can generate this code.
- 10y ago

duke360 10y ago

major part of these new features are very cool but i'm afraid they could compromise future evolution of the Language. some implementation details scares me, maybe i'll become used to them, i only hope that these doesn't result in a boomerang for future versions. Deconstruction implementation is scary, i would prefer to have a special symbol (like the desctrutor) and duples that ignores names are ok but sounds very error prone, maybe i just have to try them to understand, also order sensitive case makes my dev sense tingle...

shaydoc 10y ago

removal of pre-declaration of out parameters = win!

dpen2016 10y ago

Just a note: This article published yesterday refers to VS 15 Preview 5 as unreleased but VS 2017 RC (the next Preview on) was also released yesterday.