What’s New in C# 7.0

Post by macca321 » Thu, Aug 25, 2016, 12:36 PM UTC

edgyswingset wrote: post #119

platz wrote: post #94

Earlier quoted context omitted.

> C#, is every bit a form of pattern matching as matching on a particular case of a union type. I'm afraid that is not the case, because in the current C# version, the compiler does nothing help you determine if you've matched all the possibilities. (it is not exhaustive) Exhaustiveness is important because it gives warning or an error to help you refactor and modify code without fear of breaking other code. Why enga…

Yes, and because of the lack of record and union types in C#, it's (probably) nigh-impossible to pull off exhaustive pattern matching. However, this is still pattern matching - you can define tuple patterns which decompose the data, much like you can in F#; just with some different syntax. I agree with you that exhaustiveness is incredibly important, and I really hope that it can be done in C# some day. However, reco…

Post by tigershark » Thu, Aug 25, 2016, 12:39 PM UTC

flukus wrote: post #106

voltagex_ wrote: post #103

Earlier quoted context omitted.

Can you give an example of how C# would be different with anonymous classes? Googling that term just gives a whole lot of references to inner classes in Java.

One I've come across is binding a command to a button. With anonymous inner classes you can have something like: myButton.AddListener(new Command { bool enabled() { return false; //more logic goes here } void onClick() { //do something } });

    SubmitCommand = new DelegateCommand(()=> DoSomething(), ()=> IsSubmitEnabled);

Post by snaky » Thu, Aug 25, 2016, 12:49 PM UTC

frik wrote: post #205

cm2187 wrote: post #118

Earlier quoted context omitted.

VB.net development is not that different from VB6. It is a way more sophisticated language and therefore can do more complex things. But the basic things take pretty much the same syntax than they were in VB6.

It is and it isn't. VB.Net is basically everything from C# with an syntax heavily inspired by VB6. But the similarity ends there. The RAD IDE of VB6 or Delphi are unmatched, and the compatibility is gone. As WinForms is legacy as well, the whole experience is different anyway. People would like to run their Win32 apps on their smartphone, nowadays you have more luck with Android than what Redmond comes up.

Post by 16bytes » Thu, Aug 25, 2016, 1:22 PM UTC

CyrusNajmabadi wrote: post #37

flukus wrote: post #2

Out variables seem like a mis-feature, especially when they are adding a better alternative (Tuples) in the same release. It's great to finally have tuples, but the c/java style syntax is showing it's age compared to something like scala which has return type declarations at the end, which I find much more readable. Literal improvements will be a godsend for writing database migrations. Ref returns and locals look li…

Hey there, C# language designer here. > Out variables seem like a mis-feature, especially when they are adding a better alternative (Tuples) in the same release. Out variables are really great when working with existing code that predates Tuples (for example, the entire BCL). We don't just introduce language features that will only work well for new code. We also want to make the experience of coding against existing…

Post by lgessler » Thu, Aug 25, 2016, 1:35 PM UTC

brusch64 wrote: post #137

addicted wrote: post #102

Earlier quoted context omitted.

C# has (had? I'm still a couple of versions behind) so much syntactical overhead that writing code without a visual studio seems painful at the very least. The var keyword was the first time it was even possible to write C# without tooling. It has definitely made it possible for me to use Vim for editing C# code. Newer features, such as lambda expressions, and some of the much nicer property syntax makes me feel that…

Compared to what languages ? I always thought of C# as the improved, less verbous Java. I wouldn't compare it with Python or other dynamic languages, but I prefer it to most compiled languages (especially at the times it was created)

    public static IList FindEphraimitesToKill(IList ephraimites)
    {
        IList ephraimitesToKill = new List();

        foreach (Ephraimite ephraimite in ephraimites) 
        {
            if (ephraimite.Speak("shibboleth") == "sibboleth")
            {
                ephraimitesToKill.Add(ephraimite);
            }
        }

        return ephraimitesToKill;
    }

    let findEphraimitesToKill ephraimites =
      let ephraimitesToKill = ref [] in
      List.iter (fun (ephraimite) -> begin
        if speak(ephraimite, "shibboleth") = "sibboleth" then
          ephraimitesToKill := !ephraimitesToKill @ [ephraimite] 
      end) ephraimites ;
      ephraimitesToKill;;