• Visual Studio for Mac: Top Features of the New Editor

      Over the past year, the Visual Studio for Mac team updated the editors within the IDE to be faster, more fluent and more productive. We did this by building a macOS-native editor interface on top of the same editor backend as Visual Studio on Windows. In version 8.1 we introduced the new C# editor. This was followed by the new XAML editor in 8.2. And most recently, we updated our web languages to utilize the new editors in version 8.3, completing the process we set out to do a year ago. To celebrate this accomplishment, I wanted to share a bit of detail regarding the design and implementation of the new editors along with my five favorite new features in the Visual Studio for Mac code editors.

      At the core of the updated editors within Visual Studio for Mac is the shared language service with Visual Studio on Windows. What this means is that the same backend that powers the Windows version of Visual Studio now powers the macOS version as well. This includes IntelliSense, Roslyn, text logic, and all the language services behind the scenes. The only portion not shared between Windows and macOS is the UI layer, which stays native for each platform. In the case of macOS, that means using macOS frameworks like Cocoa and CoreText to power the UI experience. By using a native UI, while also being able to utilize support for native input methods as well as support for right-to-left languages, font ligatures and other advanced graphical features.

      Read more →
    • Regular Avalonia

        Sometimes we don’t understand how the regular expression that we have composed works and want to check. There are many applications like regex101.com or vs code. I wanted to add one more to this list.

        In this article we will see how you can wrap Regex in cross-platform graphics and create a simple application for testing regular expressions.

        Read more →
      • What's new in ML.NET and Model Builder

          We are excited to announce updates to Model Builder and improvements in ML.NET. You can learn more in the «What’s new in ML.NET?.» session at .NET Conf.

          ML.NET is an open-source and cross-platform machine learning framework (Windows, Linux, macOS) for .NET developers.

          ML.NET offers Model Builder (a simple UI tool) and CLI to make it super easy to build custom ML Models using AutoML.

          Using ML.NET, developers can leverage their existing tools and skillsets to develop and infuse custom AI into their applications by creating custom machine learning models for common scenarios like Sentiment Analysis, Recommendation, Image Classification and more!..

          Read more →
        • A small overview of SIMD in .NET/C#

            Here’s a quick look at algorithm vectorization capabilities in .NET Framework and .NET Core. This article is for those who know nothing about these techniques. I will also show that .NET doesn’t actually lag behind "real compiled" languages for native development.

            Read more →
          • Ads
            AdBlock has stolen the banner, but banners are not teeth — they will be back

          • System.IO.Pipelines — a little-known tool for lovers of high performance

            • Translation
            Hello reader. Quite a lot of time has passed since the release of .NET Core 2.1. And such cool innovations as Span and Memory are already widely known, you can read, see and hear a lot about them. However, unfortunately, library called System.IO.Pipeslines did not receive the same attention. Almost everything there is on this topic is the only post that have been translated and copied on many resources. There should be more information about that technology to look on it from different angles.

            Read more →
          • Checking the .NET Core Libraries Source Code by the PVS-Studio Static Analyzer

              Picture 19

              .NET Core libraries is one of the most popular C# projects on GitHub. It's hardly a surprise, since it's widely known and used. Owing to this, an attempt to reveal the dark corners of the source code is becoming more captivating. So this is what we'll try to do with the help of the PVS-Studio static analyzer. What do you think – will we eventually find something interesting?
              Read more →
            • WinForms: Errors, Holmes

                Picture 5

                We like to search for errors in Microsoft projects. Why? It's simple: their projects are usually easy to check (you can work in Visual Studio environment for which PVS-Studio has a convenient plugin) and they contain few errors. That's why the usual work algorithm is as follows: find and download an open source project from MS; check it; choose interesting errors; make sure there are few of them; write an article without forgetting to praise the developers. Great! Win-win-win: it took a little time, the bosses are glad to see new materials in the blog, and karma is fine. But this time «something went wrong». Let's see what we have found in the source code of Windows Forms and whether we should speak highly of Microsoft this time.
                Read more →
              • Saving Routing State to the Disk in a Cross-Platform .NET Core GUI App with ReactiveUI and Avalonia

                • Translation
                • Tutorial


                User interfaces of modern enterprise applications are quite complex. You, as a developer, often need to implement in-app navigation, validate user input, show or hide screens based on user preferences. For better UX, your app should be capable of saving state to the disk when the app is suspending and of restoring state when the app is resuming.

                ReactiveUI provides facilities allowing you to persist application state by serializing the view model tree when the app is shutting down or suspending. Suspension events vary per platform. ReactiveUI uses the Exit event for WPF, ActivityPaused for Xamarin.Android, DidEnterBackground for Xamarin.iOS, OnLaunched for UWP.

                In this tutorial we are going to build a sample application which demonstrates the use of the ReactiveUI Suspension feature with Avalonia — a cross-platform .NET Core XAML-based GUI framework. You are expected to be familiar with the MVVM pattern and with reactive extensions before reading this note. Steps described in the tutorial should work if you are using Windows 10 or Ubuntu 18 and have .NET Core SDK installed. Let's get started!

                Read more →
              • «Reader» monad through async/await in C#

                  In my previous article I described how to achieve the "Maybe" monad behavior using async/await operators. This time I am going to show how to implement another popular design pattern "Reader Monad" using the same techniques.

                  That pattern allows implicit passing some context into some function without using function parameters or shared global objects and it can be considered as yet another way to implement dependency injection. For example:

                  class Config { public string Template; }
                  public static async Task Main()
                      Console.WriteLine(await GreetGuys().Apply(new Config {Template = "Hi, {0}!"}));
                      //(Hi, John!, Hi, Jose!)
                      Console.WriteLine(await GreetGuys().Apply(new Config {Template = "¡Hola, {0}!" }));
                      //(¡Hola, John!, ¡Hola, Jose!)
                  //These functions do not have any link to any instance of the Config class.
                  public static async Reader<(string gJohn, string gJose)> GreetGuys() 
                      => (await Greet("John"), await Greet("Jose"));
                  static async Reader<string> Greet(string name) 
                      => string.Format(await ExtractTemplate(), name);
                  static async Reader<string> ExtractTemplate() 
                      => await Reader<string>.Read<Config>(c => c.Template);
                  Read more →
                • .NET – Tools for working with multithreading and asynchrony – Part 2

                    I have originally posted this article in CodingSight blog.
                    It's also available in Russian here.

                    This article comprises the second part of my speech at the multithreading meetup. You can have a look at the first part here and here. In the first part, I focused on the basic set of tools used to start a thread or a Task, the ways to track their state, and some additional neat things such as PLinq. In this part, I will fix on the issues you may encounter in a multi-threaded environment and some of the ways to resolve them.


                    Read more →
                  • “Maybe” monad through async/await in C# (No Tasks!)

                      Generalized async return types — it is a new C#7 feature that allows using not only Task as a return type of async methods but also other types (classes or structures) that satisfy some specific requirements.

                      At the same time, async/await is a way to call a set of "continuation" functions inside some context which is an essence of another design pattern — Monad. So, can we use async/await to write a code which will behave in the same way like if we used monads? It turns out that — yes (with some reservations). For example, the code below is compilable and working:

                      async Task Main()
                        foreach (var s in new[] { "1,2", "3,7,1", null, "1" })
                            var res = await Sum(s).GetMaybeResult();
                            Console.WriteLine(res.IsNothing ? "Nothing" : res.GetValue().ToString());
                        // 3, 11, Nothing, Nothing
                      async Maybe<int> Sum(string input)
                          var args = await Split(input);//No result checking
                          var result = 0;
                          foreach (var arg in args)
                              result += await Parse(arg);//No result checking
                          return result;
                      Maybe<string[]> Split(string str)
                        var parts = str?.Split(',').Where(s=>!string.IsNullOrWhiteSpace(s)).ToArray();
                        return parts == null || parts.Length < 2 ? Maybe<string[]>.Nothing() : parts;
                      Maybe<int> Parse(string str)
                          => int.TryParse(str, out var result) ? result : Maybe<int>.Nothing();

                      Further, I will explain how the code works...

                      Read more →
                    • Write Better Code Faster with Roslyn Analyzers

                        Roslyn, the .NET compiler platform, helps you catch bugs even before you run your code. One example is Roslyn’s spellcheck analyzer that is built into Visual Studio. Let’s say you are creating a static method and misspelled the word static as statc. You will be able to see this spelling error before you run your code because Roslyn can produce warnings in your code as you type even before you’ve finished the line. In other words, you don’t have to build your code to find out that you made a mistake.

                        Roslyn analyzers can also surface an automatic code fix through the Visual Studio light bulb icon that allows you to fix your code immediately.

                        Read more →
                      • Fighting complexity in software development

                          What's this about

                          After working on different projects, I've noticed that every one of them had some common problems, regardless of domain, architecture, code convention and so on. Those problems weren't challenging, just a tedious routine: making sure you didn't miss anything stupid and obvious. Instead of doing this routine on a daily basis I became obsessed with seeking solution: some development approach or code convention or whatever that will help me to design a project in a way that will prevent those problems from happening, so I can focus on interesting stuff. That's the goal of this article: to describe those problems and show you that mix of tools and approaches that I found to solve them.

                          Read more →
                          • +19
                          • 2.8k
                          • 2
                        • Tutorial: Update interfaces with default interface members in C# 8.0

                            Beginning with C# 8.0 on .NET Core 3.0, you can define an implementation when you declare a member of an interface. The most common scenario is to safely add members to an interface already released and used by innumerable clients.

                            In this tutorial, you'll learn how to:

                            • Extend interfaces safely by adding methods with implementations.
                            • Create parameterized implementations to provide greater flexibility.
                            • Enable implementers to provide a more specific implementation in the form of an override.

                            Read more →
                          • Microservices architecture & implementation Step-by-Step Part 1

                            Hi All,

                            I’m in the process of implementing a new simple microservices-based project as an example of a step-by-step guide for those who had a hard time with a microservices architecture and are still looking for “another” good reference. Also, I would really appreciate thought through feedback and proposal to make this project a high-quality chunk of work.

                            There are tons of articles and source code examples. But, unfortunately, I could not find any reference with simple step-by-step instructions, without doing a deep dive into Docker, Event Store, a multitude of configurations, cloud deployment stuff, etc. I cloned several projects and tried to start playing with them, but you know, only God knows how to start them, which dependencies are missing and why all those scripts are failing with thousands of ERRORS.

                            For example, this eShop project from Microsoft contains all we need, but it is not so simple to figure out what is going on there, SQL database connection strings, Docker scripts fail, no How-Tos and I’m not sure it is super-simple architecture you need to start with.

                            Read more →