Skip to main content

Improper type assignation

Need​

Enforce proper type assignation in the source code

Context​

  • Usage of C# 7.0 for modern and efficient programming in the C# language
  • Usage of Microsoft.AspNetCore.Mvc for building web applications with ASP.NET Core

Description​

Non compliant code​

public class HomeController : Controller
{
    public IActionResult Index()
    {
        var myVariable = "Hello World!";
        return View(myVariable);
    }
}

In the provided code snippet, we have a variable myVariable that's declared with the var keyword. This keyword allows you to declare a variable without specifying its type. The type of the variable is automatically inferred by the compiler based on the value assigned to it.

In this case, myVariable is inferred to be of type string because it's assigned a string value "Hello World!".

While this might seem convenient and flexible, it can lead to potential problems and inefficiencies. For instance, if the value assigned to myVariable changes in the future, the type of myVariable could change too, leading to potential runtime errors or unexpected behavior.

Furthermore, every time myVariable is used, the runtime needs to determine its actual type and perform a type casting operation. This can be inefficient especially in performance-critical sections of the code.

Finally, the use of var can also make the code less readable and maintainable, especially in complex applications, as it's not immediately clear what type a variable is supposed to be.

Steps​

  • Declare the specific data type for the variable 'myVariable'
  • Assign the value 'Hello World!' to the variable 'myVariable'
  • Ensure that the assigned value matches the declared data type
  • Update the code to use the declared data type instead of 'var'
  • Recompile and test the application to verify the fix

Compliant code​

public class HomeController : Controller
{
    public IActionResult Index()
    {
        string myVariable = "Hello World!";
        return View(myVariable);
    }
}

The original code was using the var keyword to declare the variable myVariable. This is a potential vulnerability because the var keyword allows for implicit typing, which means the compiler determines the type of the variable at compile time. However, this can lead to inefficiencies as the type of the variable has to be determined every time it is used.

The fixed code explicitly declares myVariable as a string. This is a more secure practice as it ensures that the type of myVariable is known at all times, which can prevent potential type-related errors or vulnerabilities. It also improves the efficiency of the code as the type of the variable does not need to be determined every time it is used.

After updating the code, it is important to recompile and test the application to ensure that the changes have not introduced any new issues and that the application behaves as expected.

References​

Last updated on