When does it make sense to use private static methods in instance class [duplicate]

Question

Ive inherited some code that are a regular class with some private static methods in them. The code (pseudo code) looks like this

public class Animal
{
    private string typeOfAnimal;

    public Animal(string typeOfAnimal)
    {
        this.typeOfAnimal = typeOfAnimal;
    }

    public void MakeSound()
    {
        var sound = Animal.GetSound(typeOfAnimal);

        // Make use of sound here       
    }

    private static string GetSound(string typeOfAnimal)
    {
        if(typeOfAnimal  == "dog")
            return "bark";
        else if(typeOfAnimal == "cat")
            return "mjau";
    }
}

Is there any benefit in doing like this compared to making GetSound a regular instance method?

Answer 1

There is some very minor performance difference in static methods, I think that is actually something the SO guys take advantage of. Also, making the method static gets you a slight readability improvement because of what the keyword implies.

My take on this is usually readability. In this case there are two differences: instances vs static, public vs private. Neither is inherently more beneficial than the other, the benefits only appear depending on intended use. In your case, it has no value being a public method and isn't part of the public API of the type so you make it private, and doesn't want to mutate instance state so you make it static.

By default, ReSharper highlights methods that can be made static.

Answer 2

It is advisable to mark your private methods as static if they are not using any of the instance object for slightly better performance and readability.

Infact the following warning in code analysis is shown if such methods are not marked as private.

CA1822: Mark members as static

Extract from the link -

Members that do not access instance data or call instance methods can be marked as static (Shared in Visual Basic). After you mark the methods as static, the compiler will emit nonvirtual call sites to these members. Emitting nonvirtual call sites will prevent a check at runtime for each call that makes sure that the current object pointer is non-null. This can achieve a measurable performance gain for performance-sensitive code. In some cases, the failure to access the current object instance represents a correctness issue.