IDE for .NET utviklere
Rider er et multiplattform .NET IDE basert på IntelliJs plattform og Resharper. Utvikle .NET, ASP.NET, .NET Core, Xamarin eller Unity applikasjoner på Windows, Mac og Linux.
Rider from Jetbrains supports .NET Framework, the new cross-platform .NET Core, and Mono based projects. This lets you develop a wide array of applications including .NET desktop applications, services and libraries, Unity games, Xamarin apps, ASP.NET and ASP.NET Core Web applications. It provides 2000+ live code inspections, hundreds of context actions and refactorings, and combines them with the IntelliJ platform's solid IDE features. Despite a heavy feature set, Rider is designed to be fast and responsive. As well as running and debugging multiple runtimes, Rider itself runs on multiple platforms: Windows, macOS and Linux.
- ReSharper + IntelliJ platform - UI and multiple features of the IntelliJ platform, which powers IntelliJ IDEA, WebStorm, and other JetBrains IDEs. It's cross-platform, familiar to millions of developers, and provides core functionality such as VCS and database support. On top of that, add ReSharper features: navigation and search, refactoring, code inspections, quick-fixes, and so on.
- Designed to be smart and fast - Rider isn't jammed into a 32-bit process, which helps it gain deep insight into your code while still being responsive. It opens (and reopens) most solutions with almost zero latency. External changes to solution? Switching Git branches? Not a problem: It catches up quickly. When you edit code, the topmost priority is to make sure that you type as fast as your fingers are trained to, not only as fast as the IDE can process your input.
- Works on Windows, Mac and Linux - Rider can run on multiple platforms: Windows, macOS and different breeds of Linux. If you want to edit, build, run or debug Unity or .NET Core applications on a Mac, here's your full-blown IDE.
- Intelligent code editor - It provides tons of smart code editing features, such as different kinds of code completion, auto-importing namespaces, auto-inserting braces and highlighting matching delimiters, rearranging code, live and postfix templates, controller and action hyperlinks in ASP.NET MVC, a multi-selection mode, gutter icons for inheritance navigation, as well as quick access to refactorings, generation, navigation and context actions.
- Code analysis - Boasts 2000+ live code inspections to help you detect errors and code smells. Over 1000 quick-fixes are available to resolve detected issues individually or in bulk: just hit Alt+Enter to pick one. For a bird's-eye view of errors in your projects, use solution-wide error analysis (SWEA): it will monitor errors in your code base and let you know if anything goes wrong, even you don't have a problematic file open in the text editor.
- Navigation and search - Jump to any file, type, or member in your code base in no time, as well as find settings and actions, all with a common Search Everywhere shortcut. You can find usages of any symbol, including cross-language usages and usages in string literals. For contextual navigation, use a single Navigate To shortcut that will take you from a symbol to its base and derived symbols, extension methods or implementations.
- Decompiler - Want to know how third-party library code works? No problem with Rider: just use Go to Declaration on a library symbol, and have Rider decompile the library type to C# in a regular editor tab. You can then navigate decompiled code as you normally navigate your source code, as well as find and highlight usages. Sometimes however, decompiling is not even necessary: Rider can fetch source code from source servers such as Microsoft Reference Source Center.
- Refactoring - Most of ReSharper's 50+ refactorings are already available in Rider, and its 350+ context actions are all there. You can rename, extract methods, interfaces and classes, move and copy types, use alternative syntax, and a lot more! Look for available refactorings in the Refactor This pop-up, or use context actions that you can access with Alt+Enter.
- Unit testing - Rider lets you run and debug unit tests based on NUnit and XUnit in applications targeting .NET Framework, .NET Core and Mono. Rider marks test classes and methods with a gutter icon in the editor: click it or use the Alt+Enter menu to run, debug and manage tests. You can explore tests, group them in different ways, break them down into individual sessions, see test output and navigate to source code from stack traces.
- Debugging - Rider includes a debugger that works with .NET Framework, Mono and .NET Core applications. You can create multiple debug configurations, attach to external processes, set and manage breakpoints and breakpoint conditions, step into, over and out, run to cursor, set watches, evaluate expressions and explore threads.
- Version control - Rider includes support for Git, Subversion, Mercurial, Perforce and TFS out of the box, with more version control systems supported via plugins. In the code editor, local changes are highlighted as you type. Using a dedicated VCS tool window, you can view local, incoming and repository changes, manage changelists, shelve changes for later use, view diff, commit and push. A built-in visual merge tool will help you resolve conflicts, and Rider will even let you know if a file you are working on has been changed after your last update.
- Databases and SQL - You can work with SQL and databases without leaving Rider. Connect to databases, edit schemas and table data, run queries, and even analyze schemas with UML diagrams. Rider's rich SQL editor comes with syntax highlighting, smart code completion, on-the-fly code analysis, code formatting and navigation.
- Plugins - Rider takes advantage of its roots by supporting a wide array of plugins developed for the IntelliJ platform and ReSharper. In addition to bundled plugins (such as those for VCS, F# and Unity support), you can choose to install more plugins as you need them: when you open a file supported by a plugin that you're not using, Rider will suggest that you install it. For example, plugins are available that support Markdown, .gitignore files and Python scripts.
Download demo of Rider
Download a trial of Rider and evaluate the product for 30 days. A trial license can be downloaded at https://www.jetbrains.com/products.html.
Operating System for Deployment
- Windows 10, 8.1, 8 or 7. 64-bit distributions only.
- OS X 10.10+. 64-bit distributions only.
- Linux. 64-bit distributions only.
Here is our collection of resources for learning and getting the most of your subscription of JetBrains.
JetBrains uses a subscription-based licensing model, allowing you to purchase yearly subscriptions that includes all bug fix updates. The new licensing model also includes perpetual fallback license grants. When purchasing an annual subscription, you will immediately get a perpetual fallback license for the exact version available at the time of your purchase.
Commercial Annual Subscription - for legal entities, including companies and organizations (both for-profit and non-profit), requiring the software for general commercial use. A legal entity may use the software under the Business Subscription on any computer, operating system, and by any developer within a legal entity, provided that the total number of concurrent users never exceeds the number of subscriptions purchased by that legal entity.
Commercial Annual Subscription includes:
- Free unlimited email access to technical support and online support resources for the period of the Business Subscription
- Free generally available bug fix upgrades, minor releases and major releases for the licensed JetBrains IntelliJ IDEA edition for the period of the Business Subscription
- Available to any legal entity (companies and organizations, including non-profit and government)
- The license is owned by the legal entity, not by an individual
- Non-transferable restriction: Use of the software is restricted to the legal entity with no right to transfer. Companies and organizations can only transfer their licenses between employees and contractors
- The licensed purpose of use is general commercial usage
- Multi-user license - the total number of concurrent software users cannot exceed the number of purchased subscriptions
- The license term is time-limited, based on yearly subscription payments
- Perpetual fallback license: Your license is NOT perpetual. The new licensing model includes perpetual fallback license grants. Perpetual fallback license is a license that allows you to use a specific version of the software after your Business Subscription expires. The specific version of the software that you can fallback to use when your Business Subscription expires will be the exact version available at the time of your purchase
In the subscription following Support and Maintenance with JetBrains is included
- Unlimited access to technical support via e-mail
- Free upgrades to all minor and major releases including bug fixes
We recommend the following JetBrains support- and resource pages:
Alfasoft offer first line support to our JetBrains customers
Please click here for first line support! (Link to alfasoft.com support form)
Please explain your problem in detail when contacting us. Please remember to enter your version number, and which operating system you are running.
Updates in Rider 2017.3
- Debugging third-party code - Version 2017.3 makes debugging external code an automatic, pain-free process. You can now step through and set breakpoints in assemblies that Rider decompiles on-the-fly.
- Smart Step Into - This action helps you choose a particular call to step into, while stepping over all other calls in a line.
- Return values in locals - Rider now displays function return values in the Variables view (a.k.a "locals") of the Debug tool window as you step through your code.
- More debugger improvements
- You can now drag-and-drop the execution pointer to an earlier or later location in code, letting you retry or skip certain logic without having to restart the application.
- Callers of async functions are now displayed in the Frames view, restoring the async causality chain.
- Debugger actions like Force Run To Cursor and Set Next Statement are now available via Alt+Enter during debugging sessions.
- Code completion items in Variables and Watches views get a refreshed presentation.
- Lambda expressions and extension methods are now supported when you debug Mono-based applications such as Xamarin or Unity.
- Values of numeric types - decimal, float, double - are now evaluated and presented as expected.
- New project wizard
- Project templates are now grouped by framework, with languages, flavors and target framework versions selectable in properties of each framework template.
- Git or Mercurial repositories can be created along with new solutions.
- You can search the wizard for a particular type of application or programming language.
- More project templates are available by default, such as WPF Application and Unity Class Library.
- Additional project templates based on dotnet new can be easily installed.
- Unit testing improvements
- Two new actions are available: Repeat Tests Until Failure and Rerun Failed Tests In Current Session.
- All actions now respect the currently selected filter (such as Failed tests only). Filters themselves are now presented in a more compact manner: if a test status doesn't occur in the current test session, the filter for that status is not displayed.
- Local shortcuts for unit test trees are introduced: for example, Del removes selected tests from a session, and Alt+Shift+Insert creates a new session.
- When you search for tests in the unit test tree, you can now find results in collapsed nodes.
- C# Interactive - New C# Interactive tool window helps you run C# statements without having to wait for compilation. This is a quick REPL-based way to draft code and get immediate feedback on what a given expression will return.
- Unity support improvements
- New context actions to annotate fields as serializable or not serializable, as well as to convert auto-properties to properties with serialized backing fields.
- New code inspections around Unity attributes, such as signature checks in methods marked with [PostProcessScene] and other Unity attributes.
- Code completion starts to show Unity event functions at the top of the list, and works again before attributed fields.
- Syntax highlighting and coding assistance are available in compute shaders in addition to regular shaders.
- Unity debugger learns to break on user-unhandled exceptions, evaluate locals in coroutines and tasks, and reliably hit breakpoints when attached to local Unity processes. pdb2mdb is now integrated to enable the Mono debugger to handle assemblies that come with Windows-specific PDB files.
- Quick Documentation pop-up provides links to external documentation for Unity symbols.
- Web.config and App.config transforms
- It learns to execute Web.config and App.config transformations that are commonly used to modify settings when packaging applications.
- Reworked formatter - It learns to align code in columns and apply other new code styles. It also gets a way to disable or enable formatting for selected blocks of code with comments, or for entire files with EditorConfig.
- More changes from ReSharper
- Reworked Extract Method refactoring that supports returning tuples instead of out parameters when you're using C# 7.
- New C# typing assists to add multiline comments, indent methods in chains, and surround code selections.
- Support for tuples and documentation inheritance via <inheritdoc/> in VB.NET.
- More frontend development features
- It continues to expand the set of WebStorm functionality that it provides out of the box. This release bundles a set of plugins for frontend developers that were formerly only available on demand, and weren't easily discoverable. This set of plugins includes support for TSLint, CoffeeScript, LiveEdit, Polymer and web components, Pug (ex. Jade), Handlebars, Karma, Stylus, AngularJS, spy-js, Gherkin, and Cucumber. (In related news, Vagrant plugin is now also available by default.)
- Improved detection of package.json files in projects, which lets Rider suggest installing or updating npm packages in more cases.
- MSBuild and NuGet
- Rider's NuGet tooling learns to handle fallback folders, restore packages based on PackageReference directives in .csproj files, and ignore disabled NuGet package sources.
- It now provides UI to edit .NET Core project properties, and applies additional heuristics when dealing with linked files: it lets you choose between copying, moving files and adding links to them when you add an existing item, and suggests to exclude linked files from a project instead of deleting them from file system.
- Enabled IntelliSense in .NET Core project files.
- IntelliJ platform changes
- Editor-based REST client based on scratch files with the .http extension. (The UI-based version of the REST client continues to be available, and even gets a few cosmetic updates.)
- Version control updates including interactive rebase from Git log, preserving workspaces when switching between branches, and improved handling of Git and Mercurial merge commits.
- Database updates: grouping data sources, XQuery/XPath coding assistance in .sql files via language injections, and more.
- Docker support updates, most importantly revised Docker run configurations.
- You can now reliably export and import Rider settings via Import Settings, Export Settings and Manage Layers dialogs.
- C# code style settings were extended with a Null Checking tab that helps choose a default null checking style in code that it generates for you.
- Inspection severity configuration is now separated into per-language pages.
- A new page with JetBrains Annotations settings was added under Inspection Settings.
- Other changes
- Find Usages learns to work asynchronously to show available results while a search is still running, and offers a new grouping by usage type.
- We have introduced a new Xcode keymap for long-time Mac users.
- Designer files are now automatically regenerated on saving the associated .resx files.
- Context menu on Solution Explorer nodes has been restructured for a clearer, more compact presentation of actions.
- JetBrains annotations were ported to .NET Core, which makes entire categories of code inspections (nullability, LINQ, purity inspections) work more reliably.
- Performance improvements
- Loading and reloading projects: thanks to a new asynchronous handling of MSBuild tasks, the synchronization stage of loading projects is now up to 5 times faster on large solutions that we used for testing.
- Code completion performs faster on huge solutions.
- In terms of debugging, the debugger launch time in some scenarios has been optimized, as well as rendering of large call stacks.
TRAINING & EVENTS
Currently Alfasoft does not offer JetBrains trainings.
For a first insight about Rider please watch following video: