(resend; NNTP issues?)

Not via BindingFlags - but you can via TypeDescriptor.

Marc

using System;
using System.ComponentModel;
class Foo
{
   static void Main()
   {
       Foo foo = new Foo();
       foo.DateOfBirth = DateTime.Today;
       foo.Name = "Fred";
       foo.ShoeSize = 10;
       Attribute[] attribs = {new InterestingAttribute()};
       foreach(PropertyDescriptor prop in
TypeDescriptor.GetProperties(foo, attribs))
       {
           Console.WriteLine("{0}={1}", prop.Name,
prop.GetValue(foo));
       }
   }

   public string Name { get; set; }
   [Interesting]
   public DateTime DateOfBirth { get; set; }
   [Interesting]
   public int ShoeSize { get; set; }
}

[AttributeUsage(AttributeTargets.Property,
   AllowMultiple = false, Inherited = true)]
class InterestingAttribute : Attribute { }

If you wanted to use an attribute you'd have to enumerate through all of the
properties and test what attributes are on the property. If speed is an
issue, figure out which properties have the attribute applied to it for that
type and cache the results for easy retrieval later on. Once the class gets
checked over once, it won't have to worry about about finding them again. If
you need to have this handle across multiple objects, you may want to use an
in-memory collection similar to:

Dictionary<Type, Collection<PropertyInfo>> cache;
Collection<PropertyInfo> propertiesCollection = new
Collection<PropertyInfo>();

Type currentType = this.GetType();
foreach (PropertyInfo propInfo in currentType.GetProperties()) {
   object[] attributes =
propInfo.GetCustomAttributes(typeof(UseForReflectionAttribute), true));
   if (attributes == null || attributes.Length == 0) continue;

   propertiesCollection.Add(propInfo)
}

this.cache.Add(currentType, propertiesCollection);

Now that the collection has been created for the current object, you'll want
to use it:

foreach (PropertyInfo propInfo in this.cache[this.GetType()]) {
   // Do what you wanted to with your object here
}

Granted I don't know your situation, but something similar to what I've
demonstrated above should provide you with the flexibility you need and keep
it fast enough that you won't get a large degredation in speed while
enumerating through the properties on the object constantly.