Cross-platform C# Programming with JetBrains' Rider

Visual Studio has had a lengthy reign, but now there is a new viable option in JetBrains' Rider. This blazing-fast IDE is the subject of this course, and you can program any application with it after watching this course.
Course info
Rating
(15)
Level
Intermediate
Updated
Mar 10, 2017
Duration
2h 33m
Table of contents
Description
Course info
Rating
(15)
Level
Intermediate
Updated
Mar 10, 2017
Duration
2h 33m
Description

JetBrains Rider is the first viable alternative to Visual Studio. In this course, Cross-platform C# Programming with JetBrains' Rider, you will learn how Rider provides a fusion of the award-winning ReSharper and IntelliJ platforms. Next, you'll explore how to use the power and performance of a blazing-fast IDE platform with over 10 years worth of analysis, and how to perform refactoring and other helpful features of ReSharper. After you have taken this course, you will be able to program almost any application you want to using Rider.

About the author
About the author

Dmitri is a developer, speaker, podcaster, technical evangelist and wannabe quant.

More from the author
ReSharper Fundamentals
Intermediate
2h 54m
Apr 28, 2017
More courses by Dmitri Nesteruk
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone, my name is Dmitri Nesteruk, and I'd like to welcome you to my course on Cross-platform C# Programming with JetBrains' Rider. As a former technology evangelist at JetBrains, I'm a big fan of various developer tools, and I'm particularly excited to tell you about a new JetBrains integrated development environment called Rider. Now Rider is a cross-platform. NET-centric IDE that is positioned as a faster and cross-platform alternative to Visual Studio. Rider brings with it all of the benefits of the award-winning ReSharper plug-in, coupled with the power and portability of the IntelliJ platform. So in this course we're going to cover the following modules. We'll have an introduction where we discuss what Rider is and what its position is in the field of development environments. Then we're going to take a look at running, debugging, and testing your programs in JetBrains' Rider. We're going to take a look at the Search and Navigation facilities available in the IDE. We'll take a look at some of the coding assistance features. We'll take a look at code generation and templating in Rider. We'll take a look at the various refactorings that Rider supports, and we'll consider additional functionality. By the end of the course, I hope you'll gain an appreciation for the advantages that Rider offers, and I hope you'll become comfortable in using Rider to develop. NET applications. A key requirement for this course is for you to be familiar with. NET development in general. Knowledge of IDE concepts and experience with other IDEs such as Visual Studio will be beneficial, but it's not essential. So I hope you'll join me on this journey to learn about Rider with the Cross-platform C# Programming with JetBrains' Rider course here on Pluralsight.

Running, Debugging, and Testing
Hello. In this module, we're going to take a look at how to run our programs, how to debug them, and how to test them as well. So here are some of the things we're going to see in this module. First of all, we'll take a look at the process of editing code, as well as running the code and seeing some output. Then we're going to take a look at the integrated debugging functionality, which is included in Rider. Then we'll talk about NuGet support, because Rider also supports NuGet packages, and it has a special window for working with NuGet. And finally we'll take a look at the integrated unit testing options in Rider.

Search and Navigation
One of the principle strengths of Rider is in navigating very complex codebases. So this module will demonstrate Rider's search and navigation facilities when inspecting a fairly complicated project. So here's what we're going to see in this module. First of all, we'll talk about something very simple, we'll talk about the command for going to a declaration, and what happens if you go to a declaration on a type which you don't have the sources for. Then we'll take a look at the key part of Rider's search functionality, which is called Search Everywhere. Just as the name suggests, it basically performs a search on every kind of element it can get its hands on in terms of the overall project. Then we'll take a look at how to navigate type hierarchies, so when you implement interfaces or when you inherit classes, whether they are abstract or not, you can navigate up and down the inheritance hierarchy. We'll then take a look at the Navigation Bar, which is yet another way of navigating, in addition to the Solution Explorer. We'll take a look at how to use bookmarks in Rider. We'll take a look at how to find the usages of a particular symbol somewhere in your solution. We'll take a look at a special menu called the Navigate To menu, which is used to kind of group all the navigation options for a particular element together, and finally we'll just discuss actions, which are not related to navigating code, they are more to do with navigating the set of commands that are available in Rider as a platform.

Coding Assistance
In this module, we discuss the different ways in which Rider helps you write code and manipulate code on a textual level. Note that we're not going to talk about the major automated operations such as refactorings, we're talking more about the down-to-earth editing experience, like having your brackets automatically closed for you, that sort of thing. So here's what we're going to see in this module. We'll start by looking at the key features of coding assistance and discuss simple things such as how to comment code, how to move it around, and how to trigger simple context actions using the Alt+Enter shortcut. We then take a look at code completion, which some of you might know as IntelliSense. Rider has a more smart variant of code completion compared to Visual Studio, and it will be interesting to see what the differences are. Now armed with the knowledge of code completion, we'll then look at the way in which Rider helps us get the using statements and the references that our project needs. And finally, we'll look at some results from Rider's code analysis, and how the so called Quick Fixes can help us fix possible errors.

Code Generation
A lot of our programming efforts goes into creating structures, which are very mundane, like for example a constructor for a typical type is fairly obvious to create, and there should be no need to type it by hand, so this is where Rider's code generation functionality comes in because it actually tries to help you in making all those constructs automatically. So here is what we're going to see as part of this module. First of all, we'll talk about something called generative completion. Now this is the idea that when you get a code completion list, not only do you get a list, not only do you get a listing of the members that you can complete, but in addition you also get some extra options, which allow for code generation. In addition, we'll take a look at the Generate menu, which is the central place in which Rider can help you generate the different code elements, so this is where most of the functionality actually resides. In addition, we'll talk about a functionality called Create From Usage, which is the idea that you first of all type the construct as you're using them, and then you generate them later. And finally we'll take a look at templates, with a focus on the pneumonic templates that I've been using throughout this entire course.

Refactoring
Refactoring is this concept of changing the structure of your code so as to make it better organized and more usable, while at the same time preserving the correctness of execution. So in this module we'll take a look at Rider's different code refactorings, and how they work. Here's what we're going to see as part of this module. First of all we'll take a look at what's probably the most common kind of refactoring, the rename refactor, and where you just want to rename a class or some kind of symbol, and you want the change to be propagated throughout all the places where that symbol is being used. Then we'll take a look at the different introduce refactorings, those refactorings, just as the name suggests, they introduce a variable or a parameter, or they introduce some new piece of code essentially. Then we'll take a look at extract and inline method, which allows you to take a chunk of a method, and put it into a separate method, and then return back by inlining what you've just extracted. Then we'll discuss distracting interfaces and classes, and working with inheritance hierarchies and kind of pulling members up, pushing members down, that sort of thing. Then we'll take a look at a few more refactorings, which are a bit more difficult to categorize, there are lots of things like, for example, changing a constructor into a factory method, and we'll finish off the module with a discussion of refactorings available not just on individual class and class members, but on files and entire project structures.

Additional Functionality
Hi there. In this module we're going to take a look at a few more pieces of functionality, which Rider provides. So here's what we're going to see. First of all, we'll take a look at something called Quick Switch Scheme. Now this is another menu that lets you quickly change the presentation style of the entire IDE. Then we'll talk about scratch files, what they are for, and how they can be used. We'll take a look at the terminal once again, and we'll find a nice and interesting use for the terminal. We'll talk about the support for the different source control systems. And finally we'll take a look at some examples of support for WPF.