Hello everyone,

We’re excited to introduce the first EAP build of ReSharper Ultimate 2020.2!

Here’s what we have in store for you.
(more…)

Today we’re starting the Rider 2020.2 release cycle. Already in this first EAP build, Rider’s got several new goodies to help you in your daily coding routine.

Let’s dive in!

GitHub Pull Requests support

Support for Full GitHub Pull Requests is finally here! You’ll be able to browse, assign, manage, and even merge pull requests, view the timeline and in-line comments, submit comments and reviews, and accept changes.
(more…)

Version 2020.2 EAP01 finally brings dotMemory to Linux and macOS! For these systems, dotMemory is currently available only as a command-line tool. The tool is free and lets you take and save memory snapshots. To analyze the snapshots, you still need the standalone version of dotMemory, which is only available on Windows.

What you can profile

Here’s the dotMemory compatibility list for Linux and macOS:

(more…)

We’ve only just started the EAP for Rider 2020.2, but it’s already got plenty of goodies for Unity development. For example, we’ve done a huge amount of work to reduce memory overhead when parsing your assets, and Rider will now find usages and show Inspector values of more types, methods and fields, even inside prefab modifications!

But today I’d like to introduce a new feature that we’re really excited about, a feature that you never knew you needed, but we think you’re going to love!

We’re calling it a “pausepoint” and it’s a special kind of breakpoint that doesn’t stop the debugger in Rider. Instead, when it’s hit, it will switch the Unity Editor into pause mode, allowing you to inspect your game, make modifications and resume when ready.

(more…)

Join us Thursday, July 9, 2020, 16:00 – 17:00 CEST (10:00 AM – 11:00 AM EDT or check other timezones) for our free live webinar, How to stop worrying and adopt nullable reference types, with Andrey Dyatlov.

Register now!

Nullable reference types is a deceptively simple feature. While starting with it is as easy as adding a single ? mark to your source code, migrating large code bases has been proven to be a tedious and sometimes quite tricky task especially when complex code contracts and generics are involved.

The presentation will quickly cover what benefits this feature brings to the table, how it differs from JetBrans.Annotations attributes and how it evolved since its original release almost a year ago.

I will show a couple of ways to ease migration of large code bases to nullable reference types and how you can start to benefit from the feature immediately without putting any effort into annotating your code base just yet. I will also outline the most common pitfalls and explain how to deal with generics and potential analysis shortcomings as well as how to guide the compiler through complex code contracts to get the most out of this feature.

(more…)

At JetBrains, we make tools for developers, so we keep up with the latest trends and changes in the software development industry. We build many IDEs based on multi-platform software product lines for various programming languages.

Our Developer Ecosystem Survey, which JetBrains runs yearly, aims to reveal the current ambience of the developer world. Today we are happy to share with you the results of the 2020 edition of this survey, focusing on C#.

VIEW THE STATE OF DEVELOPER ECOSYSTEM 2020 REPORT

(more…)

The Model-View-Controller (MVC) pattern is inarguably a successful approach to building web applications. The design gained popularity in many tech communities, implemented in frameworks like Ruby on Rails, Django, and Spring. Since April 2, 2009, Microsoft has offered developers the ability to create MVC pattern web applications with the release of ASP.NET MVC. The approach leans heavily on the ideas of convention over configuration, and with conventions come ceremony. The ceremony can come with an overhead not necessary for less complicated apps.

With the release of .NET Core 2.0, ASP.NET developers were introduced to Razor Pages, a new approach to building web applications. While it can be reminiscent of WebForms, the framework learns from the decade of experience building web frameworks. The thoughtfulness put into Razor Pages shows with its ability to leverage many of the same features found in ASP.NET MVC.

In this post, we’ll explore an existing ASP.NET MVC application, begin to migrate it to Razor Pages, and see where Razor Pages may not be a good fit. (more…)

The recording of our June 25 webinar, Advocates on Rider – Uncovering the IDE That Gets You Places, with our developer advocates Rachel, Matthias, Matt, Khalid and Maarten, is now available. Subscribe to our community newsletter to receive notifications about future webinars.

In this webinar, join JetBrains .NET developer advocates Rachel, Khalid, Matthias, Matt and Maarten, who will be demoing Rider. They will show you their favourite tips and tricks, uncovering how they work with Rider. Expect smooth navigating through a code base, writing and editing code, inspections, a look at debugging, ASP.NET Core, database functionality, and much more.

(more…)

July brought some special events to computing history. IBM announced the Model 650 Computer in 1953. In 1968 Intel was officially founded – and since, IBM has been using Intel chips in their personal computers. Computing history would be much different, and probably a lot less useful without chips from Intel or influence from IBM. Fun fact: Gordon Moore, one of the founders of Intel is responsible for Moore’s Law.

.NET news

• The .NET Foundation has opened nominations for its chair committee
• F# 5 and F# tools update for June
• Announcing .NET 5.0 Preview 6
• Announcing Entity Framework Core EFCore 5.0 Preview 6
• Blazor WebAssembly Template Lands in .NET 5 Preview 6
• Introducing dotnet-monitor, an experimental tool
• .NET Conf “Focus on Microservices”

.NET tutorials and tips

What is Entity Framework in ASP.NET MVC – Asma Khalid demonstrates the what and how of ASP.NET MVC.

Visualizing ASP.NET Core endpoints using GraphvizOnline and the DOT language – This is an excellent and quite useful post by Andrew Lock showing how to visualize ASP.NET Core endpoints.

Learn how you manage routing in Blazor for .NET Core and VS Code – Check out this nice post by Chris Noring, showing you how to manage routing in Blazor.

Remote debugging Windows containers with Rider – Joost Meijles dives into debugging Windows containers, with Rider!

Dynamically Build LINQ Expressions – Jeremy Likness’ post on dynamically building LINQ Expressions will prove to be quite useful. It’s the kind of thing that many developers need to do, but have difficulty implementing.

Run Azurite in Docker with Rider and keep Azure Storage data local to a solution – Have you seen Azurite yet? How about running it in Docker? Let Maarten Balliauw show you!

Parse Markdown Front Matter With C# – Markdown! It’s a favorite way to whip up docs quickly. So this post by Khalid Abuhakmeh details how to parse it in C#.

Elastic Jobs in Azure SQL Database (2 Part series) – SQL is an important part of .NET development. Start with Part 1 by Anna Hoffman & Marisa Brasile and learn everything you need to know about Elastic Jobs in Azure SQL Databases.

On simplifying null validation with C# 9 – Everyone wants to make things like null check simpler. This post by Dave Brock shows you how.

5 useful Xamarin Forms Snippets – They are useful! Check out these Xamarin Forms snippets by Damien Doumer.

ASP.NET Core MVC API: How to Perform a Partial Update using HTTP PATCH Verb – This is valuable information for those times when you need to do something different, such as a partial update in a CRUD app. David Grace gives us the knowledge to get that done in this post.

Deploying ASP.NET Core Web Applications to Docker – Shipping is a feature! Bjoern Meyer writes about how to do it with Docker.

It’s all in the Host Class: Dependency Injection with .NET (Part 1) and Configuration (Part 2) – Christian Nagel reveals everything you need to know in this 2 Part series about the Host Class in .NET.

3+1 ways to manage state in your Blazor application – We strive for stateless apps but we also need to store data for each session. John Hilton shows us how to manage it in Blazor.

XML + JSON Output for Web APIs in ASP .NET Core 3.1 – Shahed Chowdhuri strikes again, with this excellent post on XML + JSON output for Web APIs.

Unraveling the Azure Maya Mystery and building a world – Ok, it’s not .NET per se, but Jen Looper has created this fun Azure Maya Mystery using Azure and Vue.JS. It’s great so check it out!

Integration of Azure Data Explorer with Cosmos DB for near real-time analytics – Azure Data Explorer and CosmosDB are now important facets if .NET development in the cloud. Let Minni Walia show you how to run near real-time analytics for it.

Events, community and culture

Struggling To Focus? How To Be Accountable While Working Remotely – Emily Whitten demonstrates how to do remote work well.

Dismantling barriers to participation in programming communities with Dr. Denae Ford – The software development industry has long been plagued by gatekeeping and unwelcoming communities. In this podcast, Scott Hanselman talks to Dr. Denae Ford about how to involve more folks by dismantling the barriers.

Does A 4-Day Workweek Actually Increase Productivity? – Well, does it? Microsoft Japan and other companies are trying it. In this blog post, Suzanne Zuppello has some thoughts about it. What do you think?

Random interesting and cool stuff

Contribute To The Top 10 Impactful .NET OSS Projects 2020 – Folks are always looking for OSS projects. Whether you’re new to OSS or an OSS pro, here are the top 10 impactful projects you might consider contributing to.

The ASP.NET Monsters [Dave Paquette, Simon Timms, James Chambers] .NET podcast. – These guys are fun and knowledgeable, and it’s definitely worth it to listen to their podcast.

And finally…

Here’s a chance to catch up on JetBrains news that you might have missed:

• Rider 2020.2 Early Access Program Begins!
• ReSharper Ultimate Starts Its Early Access Program for 2020.2!
• The Developer Ecosystem in 2020: Key Trends for C#
• Advocates on Rider – Uncovering the IDE That Gets You Places – Webinar Recording
• Webinar – How to stop worrying and adopt nullable reference types
• A Guide To Migrating From ASP.NET MVC to Razor Pages
• Introducing Pausepoints for Unity in Rider 2020.2
• Memory profiling on Linux and macOS with dotMemory 2020.2

Check out this fantastic offer! CODE Magazine is offering a free subscription to JetBrains customers!

If you have any interesting or useful .NET or general programming news to share via .NET Annotated Monthly, leave a comment here, email me at rachel.appel@jetbrains.com, or drop me a message via Twitter.

Subscribe to .NET Annotated!

Getting started with Rider for Unreal Engine is quick and easy. This video will take you through the initial steps, getting the app installed once you’ve registered and installed, and setting Rider as the default source code editor for Unreal. You’ll be introduced to the two main keyboard shortcuts that are the entry points to Rider’s advanced feature set, and see what Unreal plugins are required to get the most out of Rider, such as integrating Rider with Unreal Blueprints. Register to download your copy at jb.gg/unreal.

JOIN THE EARLY PREVIEW

Your Rider team
JetBrains
The Drive to Develop

Today, we would like to share with you how MRstudios is using JetBrains Rider. They have a team of software developers, visual effects artists and 3D artists, working together to develop real-time 3D applications for the manufacturing industry.

We spoke with Thomas Weiss, Technical Director and Co-Founder of MRstudios.

Hi Thomas! Can you tell us a little more about yourself and MRstudios?

I am the Technical Director and Co-Founder of MRstudios, a company I established with my friend Morten in Berlin in March 2016. In 2017, we incorporated the company in Prague. I have a Master’s degree in Computational Visualistics and 10+ years of experience in the fields of offline and real-time rendering.

MRstudios specializes in the development of real-time 3D applications for the manufacturing industry. We are proud to be considered one of the market leaders in Industrial Virtual and Augmented Reality solutions in German-speaking and Nordic markets.

What size is your team at MRstudios, and how large is the company?

Today, our team consists of more than 10 people, including software developers, programmers, visual effects artists, 3D artists, and a strong business development and operations team.

What is your current technology stack, and what types of projects do you work on?

We mainly work with game development tools such as 3ds Max, Blender, Photoshop, Quixel, Substance Painter, Git, and Unity. We use these tools to create interactive 3D experiences such as Virtual, Augmented, and Mixed Reality software applications – engineered from concept to completion, as we like to say.

This means that we cover the entire value chain, supporting clients all the way from the very early brainstorming stages through to rolling out a VR/AR strategy in corporations with thousands of staff members globally.

Our projects are usually targeted at technical training, sales and marketing, and product development. We are also increasingly supporting clients with highly complex systems, such as linking Unity-based software with enterprise cloud systems. The goal is always the same: speaking the language of our clients and making their life as easy as possible by adding to their existing channels and software architecture.

Are all your developers on the same operating system?

No, our developers are completely free to use whatever operating system they like the most. We don’t force them to use a strict framework. If someone doesn’t like Windows, which can happen, why can’t they use Linux? The same applies to Android or Apple devices.

Independent of the system applied, we have ISO27001 security protocols in place, which is highly valued by our industrial clients.

Why did you switch to Rider for your Unity development? How has it helped your team?

Using Visual Studio as an IDE in combination with Unity is better than using MonoDevelop, but a proper connection between the tools was still missing. The first time I heard of Rider was at Unite 2018 in Berlin. Back then I was very curious about it, but I wasn’t ready to switch from my existing development environment to something that I barely knew.

In the beginning of 2020, we had a lot of internal discussions on how to optimize and streamline our existing workflows as everyone was using different development tools such as Visual Studio, Visual Studio Code, Xcode, Sourcetree, and the like. This was the moment Rider was reintroduced.

Thanks to Rider, we now have a common tool that runs on all three major platforms, has a beautiful Git integration, and comes with perfect support for Unity. Since the introduction of Rider, the code quality and readability has significantly increased. Coding has never been this fast and easy as it is with Rider.

Did you face any issues switching from Visual Studio to Rider? What kind of experience did you have using a different tool?

Switching to Rider was flawless. Even commonly used shortcuts could be easily transferred. Switching your IDE is usually a very difficult process as it means you must adapt to a new user interface and a different environment.

You never know how Unity is going to react to a new IDE or whether you will encounter complications due to incompatibilities. We have discovered more and more tools within Rider that have helped us develop applications faster and in a more structured manner.

What does your typical development flow look like? How much time do you spend in Unity, and how much in Rider?

Given that we already have a 3D model that we can interact with, we start with the implementation of basic interactions like camera movements, animations of the model itself, and the like.

The user interface is developed during the 3D modeling phase, so optimally we can already start implementing it and making it interactable next to the implementation of the basic interactions. At this stage, client reviews are usually coming in and need to be implemented, so it is a back-and-forth between Unity and Rider depending on whether the changes affect the model or the interactions.

Toward the end, the development shifts to Rider, since the model and the visuals are already final. Implementing localization and backend connections is one of the last steps and Rider-only.

What do you think of the link between Rider and Unity?

My colleagues and I had never seen an IDE that could communicate with Unity in such a flawless and intuitive way. Code compilation in the background is a massive game changer. The usage information of methods and variables is very helpful. Code completion and automatic implementation of UnityEvents speeds up the whole workflow when working with the Unity EventSystem.

On top of all these features is the visually appealing integration of Git. Ultimately, well-developed code should be a feast for the eyes, too, shouldn’t it?

Has your coding style or architecture changed with better tooling support?

Definitely! Everyone comes from a different development background and has different methods for writing readable code. Rider tries to smooth out such differences by basically enforcing certain standards like naming conventions. Aside from this, it is the simple refactoring of if-statements, highlighting unused variables or methods, and the easy definition of namespaces.

We are to some extent a German company as both founders are from there, so we appreciate very well-structured coding environments. Rider supports this approach directly and indirectly, even if you have team members who tend to be, let’s say, a bit more liberal with their coding.

What are your favorite Rider features that help you on a daily basis?

In a nutshell:

• Alt+Enter and Shift+Shift, the two keyboard shortcuts which help you do everything
• Refactoring
• Unity usages

Are you aware of our Early Access Preview versions, and do you use them?

No, but I would like to try them out.

Note from JetBrains: you can download and install the Early Access Previews of Rider, or use the Toolbox App and install stable Rider and EAP versions side by side.

We’d like to thank Thomas and MRstudios for taking part in this Q&A.

If you use JetBrains IDEs and would like to share your experience with us, please let us know by leaving a comment below or contacting us.

Wondering how to build a Xamarin mobile application with Rider? In this blog post, our friends from Syncfusion explain how to do it using Syncfusion Xamarin Components.

JetBrains Rider is a cross-platform IDE for consistent application development. Cross-platform is what most mobile developers are, targeting Android and iOS.

Syncfusion Xamarin components include over 145 essential controls, like DataGrid, Charts, and ListView, for building powerful line-of-business Xamarin applications.

In this post we’ll be using JetBrains Rider along with Syncfusion Xamarin components to develop a mobile application that will illustrate a bus seating layout in a ticket booking app. To develop this application, we’re going to use Syncfusion’s Maps control for Xamarin.

Creating a Xamarin project in Rider

Follow the below steps to create a Xamarin application in JetBrains Rider:

1. Open the Rider IDE. When prompted with a few options, choose to create a New Solution.

2. In the New Solution dialog, select Application under the Xamarin category. Choose Xamarin.Forms for the type, .NET Standard for the sharing strategy, and then provide a name for the solution. Here we are going to use SeatingLayoutApp as its name. Click Create to create the project and the solution.

Adding SfMaps to the app

Follow the below steps to add an SfMaps control to the Xamarin project:

1. Right-click the Solution name in the Solution Explorer and choose Manage NuGet Packages.

2. Search for Syncfusion.Xamarin.SfMaps NuGet, select the NuGet package, and install it in the three projects in the solution.

   If you face any issues installing the NuGet package, try to update the packages —such as Xamarin.Forms package v3.6.0.344457 or above and Android support libraries package v28.0.0.1 or above—before installing the Syncfusion.Xamarin.SfMaps package.

3. Add the necessary XML Namespace for adding the Maps control in the application, and then add the Maps controls along with the layers.

   <?xml version="1.0" encoding="utf-8"?>
   
   <ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
                xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
                xmlns:local="clr-namespace:SeatingLayoutApp"
                xmlns:maps="clr-namespace:Syncfusion.SfMaps.XForms; 
                assembly=Syncfusion.SfMaps.XForms"
                x:Class="SeatingLayoutApp.MainPage">
   
       <Grid>
           <maps:SfMaps>
               <maps:SfMaps.Layers>
                   <maps:ShapeFileLayer />
               </maps:SfMaps.Layers>
       	</maps:SfMaps>
       </Grid>
   
   </ContentPage>

4. Add the necessary shape files to render the shapes on the map. A shape file is a set of files that are stored in a non-topological geometry with the attribute information for the spatial features and records in a data set.

   The maps control supports reading and loading shape files. A shape file can be a set of files or a single file. Generally, a shape file contains the following files:

   • Main file (.shp)
   • dBase file (.dbf)

   Download the shape files from the GitHub location: .shp file and .dbf file.

   • Android
     1. Add the necessary shape files to the Assets folder of the Android project.
     2. Open their properties by right-clicking them.
     3. Set AndroidAsset as the value for the Build action property.
   • iOS
     1. Add the necessary shape files to the Resources folder of the iOS project.
     2. Open their properties by right-clicking them.
     3. Set BundleResource as the value for the Build action property.
5. To launch the SfMaps control in iOS, SfMapsRenderer should be initialized in the FinishedLaunching method of the AppDelegate class.

   public override bool FinishedLaunching(UIApplication app, NSDictionary options)
   { 
       global::Xamarin.Forms.Forms.Init(); 
       Syncfusion.SfMaps.XForms.iOS.SfMapsRenderer.Init(); 
       LoadApplication(new App()); 
       return base.FinishedLaunching(app, options);
   }

With this we have created a Xamarin application, added an SfMaps control, and configured it.

Rendering custom shapes

Since the Xamarin.Forms SfMaps control renders shapes from shape data in the main shape file (.shp) and the dBase file (.dbf), you need to build shape data with coordinates that render a bus seating layout. For this blog post, we created the shape data beforehand. Now, assign the shape data file to the Uri property in the ShapeFileLayer. Since you need to select multiple seats, set the SelectionMode property to Multiple. Also, assign GeometryType to Points for custom shapes as shown in the following code.

<maps:SfMaps> 
    <maps:SfMaps.Layers> 
        <maps:ShapeFileLayer Uri="Custom.shp" 
         SelectionMode="Multiple" GeometryType="Points"> 
        </maps:ShapeFileLayer> 
    </maps:SfMaps.Layers>
</maps:SfMaps>

Next, create a view model class named ViewModel and populate the data for the seat number. Set the BindingContext of the MainPage to the view model class and Bind ShapeItems to the ItemsSource property of ShapeFileLayer.

Also, set the ShapeIDPath property to refer to the data field in the ItemsSource, and set the ShapeIDTableField property to refer to the column name in the dBase file (.dbf) of shape layers to identify the shape.

public class ViewModel
{
    public List<ShapeData> ShapeItems { get; set; } 

    public SeatingLayoutViewModel() 
    { 
        int totalSeats = 22; 
        ShapeItems = new List<ShapeData>(); 
        for (int i = 1; i < totalSeats; i++) 
        { 
            ShapeItems.Add(new ShapeData("" + i)); 
        }
    }
}

public class ShapeData
{ 
    public ShapeData(string seatNumber) 
    { 
        SeatNumber = seatNumber; 
    } 

    public string SeatNumber { get; set; }
}

<Grid x:Name="Maingrid" BackgroundColor="White">
    <Grid.BindingContext>
        <local:ViewModel /> 
    </Grid.BindingContext>
    <maps:SfMaps EnableZooming="false" x:Name="Maps">
        <maps:SfMaps.Layers> 
            <maps:ShapeFileLayer Uri="Custom.shp" ItemsSource="{Binding ShapeItems}" 
                 SelectionMode="Multiple" ShapeIDPath="SeatNumber" 
                 ShapeIDTableField="seatno" EnableSelection="true" GeometryType="Points" 
                 ShapeSelectionChanged="MapsTicketBooking_ShapeSelectionChanged"> 
            </maps:ShapeFileLayer> 
        </maps:SfMaps.Layers> 
    </maps:SfMaps>
</Grid>

Setting shape colors

Colors are applied to shapes to differentiate the booked seats and available seats. To do this, set the colors from the data source to the ShapeColorValuePath property. For the booked seats’ color, use the EqualColorMapping feature to set the color based on the seat number.

<Grid x:Name="Maingrid" BackgroundColor="White">
    <Grid.BindingContext>
        <local:ViewModel />
    </Grid.BindingContext>
    <maps:SfMaps EnableZooming="false" x:Name="Maps">
        <maps:SfMaps.Layers>
            <maps:ShapeFileLayer Uri="Custom.shp" ItemsSource="{Binding ShapeItems}" SelectionMode="Multiple"
                                 ShapeIDPath="SeatNumber" ShapeIDTableField="seatno" EnableSelection="true"
                                 GeometryType="Points"
                                 ShapeSelectionChanged="MapsTicketBooking_ShapeSelectionChanged">
                <maps:ShapeFileLayer.ShapeSettings>
                    <maps:ShapeSetting ShapeFill="Gray" SelectedShapeColor="#62AA5F"
                                       ShapeColorValuePath="SeatNumber"
                                       ShapeValuePath="SeatNumber">
                        <maps:ShapeSetting.ColorMappings>
                            <maps:EqualColorMapping Value="9" Color="#FFA500" />
                            <maps:EqualColorMapping Value="8" Color="#FFA500" />
                            <maps:EqualColorMapping Value="1" Color="#FFA500" />
                            <maps:EqualColorMapping Value="2" Color="#FFA500" />
                        </maps:ShapeSetting.ColorMappings>
                    </maps:ShapeSetting>
                </maps:ShapeFileLayer.ShapeSettings>
            </maps:ShapeFileLayer>
        </maps:SfMaps.Layers>
    </maps:SfMaps>
</Grid>

Enabling selection

For selecting shapes in maps, the selection feature should be enabled. All the shapes in the maps can be selected. This means you need to add code in the ShapeSelectionChanged event to restrict the selection of already booked seats and display the seat number to the right of the map when a non-booked seat is clicked.

private void MapsTicketBooking_ShapeSelectionChanged(object sender, ShapeSelectedEventArgs e)
{
    ShapeFileLayer shapeLayer = sender as ShapeFileLayer;
    ShapeData data = e.Data as ShapeData;
    if (data != null)
    {
        if (data.SeatNumber == "1" || data.SeatNumber == "2" 
            || data.SeatNumber == "8" || data.SeatNumber == "9")
        {
            if (shapeLayer.SelectedItems.Contains(e.Data))
                shapeLayer.SelectedItems.Remove(e.Data);
        }
    }
}

Customizing the map

Furthermore, you can add titles, images, and borders to maps in XAML to create the appearance of a bus seating layout, and you can add a button to clear the selection.

All these features are implemented in a sample we shared in this GitHub location. Build and deploy the project in all the platforms (Android, iOS).

The screenshot of the completely implemented sample will be similar to the one below.

Conclusion

I hope you have enjoyed reading this post and can see how easy it is to create a mobile application with JetBrains Rider and Syncfusion Xamarin Components.

To learn about even more features of the Syncfusion Maps component, visit the Feature Tour page. Try this sample and share your feedback as comments below.

Rider 2020.1.4 and ReSharper Ultimate 2020.1.4 are ready for you to download.

ReSharper Ultimate 2020.1.4

ReSharper 2020.1.4 comes with better support for one more C# 8 language feature: the ability to mark property accessors separately with the Obsolete and Deprecated attributes (RSRP-477579).

Rider 2020.1.4

Rider 2020.1.4 has a couple of fixes in addition to the C# 8 update from ReSharper:

• No more indefinite "waiting for intention actions…" message after calling the Alt+Enter menu (RIDER-44548).
• Rider can successfully connect to MS SQL Server (DBE-10839).

You’ll find ReSharper Ultimate 2020.1.4 and Rider 2020.1.4 on our website, or you can update using the Toolbox App.

We’re happy to introduce you to the .NET Guide – a central place for tutorials, tips & tricks for .NET and the JetBrains .NET tools!

All tips and tutorials are organized by product, technology, and topic. Tips & tricks show you how ReSharper and Rider can help you write better code, faster. Tutorials come with a screencast and extra written content, and are excellent for learning the basics and exploring additional resources. Tutorials range from an overview of .NET and ASP.NET Core, to profiling applications.

Some tutorials that are already available:

• Getting Started With ASP.NET — A set of short videos to understand the basic landscape of an ASP.NET application.
• The Basics Series — A set of short basic walkthroughs of different .NET technologies.
• Rider Essentials — Our developer advocates show their favorite tips and tricks, uncovering how they work with Rider.
• Profiling in Rider — Explore performance and memory profiling options in Rider, and optimize an existing application.
• JetBrains .NET Days Online 2020 — Session recordings of JetBrains .NET Days Online 2020.

Go check them out!

Bite-sized tips will periodically be tweeted from our Twitter accounts, @ReSharper and @JetBrainsRider. An example is this tip showing live and postfix templates that help write code to iterate a collection.

Tutorials are more elaborate, and typically contain a screencast and written content that provides further learning and resources. Don’t want to read the text? Watch the screencast! Don’t want to watch the screencast? The text will get you there! Doing both will give you more value, as video and text cover additional topics.

Have your own tips & tricks to share? Want to see a specific tutorial?

We have already gathered quite a few tips & tricks and tutorials, and we’ll add more over time. What do you want to see? Are you looking for specific tutorials, or have tips & tricks everyone should know about?

Share your thoughts in the comments below!

The recording of our July 9 webinar, How to stop worrying and adopt nullable reference types – Webinar Recording, with Andrey Dyatlov, is now available. Subscribe to our community newsletter to receive notifications about future webinars.

Nullable reference types is a deceptively simple feature. While starting with it is as easy as adding a single ? mark to your source code, migrating large code bases has been proven to be a tedious and sometimes quite tricky task especially when complex code contracts and generics are involved.

The presentation will quickly cover what benefits this feature brings to the table, how it differs from JetBrans.Annotations attributes and how it evolved since its original release almost a year ago.

I will show a couple of ways to ease migration of large code bases to nullable reference types and how you can start to benefit from the feature immediately without putting any effort into annotating your code base just yet. I will also outline the most common pitfalls and explain how to deal with generics and potential analysis shortcomings as well as how to guide the compiler through complex code contracts to get the most out of this feature.

(more…)

Working with NuGet is an important part of every .NET project, and therefore its integration in Rider is one of our top priorities. Previously we introduced productivity boosts like import of missing packages, the NuGet quicklist and auto-display of README files. Now we want to show you some recent additions in the latest Rider 2020.2 EAP release.

In this new version, we’ve added a new way to view implicit package references, extended the NuGet package list with a brand new context popup menu to access common operations, implemented a package search history, enhanced the config view with a property pane to manage package folders with additional validation, introduced warnings about package deprecation, and fixed several more issues along the road. We’ve also made a large number of internal refactorings to pave the way for more features and fixes to come.

Let’s get ready for some NuGet magic!

Implicit Package References

Up until now, we could use the Solution Explorer to browse NuGet packages and view the transitive dependencies and assemblies contained in these packages:

The task of investigating transitive packages becomes tedious with extensive dependency chains, and even more so if we need to see why a certain package was imported, i.e., to check which explicit package references a given transitive package.

From Rider 2020.2 we can use the NuGet tool window to see all the transitive packages of a solution or project in a new Implicitly Installed Packages section:

Hovering over implicit packages reveals a tooltip containing information about its version and the referencing package. If the package is referenced in multiple versions, they will all be shown:

Context Popup Menu

Another convenient feature we’ve added is a new context popup menu that can be invoked via right-clicking or pressing Alt-Enter on a NuGet package:

From here we can quickly access all the relevant actions for a single NuGet package, like updating or removing the package, opening it in the Assembly Explorer to examine the API, revealing it in the filesystem explorer, navigating to the related NuGet.org entry, or finding dependent code. Also remember that we can just start typing here to filter actions!

Notably, there is also a new Quick NuGet Documentation action that is more of a keyboard-driven way to bring up the implicit reference paths to a package:

This action uses the same shortcut as the existing Quick Documentation action to integrate fluently into our existing muscle memory.

Package Search History

The search box for packages also received an update. Notice the little triangle next to the magnifier? We can either click on it or use Alt/Option - Down Arrow to open the history of recent package searches:

By the way, this is also available in other search boxes, like Find/Replace in File or Find/Replace in Solution.

Specify Package Folders  & Validate NuGet.config

A central part of NuGet is the configuration, which resides in NuGet.config files and works hierarchically across directories. In Rider, we already have the Sources tab in the NuGet tool window to take a glance not only at the relevant NuGet files but also at the effective configuration. In Rider 2020.2 we can now also edit values for two of the most commonly changed properties globalPackagesFolder and repositoryPath:

For relative values, we can see the effective path right below the text boxes. Of course we can also choose from a directory dialog, for instance to choose a folder from another disk.

When adding or changing local source feeds, it’s pretty annoying when we find out later that we put in the wrong value. In the Feeds tab we can now immediately see whether a feed path is invalid as the path will be highlighted with a red rectangle:

A warning message will also be shown in the search list if we search for a package and it is not found in any of the feeds:

Deprecation Warnings

When searching for a package in the NuGet tool window, it would be great to have a visual indication of which packages are still in maintenance or have been deprecated. The new warning in the details pane will help us:

We hope you like the new NuGet improvements! These are just the initial steps towards better NuGet integration that we plan to implement. Feel free to leave us feedback in the comments below. Download Rider or – even better – try JetBrains ToolBox to easily test new releases and leave your working environments untouched!

Join us Tuesday, August 25, 2020, 16:00 – 17:00 CEST (10:00 AM – 11:00 AM EDT or check other timezones) for our free live webinar, REST – the ignored parts, with Irina Scurtu.

Register now!

In a world dominated by APIs, where everyone seems to implement microservices with so many paradigms and standards to choose from, REST seems to be the default option. Despite that, many of these so-called REST APIs don’t respect the guidelines and become brittle by overlooking some of the most powerful constraints.

In this session, we will look over how we can design a REST API that is flexible and evolvable by being in sync with what HTTP has to offer.

We will look over OData as a way to filter data, versioning, hypermedia types specs, and status codes by fine-tuning .NET Core.

(more…)

In brief, what’s changing?

To simplify the licensing for our .NET and Visual Studio tools, we’ve reduced it to just three simple options:

• ReSharper subscription – for users of our Visual Studio extensions: ReSharper or ReSharper C++ or both.
• Rider subscription – for users who prefer our fast standalone .NET IDE, or do cross-platform .NET Core, Unity, or Xamarin development.
• dotUltimate subscription – for users who combine Visual Studio extensions with Rider in their development, or need any of our advanced profilers (dotTrace and dotMemory) or a code coverage tool (dotCover).

(There is also an All Products Pack, of course, which includes all JetBrains desktop tools.)

To simplify things, we covered ReSharper and ReSharper C++ with one license. We also decreased the price of the all-in-one .NET pack (which now falls under dotUltimate).

To make it easier to work with all tools included in dotUltimate, we’ll have a common installer for all the dotUltimate products on Windows. It will be able to install all the .NET products and VS extensions by JetBrains by the time the 2020.2 release is ready.

More details on the change

Starting August 2020, we will no longer sell the following licenses:

• ReSharper C++
• ReSharper Ultimate
• ReSharper Ultimate+Rider

The dotUltimate license will cover all paid .NET & Visual Studio tools from JetBrains (ReSharper, ReSharper C++, Rider, dotTrace, dotMemory, and dotCover). It will cost the same as ReSharper Ultimate currently does, but will also include Rider. Holders of active ReSharper Ultimate and ReSharper Ultimate+Rider licenses will be automatically transferred to the new dotUltimate, with all their continuity discounts preserved.

If you are a ReSharper or Rider license holder and you want to simply continue using the corresponding product only, you can safely ignore this post. Nothing changes for you. ReSharper license holders will get access to the ReSharper C++ product and vice-versa.

To figure out what this change means to you and if you need to react, please keep reading.

Why we will update our licensing

Get an easier licensing scheme

Simpler licensing is the main goal of the change. Customers can now choose the IDE or the extension they need, or they can get all the .NET products in one pack.

Rider and ReSharper under one license

Switching between Rider and Visual Studio with ReSharper is easy with dotUltimate. You can work on your Windows projects in Visual Studio augmented by ReSharper, and at the same time use the fast and powerful Rider IDE for your cross-platform .NET development.

Because Rider is powered by the ReSharper engine, as a Rider user you won’t miss any benefits that are part of your ReSharper experience, but will find even more goodies. For example, integrated support for VCS, Local History always on hand to save you from losing uncommitted changes, and SQL editing tools from the DataGrip team – all of this in a fast and responsive editor.

To learn more about Rider, check out our Rider Essentials, where our developer advocates share their favorite tips and tricks and help you discover new ways to work with the IDE.

Profiling and code coverage support

A dotUltimate license is a great choice for developers who are keen to eliminate performance bottlenecks, plug memory leaks, and ensure their unit tests are fully covered. The dotUltimate license gives you access to the profilers (dotTrace and dotMemory) and a coverage tool (dotCover). And it’s not only about these individual tools or the integration in Visual Studio, as the dotUltimate license also covers plugins for dotCover and dotTrace in Rider!

We want to make profiling tools even more easily accessible in the code editor for your day-to-day code maintenance activities. In Rider v2020.1, we introduced Dynamic Program Analysis (DPA), which auto-detects memory issues in your application while running in the background of your IDE. DPA is licensed as part of Rider (and we plan to add it to ReSharper later).

Use C++ along with C#

Another part of the change is the C++ support that we now provide to all our ReSharper customers. We have two siblings in the family that have lots of shared code – ReSharper and ReSharper C++, each of which provides value to its set of users. However, according to our feature usage statistics, we see that one in seven .NET projects includes some native C++ code. There is also C++/CLI, a bridge between C# and C++, which can be better served by using a combination of both flavors of ReSharper.

So if you work with both C++ and C#, you no longer need to buy a second license – the ReSharper license now includes both ReSharper and ReSharper C++. The licenses currently available will continue to work but will now also include access to the other ReSharper, too.

ReSharper C++ will continue to evolve – the team has some very promising plans in the pipeline. Moreover, it now powers Rider for Unreal Engine, a preview edition of Rider with C++ support that can be used to craft games with Unreal Engine. When released, it will become a part of the Rider product, bringing to it C++. This decision is fully aligned with the ReSharper/ReSharper C++ licensing change.

What this means for you

Identify yourself with one (or several) of the groups below to understand how exactly the change affects you:

1. You have an active ReSharper Ultimate subscription. Before August 2020, we will automatically transfer it to the newly created dotUltimate license. The change will be reflected in your JetBrains Account. You can continue using ReSharper and ReSharper C++, the profilers (dotTrace and dotMemory), and the coverage tool (dotCover) as before, and also start using Rider right away. Discounts for your second and third subscription years onwards are applied when this license is updated. Fallback products now also include Rider.
2. You have an active ReSharper Ultimate + Rider subscription. Before August 2020, we will automatically transfer it to the newly created dotUltimate license. The change will be reflected in your JetBrains Account. You can continue using all .NET tools from JetBrains. And you’ll pay less next time you are updating the license, not only because the continuity discounts are preserved but also because the dotUltimate license comes with a lower price.
3. You have an active ReSharper subscription. Starting August 2020, it’s also valid for ReSharper C++. Fallback products now also include ReSharper C++.
4. You have an active ReSharper C++ subscription. Starting in August 2020, it’s also valid for the ReSharper product. Please note we will no longer sell new licenses of this kind. Only renewals will be possible (via JetProfile or contact the sales). Continuity discounts are preserved. Fallback products now also include ReSharper.
5. You have an active Rider subscription. There are no changes you need to consider.

If you have an active All Products Pack subscription, there are no changes to your license. If you own several subscriptions for several .NET products and have questions or just want to upgrade to a bigger pack (like dotUltimate, for example), please contact our sales team.

What you need to do with regard to the licensing changes

We know you have lots of important projects and tasks to do. So we’ll do our best to perform all the changes automatically and smoothly, in order not to impact you. Our team is now preparing the change and making sure the transfer process runs seamlessly.

Once the changes are released, you will be able to start using the new products available with your updated license right away.

There is only one scenario where action from you would be required – if you are using an activation code and would like to use the newly added products (not previously available to you under your license). In this case you will need to reissue the activation code in your JetBrains Account once the change is made effective (see the Important dates section below).

For example, if you have an active ReSharper Ultimate license and use an activation code to register the product, it will still work for ReSharper, dotTrace, dotMemory, and dotCover. To use Rider after the change, the activation code will have to be reissued in your JetBrains Account.

Important dates

These changes will take effect with the 2020.2 release, which we estimate to be released approximately the first week of August. Transferring of the active ReSharper Ultimate and ReSharper Ultimate+Rider licenses will start one week before that, at the end of July. All licenses will be transferred automatically, and a notification with a link to this blog post will be visible in the JetBrains Accounts of all affected customers.

Have a question?

Drop it here in comments or contact our support or sales teams. We’ll be happy to assist.

We do hope the changes open new opportunities for many of you and you are just as excited as we are to move forward with this!

Your .NET team
JetBrains
The Drive to Develop

We’re often asked how ReSharper and Rider relate to build servers, and how their features can be utilized in CI/CD environments. There are actually quite a few tools bundled in free packages – namely ReSharper.CommandLineTools or dotCover.CommandLineTools – that can help to continuously monitor and improve our codebase. In this post, we will discuss the ReSharper tools, which include:

• InspectCode – runs code analysis to find and report code issues
• DupFinder – identifies semantically duplicated code fragments
• CleanupCode – reformats code to make it consistent

Check out our blog posts that put a more practical focus on InspectCode, DupFinder, and CleanupCode:

But now, without further ado, let’s get to the real news: these tools are now cross-platform, and can be used as .NET global tools!

Running Cross-Platform

Many of our tools already run cross-platform. With the latest 2020.2 EAP package, the ReSharper command-line tools also contain 3 shell scripts to run on Linux and macOS:

./inspectCode.sh MySolution.sln
./cleanupCode.sh MySolution.sln
./dupFinder.sh MySolution.sln

Note that as a result of going cross-platform, we’ve also updated the parameters to use double-dashes instead of single slashes.

Usage as Global Tools

A while ago, the .NET Core SDK introduced .NET Global Tools, which can be installed to be globally available like other shell commands. Targeting netcoreapp3.1, we’ve prepared a new jb global tool shipped with the JetBrains.ReSharper.GlobalTools package that lets us easily invoke InspectCode, CleanupCode, or DupFinder without needing to worry about where the tools are located:

dotnet tool install JetBrains.ReSharper.GlobalTools --global
jb inspectcode MySolution.sln
jb dupfinder MySolution.sln
jb cleanupcode MySolution.sln

In a build script, we can also install it as a local tool to keep the operating system clean from unnecessary modifications. Using a tool manifest file, we can execute the following locally:

# One-time locally
dotnet new tool-manifest
dotnet tool install JetBrains.ReSharper.GlobalTools

# In the build script
dotnet tool restore
dotnet jb inspectcode MySolution.sln

Without a tool manifest, we can use the --tool-path parameter:

dotnet tool install JetBrains.ReSharper.GlobalTools --tool-path ./
./jb inspectcode MySolution.sln

We’d also like to say thanks to John for this suggestion!

Please let us know if you have any questions or feedback, and give ReSharper or Rider a try if you haven’t already done so. They’ll definitely make it easier to fix code smells and generally clean up code!

Where and when does a value in our program change? And what’s the state of values in each iteration, when debugging recursive functions? Two good questions that Rider 2020.2 EAP helps answer, with Data Breakpoints and Pin-to-Frame! (more…)