When should I use the [Obsolete] attribute and when should I delete my code? [closed]

Question

The function of [Obsolete] is essentially to stop a class/function from being used but still to maintain it in code for the record.

Is there any good reason why [Obsolete] should be used as opposed to just deleting, or commenting out the code. This question is even more relevant if you have source control so there is no point keeping the code for reference purposes as it will be in the SC.

I'm curious as to what is considered best practice?

Answer 1

It is used mostly for backwards compatibility, so when you do a new implementation of a functionality that has a different expected behaviour, any code using the old functionality will still work, but you make sure that new uses of your library uses the new implementation.

If you are maintaining a library that is being used by third parties, you should develop a road map of when and if the obsolete functionality is going to be removed. The if it's important, because many times you are just indicating that that function is no longer to be maintained and the new one should be used instead.

Internally, it can be used in refactors to replace poorly-implemented-but-working functionality in a gradual way. You mark it as obsolete and start working through the warnings until you see no more of them, then you can proceed to safely remove it.

Be aware that this is an opinion based on experience on renewing legacy code bases and there is no common consensus.

Answer 2

The Obsolete attribute marks a program entity as one that is no longer recommended for use. Each use of an entity marked obsolete will subsequently generate a warning or an error, depending on how the attribute is configured.

Here an example for Hashtable comparer from reference source.

    [Obsolete("Please use KeyComparer properties.")]        
    protected IComparer comparer
    {
        get
        {
            if( _keycomparer is CompatibleComparer) {
                return ((CompatibleComparer)_keycomparer).Comparer;
            }    
            else if( _keycomparer == null) {
                return null;
            }                            
            else {
                throw new ArgumentException(Environment.GetResourceString("Arg_CannotMixComparisonInfrastructure"));
            }                
        }
        set
        {
            if (_keycomparer is CompatibleComparer) {
                CompatibleComparer keyComparer = (CompatibleComparer)_keycomparer;
                _keycomparer = new CompatibleComparer(value, keyComparer.HashCodeProvider);
            }
            else if( _keycomparer == null) {
                _keycomparer = new CompatibleComparer(value, (IHashCodeProvider)null);               
            }                
            else {
                throw new ArgumentException(Environment.GetResourceString("Arg_CannotMixComparisonInfrastructure"));
            }
        }
    }