Editing Tips & Tricks

Know everything there is to know about editing code.

2020-01-29

.net completion editing ide inspections resharper rider

Editing code is a core activity in the IDE. ReSharper and Rider can help write clean code faster, and more efficiently.

In this playlist we're going to have a look at the many editing and code completion features in ReSharper and Rider, and how to effectively use them.

Move Code

Move code the smart way!

Move code the smart way! 👈🙃👉

Instead of cutting and pasting lines, and breaking code, let's move things semantically: First we put our caret on the code intended to be moved. Then, we use Code | Move Statement Up/Down to rearrange it. Despite the refactoring name, this also works for methods, properties and other members. Placing the caret at the closing brace of a block statement, like if or while, even lets us expand and shrink the scope.

We can also reorder parameters of signatures. Again, we just place our caret on a particular parameter, and use Code | Move Element Left/Right to specify its new position. Note that if our method already has usages, we might consider using the Change Signature refactoring instead, which would update the argument order.

Alright, now move move move! 👇😌👆

Introducing Variables

Introduce variables the way you like!

Struggling with long lines of code? 🙇‍♀️

Existing expressions can easily be assigned to a new variable using the Introduce Variable refactoring. We can either select the expression and invoke Refactor | Introduce Variable or type .var at the end of the expression to invoke the related postfix template. The refactoring also takes repeated occurrences of our expression into account to reduce code duplication.

Of course, inlining a variable is equally easy using the Refactor | Inline Variable refactoring.

Remember to always use meaningful names! 🏷

Cleanup Namespaces

Fix all unused namespaces right from where you are!

You know that feeling, right? 😣

We're just about to commit our changes and then realize that we have some code smells or dead code left 😵 But there is nothing to worry about! Rider's integrated side-by-side diff viewer allows to fix them right from where we are and even in bulk!

Feel the magic of having VCS support in an IDE! 🥰

Iterating Collections

There's no faster way to iterate!

Get your hands some rest! 😌

Dealing with collection-like objects is easy if you have live and postfix templates at your fingertips. Either write foreach as a single word, or add .foreach at the end of your collection object. Then, just hit ⇥ (macOS) / Tab (VS Windows/Linux) and confirm the different hotspot variables: collection object (only live template), type name vs. var keyword, and the iteration variable name. In most cases, the variable name can already be inferred from the collection object name. Good naming pays off! 😉

Which way is your favorite? ⭐️

Formatting code in columns

Easily read common code in column-style layout!

Ad-hoc formatting or everywhere? 📐

Aligning properties in columns can greatly improve readability for DTOs or vector data types. We can also align binary expressions, invocations and many more constructs. However, often we don't want to apply such formatting across our whole code base, but in very particular cases. Using formatter comments, we can format our code just for a specific scope:

public class PersonDto
{
    // @formatter:<setting_name> <value>
    public Guid     PersonGuid  { get; set; }
    public int      PersonId    { get; set; }
    public DateTime UtcCreated  { get; set; }
    public DateTime UtcModified { get; set; }
    public string   Name        { get; set; }
    public string   Email       { get; set; }
    public string   City        { get; set; }
    public string   State       { get; set; }
    public int      ZipCode     { get; set; }
    // @formatter:<setting_name> restore
}

In order to determine the setting_name and value, we recommend to first change the formatting through the settings dialog, save it to the solution layer, and then to identify the added line in your-solution.sln.dotsettings.

May the formatting be with you! 🧙🏻

C# 8 Support

Master all the C# 8 language features!

How do these C# 8 features work again? 🤔

Learning new language constructs with Rider is just a matter of hitting ⌥⏎ (macOS) / Alt+Enter (VS Windows/Linux). Convert a switch statement to switch expression? ⌥⏎ (macOS) / Alt+Enter (VS Windows/Linux)! Prefer compound assignments instead of simple assignments? ⌥⏎ (macOS) / Alt+Enter (VS Windows/Linux)! Make use of IAsyncDisposable and using declarations? You know what – Alt-Enter! 🙃

Note that most quick-fixes can be applied in scopes, for instance in the current method, type, file, or even for the whole solution.

⌥⏎ (macOS) / Alt+Enter (VS Windows/Linux) – Probably the most important shortcut 🤓

JSON schema support

The best way to work with JSON and YAML files!

Want to love JSON and YAML again?! 😄

Rider has WebStorm included. Our powerful IDE for all things web-related. This means we can benefit from its excellent JSON schema support, which serves us with code completion and schema verification in both JSON and YAML files.

Most of the time, schemas are detected automatically, but they can also be manually selected from the status bar. In JSON files we can also specify the $schema top-level property.

We wish you a happy JSON and YAML time! 🙇‍♀️🙇‍♂️

Expand/Shrink Selection

One more chance to leave your mouse aside!

Fiddling around trying to get the right selection? 😭

Using the Expand Selection and Shrink Selection actions is an effective way to select the right text fragments. Knowing how CSharp, JSON, XML, and other formats syntactically work, they will always lead us to the next logical element or construct. For instance, we can easily select strings, block statements, methods/classes, JSON properties, or just text paragraphs. This naturally improves how we can introduce variables, move code blocks, or just fix a typo in a single word.

Shrinking a selection works context-sensitive, meaning that if we accidentally expanded too much, we can easily go back to the previous selection.

Note that Editor | General | Typing Assistance | Use CamelHumps can be enabled to treat camel-humps in single words as a next selection target.

While technically possible, we strongly advice not to use this shortcut to select a whole file. Please consider Ctrl+A for that matter. 😅

Occurrence Selection

Poor man’s manipulation to the rescue!

Where we go, we don’t need Find & Replace! 🛹⚡️

Using actions for occurrence selection is a powerful way to transform and manipulate all kinds of texts. We start by making a selection for our text. With every call to Add Selection for Next Occurrence we get another multicaret that can be moved around, insert and delete text, expand or shrink its individual selection, or toggle the casing of its text. This is exactly what we need if we have to fix only a couple of similar invocations or change the format of our data! 🎭📐

Remember to always use meaningful names! 🏷 Invoking Unselect Occurrence removes the previously added selection; Select All Occurrences scans the whole document for occurrences and selects them.

But remember: always give refactorings a try first! 🔧🤓