CA1000: Why shouldn't I declare static members on generic types?

[SimonDotException]

I've written an abstract base type which uses generics to provide XML serialization and deserialization methods for use by its derived types, but I'm seemingly unable to write it in a way which completely satisfies FxCop code analysis. Here is the simplest form of the base class which reproduces the problem:

public abstract class XmlSerializableItem<T>
{
    public string ToXml()
    {
        XmlSerializer xs = new XmlSerializer( this.GetType() );
        TextWriter xw 
            = new StringWriter( CultureInfo.InvariantCulture );
        xs.Serialize( xw, this );
        return Convert.ToString( xw, CultureInfo.InvariantCulture );
    }
 
    [SuppressMessage("Microsoft.Design", 
                    "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
    public static T FromXml( string xml )
    {
        XmlSerializer xs = new XmlSerializer( typeof( T ) );
        TextReader tr = new StringReader( xml );
        return (T) xs.Deserialize( tr );
    }
}
 

The derived type would look something like

public class MyDerived : XmlSerializableItem<MyDerived>
{
    /* add some properties etc */
}
 

and it would be used like this

MyDerived d1 = new MyDerived(); // assume a suitable constructor has been implemented
string xml = d1.ToXml();
MyDerived d2 = MyDerived.FromXml( xml );
 

and after executing this, we'd have two instances of MyDerived, both with the same property values.

The reason the base type needs to be generic is so that I can use the type parameter T as the return type of the FromXml method.

The problem is that the FromXml method throws a FxCop warning CA1000:DoNotDeclareStaticMembersOnGenericTypes. Microsoft seem to be quite emphatic that warning CA1000 should not be suppressed although I'm not sure I agree in this case. Their reason is

// Static method in a generic type.
GenericType<int>.StaticMethod();

// Generic instance method that does not support inference.
someObject.GenericMethod<int>();

Generally, both of the prior declarations should be avoided so that the type argument does not have to be specified when the member is called. This results in a syntax for calling members in generics that is no different from the syntax for non-generics.

Except in this case the type parameter is supplied in the derived type's class declaration and does not need to be provided when the derived type is used - the XmlSerializableItem class is effectively hidden from consumers of the derived type.

If I follow Microsoft's suggestion and change FromXml from a static method to an instance method then the derived type becomes, if anything, more difficult to use:

MyDerived d1 = new MyDerived(); // assume a suitable constructor has been implemented
string xml = MyDerived.ToXml();
MyDerived d2 = new MyDerived();
MyDerived d2 = d2.FromXml( xml );
 

I need an extra line of code, instantiating an instance of MyDerived, whose value is never used because that instance is only used to make the FromXml method available so that I can instantiate the instance that I actually want, from the XML string. This strikes me as a bit silly.

Maybe I'm missing something, and there's another way of providing this deserialization functionality in a base type without violating any FxCop rules. Or maybe Microsoft have got it wrong and this rule shouldn't apply to static members on abstract base types. Any thoughts on this subject much appreciated...

Thanks

Simon.