I have some more information.  Some of my properties are of type
InheritedPropertyDescriptor (after the call to
TypeDescriptor.GetProperties(myObject, false)) and when I call
ShouldSerializeValue on some of these properties the value returned is True
(which is what I would expect).  In the case of these properties, the
ShouldSerialize<PropertyName> method is called, unlike in the other
properties' cases, where ShouldSerializeValue always returns false.

Looking at implementation of
InheritedPropertyDescriptor.ShouldSerializeValue in Reflector, I found that
there is a test of see whether the property IsReadOnly.  In both cases (when
ShouldSerializeValue works as expected and not), the IsReadOnly property
returns false.  

The next test in InheritedPropertyDescriptor.ShouldSerializeValue is to
compare a private 'defaultValue' field against the static
InheritedPropertyDescriptor.noDefault field. Looking in the VS debugger, I
find something interesting.  In both cases,
InheritedPropertyDescriptor.noDefault evaluates to {Object}.  In the case
where things serialize as I expect (i.e. ShouldSerializeValue  returns true),
then the 'defaultValue' field matches the
InheritedPropertyDescriptor.noDefault.  In the case where it does not work as
expected, the 'defaultValue' field is different.  The third test in
InheritedPropertyDescriptor.ShouldSerialize is then invoked, which compares
the value of the property vs. the 'defaultValue' field's value.  If these two
don't match, then true is returned; otherwise
InheritedPropertyDescriptor.ShouldSerialize returns false.

It turns out that in the case where things don't serialize as I expect, the
'defaultValue' private field in InheritedPropertyDescriptor matches the value
of the property!  This is why the method returns false.  Using Reflector
again, I find that the 'defaultValue' field appears to be set in
InheritedPropertyDescriptor.InitInheritedDefaultValue, which is called from
the InheritedPropertyDescriptor constructor.  By trial and error, and
examining the InitInheritedDefaultValue implementation in reflector, I
believe that the code is going into the branch that does this:

    if (!this.propertyDescriptor.ShouldSerializeValue(component))
           {
            //Do stuff here - content removed by me for clarity
           }
           else
           {
                 this.defaultValue =
this.propertyDescriptor.GetValue(component);
                 obj1 = this.defaultValue;
                 this.defaultValue =
this.ClonedDefaultValue(this.defaultValue);
           }
That is, code execution goes into the else part of the if/else test and it
assigns the current value of the property to the defaultValue!  

I'm not 100% clear, but it looks like the InheritedPropertyDescriptor object
is created each time TypeDescriptor.GetProperties(myObject, false) is called,
so that the 'defaultValue' always matches the current property value;
therefore, ShouldSerializeValue always returns false...

Notre