Visual Studio IntelliCode is a tool helping in code development and analysis of code using Artificial intelligence.

This tool provides contextual recommendations for code completion as you type your code.

As per Microsoft, these contextual recommendations are provided based on best practices that are developed using AI by verifying thousands of high-quality, open-source projects on GitHub plus these tools also help to analyze your codebase and train itself to provide a project-specific recommendation.

This tool is currently available through Visual Studio Marketplace as an extension. This is one of the good to have an extension on the developer’s machine.

Today in this article, we will cover below aspects,

Main Features

• Improve developer productivity using AI.
• Help following the code and style patterns. Patterns get created from your code base itself.
• All suggestions are provided using the existing code context.
• Code review support by highlighting the code changes which require more attention.
• AI-assisted IntelliSense context-aware code completions, signature tool-tips, and help instead of traditional IntelliSense support.

Language Support

• Visual Studio: C#, C++, and XAML
• Visual Studio Code: Java, JavaScript, Python, and TypeScript

Getting Started

Prerequisites :

• Latest version of VS2017 (15.8 and above)
• Latest version of VSCode(1.29.1 and above)

Steps for configuring Visual Studio IntelliCode

• Install Intellicode from Marketplace or from VS Extension as below,

Marketplace: https://visualstudio.microsoft.com/services/intellicode/

VS Tools extension:

• The first-time installation requires you to restart Visual Studio 2017 to process installation.

• After successful installation lets open your project solution.Got to View->Other Windows->Intellicode

• Click on Train my code

• After training of model completes status will be updated as complete.

Lets see the result of code recommendation before Intellicode and after Intellicode as shown below,

As shown above, your IntelliSense support now uses more common sense using AI model and provide you specific code completion recommendation.

If you are interested to see generated model on your desktop Open file location %TEMP%\Visual Studio IntelliCode

The above folder contains the model (not the code) data that is sent to Microsoft over HTTPS.

Useful References

• Paired Programming and Collaboration – Visual Studio Live Share

That’s all! Happy coding!

Does this help you fix your issue?

Do you have any better solutions or suggestions? Please sound off your comments below.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post How to use Visual Studio IntelliCode – Code Development using AI first appeared on TheCodeBuzz.

Today in this article, we will cover Primitive Obsession Code Smell Resolution with an example.

We will cover below aspects,

“Code is read more often than it is written”

“Code is maintained more often than it is written”

A few examples of C# primitives are as below,

• int
• bool
• short
• double
• char
• float etc.

We understand that classes are just dumb templates until they are defined with proper behavior.

The behavior of a class is defined by its properties, fields, and functions.

What we need to understand here is when these primitives are less in number and less in behavioral characteristics, they are manageable.

But the real problem (which we call ‘Code Smell’) starts growing when these primitives grow in number along with their behavioral characteristics.

It gets worse when developers define the same primitives at different places with code duplication without realizing it and code smell gets spread everywhere.

So below are a few characteristics of Primitive obsession,

• Use of Primitives (excessive)

• Use of Constants or String constants for field names

• Use Numeric type code for conditional OR validation statements

Getting started

Let’s take an example and understand this,

public class Employee
    {
        public Employee(string firstName)
        {
            FirstName = firstName;
        }
        public string FirstName { get; set; }
    }

As shown in the above example, Class Employee with a single property of type string is defined, very easy indeed ! and all is well.

Now for the next future enhancement, this class grows as below,

public class Employee
    {
        public Employee(string firstName, string lastName, int iD,string contactCellNo,string ssn)
        {
            FirstName = firstName;
            LastName = lastName;
            ID = iD;
            PhoneNumber = contactCellNo;
            SSN = ssn;

        }

        public string FirstName { get; set; }
        public string LastName { get; set; }
        public int ID { get; set; }
        public string PhoneNumber { get; set; }
        public string SSN{ get; set; }
  }

Is SSN or Phone Number in the above example just a string?

Requirement 1 – The phone number here is currently defined as a string. Let’s say you would like to extract the area code (here ex. 123) then you might need to add extraction logic.

Requirement 2- Additionally, let’s say you have business requirements for extracting the last four digits of your SSN from a given social security number.

You’ll have to write additional logic to extract the last four digits of SSN. Now we will deal with 2 primitive as below,

Let’s see what it takes to extract the area code from a phone number.

            var phone = PhoneNumber;
            // Extract the area code
            var areacode = "";
           int index = phone.LastIndexOf("-", StringComparison.Ordinal);
           if (index > 0 && index < phone.Length)
                 areacode = phone.Substring(0,index);
            return areacode;

The above logic will be used and repeated at different places as and when there is a need for an area code.

Primitive Obsession Resolution(Partial):

So here developers might tend to add primitive specific validation logic to the Employee class (which is still code smell which we will see below example.. )

The class definition looks like as below after putting validation logic,

public class Employee
    {
        public Employee(string firstName, string lastName, int iD,string contactCellNo,string ssn)
        {
            FirstName = firstName;
            LastName = lastName;
            ID = iD;
            SSN = ssn;
        }

        public string FirstName { get; set; }
        public string LastName { get; set; }
        public int ID { get; set; }
        public string PhoneNumber { get; set; }
        public string SSN { get; set; }
        public string GetAreaCode()
        {
            var phone = PhoneNumber;
            // Extract the area code
            var areacode = "";
            int index = phone.LastIndexOf("-", StringComparison.Ordinal);
            if (index > 0 && index < phone.Length)
                 areacode = phone.Substring(0,index);
            return areacode;
        }

        public string GetLast4Digit()
        {
            var index = SSN.LastIndexOf("-", StringComparison.Ordinal);
            return index >0 && index < SSN.Length
                ? SSN.Substring(index + 1, SSN.Length - index + 1)
                : SSN;
        }
    }

Issues in the above Employee class:

Here GetAreaCode and GetLast4Digit methods would produce the desired results but there are a few problems as listed below,

• Extraction or formatting logic of SSN and PhoneNumber is owned by the Employee class.

• If the logic is needed in other parts of your application, then the code will be duplicated. You will end up instantiating the Employee class so that you can use the GetArea() or GetLast4Digit () method which is unnecessary.

Primitive Obsession Resolution (Full):

Refactoring Recipes for Primitive Obsession

I took these recipes from Martin Flower’s book “Refactoring: Improving the Design of Existing Code“.

Primitive obsession for the above two issues can be resolved by the below-refactoring recipes.

• Replace Data value with Object( suitable for the above example)

• Replace Type Code with Classes or Subclasses

• Replace Type Code with State/Strategy

Both above techniques concentrate more on replacing primitive type with ValueObject/Class/SubClass.

All validation or extraction logic will become part of ValueObject/Class/SubClass.

This will avoid code duplication.

Let’s now replace SSN and PhoneNumber primitive with objects. We shall also move their methods/validation logic.

public class SocialSecurity
    {
        public SocialSecurity(string ssn)
        {
            SSN = ssn;
        }

        public string SSN { get; set; }

        public string GetLast4Digit()
        {
           var index = SSN.LastIndexOf("-", StringComparison.Ordinal);
            return index > 0 && index < SSN.Length
                ? SSN.Substring(index + 1, SSN.Length - index + 1)
                : SSN;
        }
    }


    public class Contact
    {
        public Contact(string number)
        { 
            PhoneNumber = number;
        }

        public string PhoneNumber { get; set; }

        public string GetAreaCode()
        {
           var index = PhoneNumber.IndexOf("-", StringComparison.Ordinal);
            return index > 0 && index< PhoneNumber.Length
                ? PhoneNumber.Substring(0,index)
                : PhoneNumber;
        }
    }

See class diagram below for high-level changes,

On the calling side, since behavior is now sticking to a Class of its own, the code will be simplified as below,

• The result of recipes used for Primitive obsession resembles the low-level version of DDD (Domain Driven Design) bringing your domain properties and their validation logic together so that the domain model that gets built over this can be used across your application supporting the DRY (Do Not Repeat) principle. These value objects, however, are not actual business objects or domain models but are simple logical models.

• These refactoring principles like Primitive Obsession or Inappropriate Intimacy are really good friends of any Design Pattern including Domain Driven Design. These principles are where you will start ultimately before you can shape up design or architecture. Code is always supreme of all.

• Objects become logical containers by packaging data with their behavior as new methods/functions.

• There are many built-in types already available that encapsulate primitives and their methods like Ex. class DateTime.

References:

• NDepend– Continuous Code Quality

• Sonar way- Continuous Code Quality of .NET and .NET Core applications using Sonar

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Awesome code – Primitive Obsession Code Smell Resolution with example first appeared on TheCodeBuzz.

Today in this article we shall see how to use the Sonar Lint IDE extension for VSCode and manage Code Quality of Angular, React, and Vue applications with Sonar Qube.

Most of us understand the importance of code quality.

Good coding practices are language agnostic and help an organization deliver clean, highly reliable, secure, and maintainable code.

Today in this article, we shall cover the below aspects,

Software code quality and its maintenance is like a big fat elephant and often eat away a big chunk of project budget allocation. Re-engineering and refactoring of buggy code cost organization time, cost, and quality.

These small-looking coding issues become bigger problems in the future and potentially affect the complete architecture and design of your application.

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand”  -Martin Fowler

“Code is maintained more often than it is written”

SonarLint is an IDE extension that helps to detect and fix code quality issues as you type the code in IDE.

SonarLint extension combines all the best of the linting process and supports multiple analyzers and multiple languages.

• Typescript – Sonar TS analyzer

• JavaScript, React, Vue – SonarJS, ESLint analyzer

SonarLint IDE extension is currently supported by the below IDE overall,

Sonar defines coding issues in the below categories,

• Bug
• Code Smell
• Vulnerability

Each above categories can be further classified based on severity as below,

• Blocker
• Critical
• Major
• Minor
• Info

Let’s look into SonarLint VS Code plugin extension setup and configuration details.

Getting started – Code Quality of Angular, React, and Vue applications with Sonar

Prerequisites and Configuration:

Java Run time (JRE) 8

Once Java run time is installed, please verify using the version using the below command,

Further verification can be done by checking the below folder on your Windows machine,

Install Sonar Lint extension in VSCode

Setting.json update

Click on Settings ->Edit in Settings.Json

User Settings Sonar Qube – connected mode

These settings will be global and will be applied at the VSCode IDE level and will be effective for all projects.

{
"sonarlint.ls.javaHome": "C:\Program Files\Java\jdk1.8.0_201"
}

If connecting your Organization enterprise Sonar Server please add the below setting within “sonarlint.connectedMode.servers”

Note:

SonarLint uses the same rule set as configured on the SonarQube server thereby streamlining the code analysis and avoiding any ambiguity of issues reported on server vs desktop.

If not connected to the Sonar Server default ruleset ( which comes with plugin installation) will be used.

Connected Mode in User Settings

"sonarlint.connectedMode.servers": [
 {
"serverId": "your server id if any",
"serverUrl": "https://your-org/server",//Your Organization server URL
"organizationKey": "my_organization",// Organization Key
"token": "V2VkIE1…" //Organization Auth token
 }
]

Workspace settings Sonar – connected mode

This setting will be specific to an individual project. This setting can be checked in along with your source project to SCM.

{
"sonarlint.ls.javaHome": "C:\Program Files\Java\jre1.8.0_201"
}

Connected Mode in Workspace Settings

If connecting to your organization’s Sonar Server additionally add below within workspace settings.

"sonarlint.connectedMode.project": {
  "serverId": "your server id if any",
  "projectKey": "your project name in sonar server"
}

Once done with the above settings, you shall be all set to use Sonar linting. The output windows will display that SonarTS Server and the engine have started successfully.

If not connected to the server, Sonar Lint will launch the Sonar server( with different analyzers) locally by opening a local port and will use the default rule set in such a case.

If using Sonar Server in “Connected” mode kindly run the below command from the Command pallet,

Update SonarLint binding to SonarQube/SonarCloud 

As you type your code you shall be able to see the best recommendation from Sonar lint based on configured rules.

As we mentioned above Sonar lint uses the same rules set as configured on the SonarQube server and streamlines the code analysis by avoiding any ambiguity of reports on server vs desktop.

For server-side reporting SonarQube need to be used which is a licensed and enterprise version.

Sonar scan can be configured as part build and deploy process for the CI-CD pipeline.

SonarQube provides the overall health of the portfolio within the organization with nice dashboards detailing code health.

Happy coding !!

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

References:

• Continuous Code Quality using NDepend

• Code Quality of .NET Application using Sonar

Summary :

Today we learned about Sonar lint setup and configuration for Visual Studio Code IDE. Good coding practices are language agnostics and help the organization to deliver clean, highly reliable, secure, and maintainable projects. Buggy code slipping through the cracks has the potential to cost a company an entire business. Organizations can address these problems by following best practices of software development like continuous code quality and continuous code review processes.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Sonar Qube – Code Quality of Angular, React, and Vue applications first appeared on TheCodeBuzz.

Most of us understand the importance of code quality. Good coding practices are language agnostics and help any organization to deliver clean, highly reliable, secure, and maintainable code. Today in this article, we shall see how to manage the Code Quality of .NET with SonarQube.

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand”  -Martin Fowler

Software maintenance is like a big fat elephant and often eats away a big chunk of project budget allocation. Re-engineering and refactoring of buggy code cost organization time, cost, and quality. These small-looking coding issues become bigger problems in the future and potentially affect the complete architecture and design of your application.

“Code is maintained more often than it is written”

Today in this article, we will cover below aspects,

Today in this article we shall see how to use the Sonar Lint IDE extension in Visual Studio 2017(or VS2019)

SonarLint is an IDE extension that helps to detect and fix code quality issues as you type the code in IDE.

SonarLint Visual Studio extension combines together all best of the linting process and supports multiple analyzers and multiple languages.

• C# (.NET , .NET Core, .NET Standards) – Roslyn analyzer

• VB.NET- Roslyn analyzer

• JavaScript- SonarJS analyzer

• C/C++ – SonarCFamily

Support for Typescript or Python language is supported through another SonarLint plugin that works on Visual Studio Code IDE. Please see more details on the below link,

• Continuous Code Quality of Angular, React or Vue.js applications using Sonar

Getting started – Code Quality of .NET with SonarQube

Prerequisites:

* Visual Studio 2015 or 2017 or 2019

* Install SonarLint extension

From Menu->Extension->Manage Extension, please search with the keyword “Sonar” as below. Here I am installing this extension for VS2019.

Note-The first-time installation requires you to restart the Visual Studio to complete the installation.

After successful installation of the extension, IDE will start analyzing code and shall start reporting the issue as shown below,

As you type your code you shall be able to see the best recommendation from SonarLint based on configured rules.

Sonar – Connected Mode configuration

SonarQube scan can be configured as part build and deploy process within the CICD pipeline. SonarQube provides the overall health of the portfolio within the organization with nice dashboards detailing the overall health of the code.

Sonar Server

SonarLint if used with the SonarQube server streamlines the code analysis process by using a uniform rule set across the organization and avoids any ambiguity of issues reported on server vs developers Desktop/IDE. So far above we used the default ruleset which comes with plugin installation now we shall see how to use the connected mode of the sonar server.

Connected mode configuration is a simple 1-2 step process. Below we shall try connecting the application with a quality profile of the server.

• Click on Team Explorer in Visual Studio and connect to SonarQube as shown below,

• Provide Server URL and Password or Token to connect with sonar server from IDE,

After successful authentication, please select your organization.

Your application will be connected.

Establish the Sonar Server connection for the first time. Please click on “Bind” as shown below,

After successful binding, Quality profiles from Sonar Server will be downloaded locally in your projects which includes ruleset file and creation of .sonarlint folder as shown below,

• Sonar rule set file will be created within project folder (.csproj)

• Folder ‘.sonarlint‘ will be created with ruleset file and configuration file as below,

That’s all! Once the project gets connected with the server, Your project will work in connected mode using the same Quality profiles as of Sonar Server.

You will be able to see the same coding issues in IDE and in Pipeline and analyze your code against centralized configured rules.

Happy coding !!

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Other References :

• Continuous Code Quality using NDepend

• Continuous Code Quality of Angular, React or Vue.js applications using Sonar

Summary :

Today we learned about SonarLint extension set up and configuration for Visual Studio IDE. Good coding practices are language agnostics and help the organization to deliver clean, reliable, secure, and maintainable code. Buggy code slipping through cracks has the potential to cost a company an entire business.

Organizations can address these problems by following best practices of software development like continuous code quality and continuous code review processes.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Continuous Code Quality of .NET with SonarQube first appeared on TheCodeBuzz.

Today in this article, we will see Feature Envy Code Smell Resolution with examples.

Methods used in the application could be used to expose the internal or inner workings of other classes. That means a feature in a class may be using too much functionality from the feature of another class’s method. When you see such chatty communication from features of different classes there is clear visibility of code smell.

We will cover the below aspects of the article,

Feature envy smells come under a category called ‘Couplers’. In our last article, we understood couplers with the smell of Inappropriate Intimacy. Feature envy is similar to Inappropriate Intimacy but here instead of class relationship we talk about features/functions/method coupling.

“Code is maintained more often than it is written”

As per the principle of single responsibility, a function or a class should do one task at a time. A class should contain within itself both the behavior and methods (i.e. data).

“Code is read more often than it is written”

In object-oriented programming, there are multiple means of making classes that can interact with each other like using composition, aggregation, and inheritance. and transfer data to and from each other ultimately achieving required business functionality.

Characteristics of Feature Envy Smell

• A classic example could be where you sight a ‘method at the wrong place’.
• The class uses a significant number of methods and fields of other Classes (being used more than the class where it is defined)
• A properties /fields of a class are used by/in other class’s features (more than in the class where it is defined).
• A method being used to expose internal of other classes.

Cons

• High maintenance.
• Difficult to enhance/extend features.
• Demote readability and hard to understand.

Resolutions techniques

• Move Methods
• Move Fields
• Extract Method

Let’s look at each code recipe with examples in detail,

Move Methods

• Move methods to the right place
• Move tangled code to own methods

Examples – Feature Envy smell

Here we will use the same example as we used for the resolution of code smell -Inappropriate Intimacy,

namespace FeatureEnvySmell
{

    class ContactInfo
    {
        public string GetStreetName()
        {
            return "1 Medison Square";
        }
        public string GetCity()
        {
            return "NewYork";
        }
        public string GetState()
        {
            return "NY";
        }
    }

    class User
    {
        private ContactInfo _contactInfo;

        User(ContactInfo contactInfo)
        {
            _contactInfo = contactInfo;
        }
        public string GetFullAddress(ContactInfo info)
        {
            string city = info.GetCity();//1
            string state = info.GetState();//2
            string streetName = info.GetStreetName();//3
            return streetName + ";" + city + ";" + state;
        }
    }
}

Feature Envy smell Resolution

namespace FeatureEnvySmellResolved
{

    class ContactInfo
    {
        public string GetStreetName()
        {
            return "1 Medison Square";
        }
        public string GetCity()
        {
            return "NewYork";
        }
        public string GetState()
        {
            return "NY";
        }
        public string GetFullAddress(ContactInfo info)
        {
            string city = info.GetCity();//1
            string state = info.GetState();//2
            string streetName = info.GetStreetName();//3
            return streetName + ";" + city + ";" + state;
        }
    }

    class User
    {
        private ContactInfo _contactInfo;
        User(ContactInfo contactInfo)
        {
            _contactInfo = contactInfo;
        }
    }
}

Extract methods

Each method should do one task at a time.

I shall share an example of this technique for the same soon in my next article soon.

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Awesome Code – Feature Envy Code Smell Resolutions first appeared on TheCodeBuzz.