Niranjan Singh's coding blog

I ran into problem that when I try to find extensions in the VS Code, it does not display anything and even not able to check for updates. In this scenario, I have downloaded newer version of VS Code but it was not the permanent solution to solve this problem.

In such type of issues, I found that our enterprise proxy block the request which sent to the respective software vendors. Finally I decided to get to know that how can I setup proxy settings in VS Code as I did with tortoiseSVN and other tools.

I found reference in VS Code documentation - Proxy server support

Many enterprises require that their computers run behind a proxy server and don't allow direct access to the Internet. A proxy server intermediary can limit access to the VS Code Extension Marketplace and prevent installing VS Code extensions.

Follow the below steps to setup proxy settings:

1. File > Preferences > Settings
   
2. Navigate to the HTTP settings section and you will find settings for proxy as shown in below image:
   
3. Now change the proxy settings as per your environment, If you proxy does not require authentication then just simply enter proxy details:

   "http.proxy": http://172.28.57.20:8080/

   If proxy require authentication then you have to provide user details:
   

   "http.proxy": "http://niranjan:password@172.28.57.20:8080/"

Complete Settings which works in my case:

// VSCode: Place your settings in this file to overwrite the default settings
{
  "http.proxy": "http://user:pass@proxy.com:8080",
  "https.proxy": "http://user:pass@proxy.com:8080",
  "http.proxyStrictSSL": false
}

From documentation:
Additionally, use "http.proxyStrictSSL": false if your proxy server uses a self-signed certificate.
Note: VS Code supports http and https proxies, but not SOCKS proxies.

What is .NET Core?

.NET Core is a development platform maintained by Microsoft and the .NET community on GitHub. It is cross-platform, which supports Windows, macOS and Linux and it can be used in device, cloud, and embedded/IoT scenarios.

What is Docker?

Docker is an open platform for developers and sysadmins to build, ship, and run distributed applications. It leverage the speed in developing, packaging and running portable distributed applications.

Docker for Windows is a Docker Community Edition (CE) app.

Note: It requires Microsoft Hyper-V to run and the current version of Docker for Windows runs on 64bit Windows 10 Pro, Enterprise and Education (1511 November update, Build 10586 or later).

Hardware Virtualization must be enabled. It is prerequisites for Hyper-V and also for Docker also.. You can check it in the Task Manager’s performance tab for CPU.

Now we start installing Docker on Windows 10 Pro.

First enable Hyper-V and here are the steps:

1. Press Windows + R and run appwiz.cpl to open “Programs and Features” section of Control Panel.
   
2. Now click on “Turn Windows features on or off”.
   
   
3. Check Hyper-V in Windows Features section to enable it.
   
   

I found an interesting and easy to understand moving image(gif) to know that how to enable Hyper-V form control panel.

Installing Docker application

1. First download Docker InstallDocker.msi installer from here and then double-clickInstallDocker.msi to run the installer.
2. Follow the install wizard to accept the license, authorize the installer, and proceed with the install.
   
3. Follow the install wizard to accept the license,and click Next.
   
4. Click Finish on the setup complete dialog to launch Docker.
   
5. When Docker start without error then you will see Docker icon in the taskbar.
   

and Linux virtual machine in the Hyper-V so we need to switch to Windows containers. It may restart your computer as did with me.

Now time to come for creating the first “Hello World” program on Docker and run it. To work with Docker, we have start “Power Shell” to run the CLI command to create the program.

1. First run the following command to get a container with the dotnet core tools.

   docker run -it microsoft/dotnet:latest
   

2. Now create “Hello World” console application:

   dotnet new console -o hwapp
   

3. It will create a directory with name ‘hwapp’. Go into that directory using ‘cd hwapp’ and run the restore command.

   dotnet restore
   

 

You can develop your applications by using any supported language by Docker, like Node.js, Java, Go, etc., Right now Microsoft tram working to make better support for .NET Core and .NET Framework in Docker environments. You can try the official  .NET and ASP.NET Core images available at Docker Hub as I have used one of them in above exercise to run the program on the Docker container.

It is quite interesting that these containers are help full to create different type application and host them to make auto build as read so far about them.

DevExpress introduces new ASP.NET Bootstrap controls in v17.1

DevExpress controls suite now include Bootstrap enabled ASP.NET controls in upcoming release. So far I found these controls well incorporated with Bootstrap framework.

These new  ASP.NET Bootstrap controls are compatible with the Bootstrap version 3.3.7. These provides out-of-the-box Bootstrap framework. Right now all not all DevExpress ASP.NET controls found in DevExpress Bootstrap controls. In DevExpress 17.1 Beta Demo Bootstrap controls are totally a separate category of controls.

DevExpress ASP.NET Bootstrap controls are new line of controls which somewhat gives us similar versions of DevExpress ASP.NET features There controls contains 4 type of controls as a subset of the DevExpress ASP.NET controls:

And Visual Studio toolbox also showing them in separate category of controls:

Let  check the DevExpress Bootstrap Controls:
Most of the added controls are similar to the standard DevExpress ASP.NET controls because they are derived from them. Editor controls has almost all of these properties and the client side events.

These bootstrap enabled controls has new properties section which specifies the bootstrap related properties. In case of button we use SettingsBootstrap.RenderOption  to specifies the button style as shown in the above image.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="DevExBootstrapControls.Default" %>

<%@ Register Assembly="DevExpress.Web.Bootstrap.v17.1, Version=17.1.2.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a" Namespace="DevExpress.Web.Bootstrap" TagPrefix="dx" %>

<%@ Register Assembly="DevExpress.Web.v17.1, Version=17.1.2.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a" Namespace="DevExpress.Web" TagPrefix="dx" %>

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
    <!-- Latest compiled and minified CSS -->
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">

    <!-- Optional theme -->
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap-theme.min.css" integrity="sha384-rHyoN1iRsVXV4nD0JutlnGaslCJuC7uwjduW9SVrLvRYooPp2bWYgmgJQIXwl/Sp" crossorigin="anonymous">

    <!-- Latest compiled and minified JavaScript -->
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <dx:BootstrapTextBox ID="btnMessage" ClientInstanceName="message" runat="server" Text="Hello, Bootstrap TextBox"></dx:BootstrapTextBox>
            <dx:BootstrapButton ID="btnShowTextMessage" runat="server" AutoPostBack="False" Text="Button">
                <ClientSideEvents Click="function(s, e) {
    alert(message.GetText());
}" />
                <SettingsBootstrap RenderOption="Success" />
            </dx:BootstrapButton>
            <br />
            <br />
            -- Grid --
            <br />
            <dx:BootstrapGridView ID="BootstrapGridView1" runat="server" AutoGenerateColumns="False" DataSourceID="SqlDataSource1" KeyFieldName="AddressID">
                <Columns>
                    <dx:BootstrapGridViewTextColumn FieldName="AddressID" ReadOnly="True" VisibleIndex="0">
                    </dx:BootstrapGridViewTextColumn>
                    <dx:BootstrapGridViewTextColumn FieldName="AddressLine1" VisibleIndex="1">
                    </dx:BootstrapGridViewTextColumn>
                    <dx:BootstrapGridViewTextColumn FieldName="AddressLine2" VisibleIndex="2">
                    </dx:BootstrapGridViewTextColumn>
                    <dx:BootstrapGridViewTextColumn FieldName="City" VisibleIndex="3">
                    </dx:BootstrapGridViewTextColumn>
                    <dx:BootstrapGridViewTextColumn FieldName="StateProvinceID" VisibleIndex="4">
                    </dx:BootstrapGridViewTextColumn>
                    <dx:BootstrapGridViewTextColumn FieldName="PostalCode" VisibleIndex="5">
                    </dx:BootstrapGridViewTextColumn>
                    <dx:BootstrapGridViewTextColumn FieldName="rowguid" VisibleIndex="6">
                    </dx:BootstrapGridViewTextColumn>
                    <dx:BootstrapGridViewDateColumn FieldName="ModifiedDate" VisibleIndex="7">
                    </dx:BootstrapGridViewDateColumn>
                </Columns>
                <CssClasses Table="grid-table-with-template" />
            </dx:BootstrapGridView>
            <asp:SqlDataSource ID="SqlDataSource1" runat="server" ConnectionString="<%$ ConnectionStrings:AdventureWorksConnectionString %>" ProviderName="<%$ ConnectionStrings:AdventureWorksConnectionString.ProviderName %>" SelectCommand="SELECT top 20 * FROM [Person_Address]"></asp:SqlDataSource>
        </div>
    </form>
</body>
</html>

and below is the output of these added controls on the page:

Conclusion: DevExpress Bootstrap controls idea is quite good and really decrease the development time rather using the flat table for rendering data and other operations using the editor controls. DevExpress native web form controls rich with the features so these Bootstrap enabled control really make intuitive user interface.

Technical debt is a concept in programming that reflects the extra development work that arises when code that is easy to implement in the short run is used instead of applying the best overall solution at once after few release of the application.  

It includes those internal things that you choose not to do now, but which will impede future development if left undone. especially in the context of refactoring.

In 1992, at the OOPSLA conference Ward Cunningham describes this concept as follows:

"Shipping first-time code is like going into debt. A little debt speeds development so long as it is paid back promptly with a rewrite. Objects make the cost of this transaction tolerable. The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt. Entire engineering organizations can be brought to a stand-still under the debt load of an unconsolidated implementation, object-oriented or otherwise."

Technical Dept increase with every release if residual issues left over from the last released are addressed. In Agile method, each sprint take care about the standard process to make a quality product but code refactoring and other stuff are not controlled at the right time then futures releases cost more in refactoring rather than doing at particular release using shortcuts. It is reduced by measuring Debt at every release to reduce to cost of the continuous development.

NDepend provide Continuous Code Quality using Smart Technical Debt Estimation. It enables you to estimate the cost to fix and the severity through customizable C# formulas for each issues persist at each sprint or release of the software.

In newer version NDepend v2017.1.0, NDepend estimates the technical-debt of a code base.

The technical-debt is estimated from C# LINQ formulas embedded inside each rule source code. This makes the the estimations both smart and easily customizable to your needs. In the below screen you will see the queries written for the predefined rules provided with the NDepend.

There are rules which can be added and modified as per the requirement. Debt estimation parameters are also customizable through NDepend Project Properties panel. See below images:

As per my opinion this feature is quite worth of use to improve the quality of the product for future cost reduction and it is quite easy to understand the serious Code Quality control in the development process through NDepend. It makes the managers to control the return on investment made on quality.

Hope NDepend benefits others to reduce the Technical Debts for their products..

What are the quality gates
Quality gates are basically acceptance criteria reviews that can be used throughout any project. Sure, managers of smaller, agile projects might say that this involves too much paperwork, but the nice thing about quality gates is that the strategy is fully customizable. It can be seen as a set of predefined quality criteria that a software development project must meet in order to proceed from one stage of its lifecycle to the next.

These are special milestone in a software project which are located before a phase that is strongly dependent on the outcome of a previous phase. They are especially useful between phases in which breaches in disciplines must be overcome.

How quality gates work:

You are not allowed to proceed the next gate until the previous gate has been completed successfully. It involves a checklist of deliverables, with some indication of the state of completion for each item. Checklist must be reviewed by the project manager (Manager) and a senior executive or stack-holders who is involved with the project. Quality gates therefore mean:

• Formal checklists are used throughout the life of a project.
• Formal sign-off and acceptance occurs at each gate.
• Assessment of the quality and integrity of the product takes place.
• Information is assured to be communicated to the correct stakeholders

Advantages of the Quality gates:
These are effective on any kind of project. There attractive because of the following advantages which includes:

• Minimizes project failure risks through phase-by-phase checklists (or Gates)
• Enables project managers to continuously communicate the process and build quality directly into the project
• Reduces development cycle time—getting it done right the first time
• Increases focus on a well-designed product

Now NDepend is equipped with this in v2017.1 and you will find default quality gates relative to technical debt and issues and issues, including Percentage of Debt, New Debt since Baseline or New Blocker / Critical / Major Issues. Quality gates relative to absolute technical debt value are disabled by default because the proper thresholds can only be defined in the context of a particular project.

Results of the applied rules are shown in the updated dashboard. This is quite new feature in NDepend for project management improvement.

You will find ratings and the status of passed rules.

HTML report has more details in a tabular format about the applied rules:

Then again the feature that I most like in NDepend is CQLinq which enables you to customize or add rules. CQLinq is much fast to run these rules and now much improved in case of performance.

There is a nice documentation is also available to know that how to Compute and Manage the Technical Debt with NDepend.

After my first article “Analyzing the Quality of your code with NDepend” on NDepend, I found few new interesting feature in it’s new release. Microsoft has introduced new version of the Visual Studio which my first choice for development. New Roslyn platform heading us to the Open source development using the Microsoft tools that making things easier to learn and get knowledge about the new tools. But we are going to explorer new features of the NDepend. Few of them are as below:
Support for Visual Studio 2017

• NDepend 2017.1 supports Visual Studio 2017.
• NDepend 2017.1. It also supports Visual Studio 2015, 2013, 2012 and 2010.
  
  

.NET Core support

• NDepend can now analyze any .NET Core assembly and its associated PDB and source files.
• The new .NET Core Portable PDB file format is now also supported.
• Support for inferring code to analyze from a project.json file, which about to completely come in the first quarter of this year. All .NET Core assemblies you need to analyze can be easily found through Analyze .NET assemblies in directory (recursive).

Dashboard Improvements

• Dashboards have been improved in the NDepend UI in Visual Studio, in the generated reports section and in the Team Services web portal.
• It now contains technical debt estimations, quality gates, rules and issues data.
• For each data, a visual indicator shows the progression since baseline. Red and green coloured values are used to pinpoint progress or regression.
• Clicking any value generates a query that drills down through corresponding data, which can be a list of code elements, debt estimations, quality gates, rules or issues.
  
  

Visual Studio Team Services VSTS and TFS 2017 Advanced Extension
A new Visual Studio Team Services extension is available. It consists of a build task that analyses code and code coverage yielded by the build process.
A web portal presents the results which embeds the NDepend dashboard and makes data actionable by drilling down anything with a single click.

A new Visual Studio Team Services extension is available. It consists of a build task that analyses code and code coverage yield by the build process. A web portal presents analysis results.

• The web portal has a dashboard that presents the most relevant data including technical debt, code size, quality gates, rules and issues numbers.
• A TFS build can be used as a baseline. All dashboard data is then diff-ed since the baseline.
• Each data presented in the dashboard is clickable to view more information.
  
• A detailed summary of quality gates is available.
  
• Technical debt can be drilled down till the issue level. Clicking an issue allows it to be edited in the Rules panel.
  The datagrid is interactive: issues can be grouped, ordered and filtered by rule name.
  
• Rules details can be explored. Clicking a rule violation redirects the user to the VSTS Code Search extension, displaying the source code of the culprit code element.
  
• The VSTS extension logs trend metrics for each build, and Trend charts are shown.
  
• A panel shows a code metrics recap for each code element. The datagrid is interactive: elements can be grouped, ordered and filtered by name.
  

Report Improvements

• The new improved report dashboard now contains information on debt and issues.
  
• The report main section contains Quality Gates status summary.
  
• The report Rules Summary now shows the number of issues added and fixed per rule.
  
• A green/red colour scale is now shown on code coverage values.
  

Code Querying Improvements

• Thanks to the new queryable domains QualityGates, Issues, IssuesInBaseline, Rules queries can be written to match IQualityGate, IIssue, IRule objects according to any criteria (rule violated or not, quality gate status that went from pass to fail, issues added since baseline, issues severity or debt...).
  
• New syntax to write quality gates.
• A new button lets you run the currently edited code query against the baseline.
  
• A code query can now return code elements of various kinds such as assemblies, namespaces, types, methods and fields.
  This new queryable domains are available including CodeElements ANTMF ; CodeElementParents ANT ; TypesAndMembers TMF ; Members MF ; CodeContainersANTM ; AttributeTargets ATMF ; where Assemblies, Namespaces, Types, Methods, Fields.
• A query can now return values of technical debt through new types Debt, AnnualInterest, DebtRating, Severity, TrendIcon and can also return System.Version and System.TimeSpan values.
  
• A colour scale is now shown on query result metric values making it easier to compare them at a glance.
• You can now write very simple queries like Methods or JustMyCode.CodeElements or codebase.PercentageCoverage. This syntax simplifies writing quality gates and trend metrics queries.
• Trend metrics used to only be defined with queries that return a scalar. A trend metric can now also be defined with a query that returns rows. In such situation the trend metric value is equals to the row count.
• Improved query edit experience including:
  - PageUp/PageDown and dot supported on completion items list
  - smart query results column width auto-adjustment
  - no more flickering on query result row sorting.

Smart Technical Debt Estimation

NDepend v2017 is the only VS extension that can tell the developer that, for example, since this morning the code just written has introduced debt that would cost about 30 minutes should it have to be repaid later.
Knowing this, the developer can fix the code before even committing it to the source control.

• An NDepend rule can now assign a technical debt and annual interest values to its issues.
• The technical-debt is the estimated man-time that would take to fix the issue.
• The annual-interest is the estimated man-time consumed per year if the issue is left unfixed. This provides an estimate of the business impact of the issue.
• Issues of a rule now have a severity level in the blocker, critical, major, minor, info range.
  The annual-interest is a measure of an issues severity. The severity and the annual-interest represent the same concept where the annual-interest is a continuous measure while the severity is a discrete measure.
• For example the rule below matches methods which are too complex. The technical debt is linear to the methods excessive complexity and the annual-interest is linear to the methods code coverage by tests (10 minutes per year for 100% coverage, 2 hours per year for 0% coverage).
  All default rules now have these debt/interest formulas which offer real-world estimations, out of the box. If needed, these formulas can be easily customized.
  
• The dashboard now shows estimated Debt values and evolution since baseline.
  This dashboard is available in the NDepend UI in Visual Studio, in generated reports and in the Team Services web portal.
  
• Many facilities are proposed from the dashboard to query/sort/filter/group... the debt estimated values and the issues set.
  These facilities include sorting debt and issues per rule or per code element, focusing on new and fixed debt since baseline and issues to fix by priority heuristics.
  Customizable Quality Gates are now available to define excessive thresholds over debt estimations that might induce build failure and prevent check-in.
  Customizable trend metrics are now available to measure debt trending. The key is to offer comprehensive sets of actionable results.
  
• The NDepend project properties now has a Debt and Issues panel to customize all technical debt computation aspects.
  This includes estimated Debt and Interest values conversion from man-time to cost estimation.
  This also includes Debt Ratio and SQALE Debt Rating on a code element (as defined by the SQALE method). These are expressed in percentage of the estimated technical-debt compared to the estimated effort it would take to rewrite the code element from scratch.
  Debt settings can also be shared among different NDepend projects.
  
• More info on Smart Technical Debt Estimation here

Quality Gates

A Quality Gate is a check on a code quality fact that must be enforced before releasing and eventually, before committing to source control.
Quality Gates for example can forbid issues with a certain severity introduced since the baseline, enforce particular code coverage by tests ratio on new and refactored code or enforce thresholds on any Technical Debt criteria.

• CQLinq can now be used to write quality gates. Technically a quality gate is like a trend metric. It's a code query that returns a scalar or rows (in which case the value is the row count). In practice a quality gate is used to fail a build when some thresholds are violated. A warn threshold, a fail threshold and a unit can be provided.
• Thanks to the new CQLinq capabilities, quality gates can be use to measure and monitor any fact concerning code, but also any fact concerning technical-debt, rules and issues.
• Quality gates can also rely on differences since baseline (diff), which means that they can monitor progression like new technical debt since baseline or % code coverage on new code written since baseline.
  
• 11 quality gates are provided per default and LINQ queries can be written to query the quality gates status.
  
• In previous NDepend versions, a build used to fail upon critical rules failures. Now the build fails upon any quality gate failure. The critical rule concept has been kept and the default quality gate Critical Rules Violated mimics the build fail behavior of previous NDepend versions.

Issues Management

• A new Issues menu offers actionable options to list issues to be fixed by priority, and browse debt and issues per rule or per code element.
  
• Quality gates, rules and issues numbers are shown from the dashboard. All these numbers are clickable to get lists of quality gates, rules or issues.
  
• A single click allows to list issues with a particular severity, added or fixed, since baseline.
  
• New menu to list issues concerning a code element.
  
• Hovering an issue with the mouse displays a complete description.
  
• Code element tooltip now shows debt and issues related data.
  

Enhanced Baseline Experience

Do you want to measure progress since this morning, last week or since the last release?
Choose the baseline in a single click from the Dashboard and harness the updated results in just a few seconds.

• Any stored baseline can be applied from the dashboard through a single click.
  Code base diff, rules, issues and quality gates are then recomputed in a few seconds.
• Any newly created project now has the baseline settings set to 30 days ago per default.
  As a consequence, the stored baseline with the date closest to 30 days ago is applied.
  The first analysis result of a project is compared with itself since no other result can be used as the baseline.
• Rules and Quality Gates are now executed against both current and baseline analysis results. Debt estimation, issues and status differences can then be queried.
  
• The search panel can now match all code elements added, refactored or removed since baseline.
  The results also show debt and issues information.
  This perspective is ideal to browse changes and issues introduced since baseline.
  

Default Rules-Set Improvements

• All default rules now include debt/interest estimation formulas that offer real-world estimations of the technical-debt, out of the box. If needed, these formulas can be easily customized.
  Typically rules related to poor coverage, poor quality and poor structure are the highest source of technical-debt.
• The new CQLinq capabilities 52 existing rules have been improved to offer less false positives and more relevant data.
• For example the rule Avoid namespaces mutually dependent has been improved to offer actionable results. It now lists all dependencies to remove at type and method level to reach a clean layered code structure.
  
• New rule Assemblies should have the same version lists application assemblies that have a different version than most other application assemblies.
• New rule Avoid non-readonly static fields.
• New notmycode query Discard generated Namespaces from JustMyCode matches the VB.NET generated namespace My.
• The notmycode query Discard generated Types from JustMyCode now also matches anonymous types.

Enhanced Visual Studio Integration

• NDepend analysis can be started after a build to automatically refresh NDepend results. New settings are provided to avoid starting the NDepend analysis when the builds purpose is to provide up-to-date compiled bits for a run session, a debug session or a unit-test session. In such a situation, it might be preferable to avoid starting the NDepend analysis to avoid both consuming CPU cycles and distracting the developer's focus.
• Minimal interval between NDepend results being refreshed automatically after a build in VS which can now also be expressed in minutes.

NDepend.API Improvements

• Possibility to compute an issues-set and an issues-set-diff through a single method call thanks to the new methods ComputeIssues() and ComputeIssuesDiff() declared in ExtensionMethodsProjectAnalysis.
• Possibility to compile a code query once and resolve it against multiple code bases. This facility represents a significant optimization when multiple resolutions are needed, because query compilation is way slower than query resolving.
  Related method ExtensionMethodsQuery.CompileNoResolve() which returns a IQueryCompiledUnresolved that presents two Resolve() methods, against a ICodeBase and an ICompareContext.
• The new method ExtensionMethodsQuery.GenerateCompletionItems() provides completion items in code query edition context.
• The new method ExtensionMethodsQuery.CompileMany(IEnumerable<IQuery>) takes an enumerable of IQuery and returns a dictionary of IQueryCompiled indexed by IQuery.

Conclusion
NDepend is again loaded with more improvements and features from it’s last version. NDepend team introduced above valuable feature and enhancements.
Note: Information and Images are taken from NDepend documentation.

CodeRush helps the developers to write, refactor, navigate and debug C# and VB source code faster and more efficiently. Along this CodeRush includes the world's fastest .NET test runner which helps developers to complete software development tasks with less effort (both physical and cognitive), and in less time.

What makes this CR for Roslyn better than Classic version?

This newer version of CodeRush for Roslyn uses significantly less memory, works faster, and lets the Visual Studio to start faster the CodeRush Classic. It leverages Visual Studio's solution-parsing data and automatically supports new C# and VB language features as they become available in Visual Studio.

Features provided by CR for Roslyn:

1. Visualize Code and Intuitively Debug
2. Move at Warp Speed
   It helps to find symbols and files quickly in your solution and easily navigate to code constructions related to the current context. CodeRush includes the Quick Navigation and Quick File Navigation features, which make it fast and easy to find symbols and open files.

   Navigation features are available via the Navigation menu, which can be invoked using the Ctrl+Alt+N shortcut.

3. Validate Quality Faster
   CodeRush lets you create new test cases or new test suites in a single keystroke. CodeRush for Roslyn automatically detects unit tests for NUnit, xUnit, MSpec and MSTest frameworks, and can optionally run tests located across multiple assemblies concurrently. The Test Runner also runs CoreCLR test cases in the DNX environment. The Sessions support makes it very easy to organize tests and run only those that are required.
4. Code Refactoring
5. Code Analysis
6. Code Formatting and Cleanup
7. many more…

Complete feature comparison matrix between CodeRush editions is available at Download Classic or Roslyn Version.

Microsoft’s has started new way of development in Open Source world with the  paradigm “Compiler as a service”. Now Microsoft has lots of open source projects including the .NET Compiler Platform (“Roslyn”).NET Compiler Platform (“Roslyn”). The .NET Compiler Platform ("Roslyn") provides open-source C# and Visual Basic compilers with rich code analysis APIs. You can build code analysis tools with the same APIs that Microsoft is using to implement Visual Studio!. According to these dramatic changes in the development on the Microsoft platform lots of tools are adopting ways to move along these. After a while again I got chance to install CodeRush in Visual Studio IDE and I there are two different flavours of CodeRush. This makes me little confuse that which one should i install to work with.

After checking through documentation and ready some blog posts related to my question I got that When to use this newer version of CodeRush for Roslyn or CodeRush Classic. Actually CodeRush Classic work with the prior version of .NET Framework 4.6. With this newer version of .NET framework which is shipped with the Microsoft’s open source projects which based on the Rosyln compiler platform. Below are points which help you to decide that which version suits to your development environment:

1. If you are using Visual Studio  2015 and .NET framework 4.6 (above) then CodeRush classic does work for you. In this case you should install CodeRush for Roslyn. This does not has all the feature of the CodeRush Classic but newer version will defiantly improve this open source stack.
2. If you are working with older version of .NET Framework then you’ll need CodeRush Classic. If you need both, you can install both versions simultaneously and defiantly i try this too.
3. CodeRush Classic supports C# 5.0, VB10, ASP.NET, HTML, JavaScript, XML, and XAML. In this case, for the newer version of language CodeRush for Roslyn is the only option and may be in near future Classic version of CodeRush go obsolete.

Learning and source of information:
CodeRush
.NET Developer Tooling: The Roslyn Revolution
CodeRush on Roslyn

Peoples who are habitual of using intellisense in Visual Studio and suddenly it is found missing then they really get mad during the work. Today I am trying to create some html pages with bootstrap for learning. I was feeling little hard to do code with bootstrap, because I am not able remember all of the class names of the bootstrap.

There are lots of glyphicon classes which is hard to remember. Visual Studio has this nice feature by adding JavaScript library path to the “_references.js” file and after that everything available in autosuggest mode.

What happened with me, I am not able to find the correct gylphicon class name without intellisense. Regarding this I have googled and found that this feature is not currently available in VS Code right now. However, it has been added as a feature request for upcoming updates.

Do not disappoint, There is also hope to do work with intellisense in VSCode. You can use extension"HTML CSS Class Completion".

Open Command Palette by press ctrl+ship+p Then run  “ext install HTML CSS Class Completion” to install this extension. Check the results in below image to see after enabling this extension.

Happy coding!

Scenario:

I had a requirement for preventing user to edit the “Composite Shape” elements (e.g. Text Primitives, Ports etc.). This restriction is required during the development for most of the cases because programs are using these shapes for some special purpose representation and these should not be altered by the use at run time to keep them consistent.

If user change these shapes then it will be hard to know that it has been modified this diagram is saved as XML string in some data store. If shape elements are used to identify the shape elements by name then it will break the program for being consistent for these shapes. See the below image, If the edited port name is used in program to  identity the center port then it will be distinguish the center  port in all of these ports.

Finally, it is required to remove some commands from the context menu of the shape in the diagram view for the user so that user will not able to modify the shape elements.

Solution:

At first place, you need to use the “Protection” on the shape to prevent some operation. You can restrict few operation on the shape for the user.

These can be set programmatically, these are just for making restrictions on the shape not for the context menu operations. See below code example:

NAbilities shapeAbilities = new NAbilities();
shapeAbilities.All = false;
shapeAbilities.InplaceEdit = true;
shapeAbilities.ResizeX = true;
shapeAbilities.ResizeY = true;
shapeAbilities.Export = false;
NShape shape = (NShape)nDrawingDocument1.ActiveLayer.Children(null)[0];
shape.Protection = shapeAbilities;

Real Solution
The simplest solution is that create a custom context menu builder for creating context menu for the current diagram view.  This will create/add the required command that you want to provide to the user while working in the diagram.

First create a Custom ContextMenuBuilder by inheriting “NDiagramContextMenuBuilder” class and override “BuildContextMenu” method. There you need to create the context menu and add the required commands to the created context menu.

internal class CustomContextMenuBuilder : NDiagramContextMenuBuilder
{
    public override NContextMenu BuildContextMenu(object obj)
    {
        NContextMenu contextMenu = new NContextMenu();
        contextMenu.Commands.Add(CreateCommand((int)DiagramCommand.Delete, false));

        return contextMenu;
    }
}

After that create an instance of this custom context menu builder and assign it to the ContextMenuBuilder property of your diagram command bars manager:

nDiagramCommandBarsManager1.ContextMenuBuilder = new CustomContextMenuBuilder();