Filter DependencyObject and DependencyProperties from a DLL/Assembly?

Question

I got the following code to generate a DLL :

public class QtObject : DependencyObject
{
    public int speedSimu
    {
        get { return (int)GetValue(speedSimuProperty); }
        set { SetValue(speedSimuProperty, value); }
    }
    public static readonly DependencyProperty speedSimuProperty =
        DependencyProperty.Register("speedSimu", typeof(int), typeof(QtObject), new PropertyMetadata(0));

    public int rpmSimu
    {
        get { return (int)GetValue(rpmSimuProperty); }
        set { SetValue(rpmSimuProperty, value); }
    }
    public static readonly DependencyProperty rpmSimuProperty =
        DependencyProperty.Register("rpmSimu", typeof(int), typeof(QtObject), new PropertyMetadata(0));

    public int nbSimu;
}

public class Timer : DependencyObject
{
    public string description
    {
        get { return (string)GetValue(descriptionProperty); }
        set { SetValue(descriptionProperty, value); }
    }
    public static readonly DependencyProperty descriptionProperty =
        DependencyProperty.Register("description", typeof(string), typeof(Timer), new PropertyMetadata("This is a time"));

    public bool isActive
    {
        get { return (bool)GetValue(isActiveProperty); }
        set { SetValue(isActiveProperty, value); }
    }
    public static readonly DependencyProperty isActiveProperty =
        DependencyProperty.Register("isActive", typeof(bool), typeof(Timer), new PropertyMetadata(true));
}

public class AnotherClass
    {
        //blaaa
    }

I now would like to ONLY get DependencyObject/Properties. (ie without property "nbSimu" and without object "AnotherClass")

Here is the code I have :

var library = Assembly.LoadFrom(libraryPath);
IEnumerable<Type> types = library.GetTypes();
var libs = types.Where(t => true);

foreach (Type type in libs)
{
    foreach (PropertyInfo property in type.GetProperties())
    {
        //TODO
   }
}

On the 3rd line I tried :

var libs = types.Where(t => t.BaseType == typeof(DependencyObject));

It doesn't say any error, but doesn't filter anything...

And about filtering the DependencyProperties, I just got no idead about how to do it...

Thanks in advance for any help on it, on both problems.

Answer 1

It works on my comp.

public class A : DependencyObject
    {
      public string Name { get; set; }

      public int speedSimu
      {
        get { return (int)GetValue(speedSimuProperty); }
        set { SetValue(speedSimuProperty, value); }
      }
      public static readonly DependencyProperty speedSimuProperty =
          DependencyProperty.Register("speedSimu", typeof(int), typeof(A), new PropertyMetadata(0));

      public int rpmSimu
      {
        get { return (int)GetValue(rpmSimuProperty); }
        set { SetValue(rpmSimuProperty, value); }
      }
      public static readonly DependencyProperty rpmSimuProperty =
          DependencyProperty.Register("rpmSimu", typeof(int), typeof(A), new PropertyMetadata(0));

    }

    public class B : A
    {
      public int Age { get; set; }
    }

    private static void Main(string[] args)
    {
      var assembly = Assembly.GetExecutingAssembly();
      var types = assembly.GetTypes();

      var filterTypes = types.Where(t => typeof (DependencyObject).IsAssignableFrom(t)).ToList(); // A and B

      Func<string, string> mapFieldToProperty =
        field => field.EndsWith("Property") ? field.Remove(field.IndexOf("Property")) : field;


      foreach (var type in filterTypes)
      {
        var depFields =
          type.GetFields(BindingFlags.Public | BindingFlags.Static).Where(
            f => typeof (DependencyProperty).IsAssignableFrom(f.FieldType)).ToList(); // speedSimuProperty and rpmSimuProperty
        var depPropertyNames = depFields.ToLookup(f => mapFieldToProperty(f.Name)); 

        var depProperties =
          type.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(
            prop => depPropertyNames.Contains(prop.Name)).ToList(); // speedSimu and rpmSimu

        foreach (var property in depProperties)
        {
          // TODO
        }

      }
      return;
    }

What about second problem.. you should keep to naming convention of your properties/fields

Answer 2

var libs = types.Where(t => t.IsSubclassOf(typeof(DependencyObject))); should work.