This rule currently only fires on string methods that return a new instance of a string. This includes methods such as, but not limited to, String.Trim, String.ToLower, String.ToUpper, etc.

As strings are immutable (that is, they can't be changed), these methods return a new instance of string rather than modifying the orginal instance the method was called on.

The following example shows this.

[C#]

string upper = "UPPER";

string lower = upper.ToLower();

Console.WriteLine(upper);

Console.WriteLine(lower);

This outputs the following:

UPPER

upper

The following example shows a class that ignores the result of calling String.Trim.

[C#]

using System;

namespace Samples
{
    public class Book
    {
        private readonly string _Title;

        public Book(string title)
        {
            if (title != null)
            {
                // Violates this rule
                title.Trim();
            }

            _Title = title;
        }

        public string Title
        {
            get { return _Title; }
        }
    }
}

[Visual Basic]

Imports System

Namespace Samples

    Public Class Book

        Private ReadOnly _Title As String

        Public Sub New(ByVal title As String)

            If title IsNot Nothing Then
                ' Violates this rule
                title.Trim()
            End If

            _Title = title

        End Sub

        Public ReadOnly Property Title() As String
            Get
                Return _Title
            End Get
        End Property
    End Class

End Namespace

[C++]

using namespace System;

namespace Samples
{

    public ref class Book
    {

  
    private:
        initonly String^ _Title;

    public:

        Book(String^ title)
        {   
            if (title != nullptr)
            {  
                // Violates this rule
                title->Trim();
            }

            _Title = title;
        }

        property String^ Title
        {
            String^ get() { return _Title; }
        }
    };
}

The following example fixes the above violation by assigning the result of String.Trim back to the variable it was called on.

[C#]

using System;

namespace Samples
{
    public class Book
    {
        private readonly string _Title;

        public Book(string title)
        {
            if (title != null)
            {
                title = title.Trim();
            }

            _Title = title;
        }

        public string Title
        {
            get { return _Title; }
        }
    }
}

[Visual Basic]

Imports System

Namespace Samples

    Public Class Book

        Private ReadOnly _Title As String

        Public Sub New(ByVal title As String)

            If title IsNot Nothing Then
                title = title.Trim()
            End If

            _Title = title

        End Sub

        Public ReadOnly Property Title() As String
            Get
                Return _Title
            End Get
        End Property

    End Class

End Namespace

[C++]

using namespace System;

namespace Samples
{
    public ref class Book
    {

    private:
        initonly String^ _Title;

    public:

        Book(String^ title)
        {   
            if (title != nullptr)
            {        
                title = title->Trim();
            }

            _Title = title;
        }

        property String^ Title
        {
            String^ get() { return _Title; }
        }
    };
}

The following example shows a method that does not use the creation of an object.

[C#]

using System;

namespace Samples
{
    public class Book
    {
        public Book()
        {
        }

        public static Book CreateBook()
        {
            // Violates this rule
            new Book();
            return new Book();
        }
    }
}

[Visual Basic]

This violation cannot be reproduced in Visual Basic.

[C++]

using namespace System;

namespace Samples
{
    public ref class Book
    {

    public:

        Book()
        {
        }

        static Book^ CreateBook()
        {
            // Violates this rule
            gcnew Book();
            return gcnew Book();
        }
    };
}

The following example fixes the above violation by removing the unnecessary creation.

[C#]

  
using System;

namespace Samples
{
    public class Book
    {
        public Book()
        {
        }

        public static Book CreateBook()
        {
            return new Book();
        }
    }
}

[Visual Basic]

This violation cannot be reproduced in Visual Basic.

[C++]

using namespace System;

namespace Samples
{
    public ref class Book
    {

    public:

        Book()
        {   
        }

        static Book^ CreateBook()
        {
            return gcnew Book();
        }        
    };
}