Custom Dependency Property not showing in Intellisense

Question

I have created the following custom Dependency Property in the code behind. This Dependency property of type infragistics XamDataGrid and so the owner. I'm trying to get a reference of the grid through this property.

The following code compiles with no errors or warnings. However, the Dependency Property does not show in the XAML intelliSense.

I have tried typing the full name as well. It is not recognizing this DP. I have cleaned the project and Rebuilt it. I have even closed Visual Studio and reopened it.

using System.Windows;
using Infragistics.Windows.DataPresenter;

namespace Demo
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        public static readonly DependencyProperty DPRProperty = 
            DependencyProperty.Register(
                            "DPR", 
                            typeof(XamDataGrid), 
                            typeof(MainWindow), 
                            new FrameworkPropertyMetadata(null));

        public XamDataGrid DPR
        {
            get { return (XamDataGrid)GetValue(DPRProperty); }
            set { SetValue(DPRProperty, value); }
        }

    }
}

Answer 1

The problem is that you expect the Dependency Property to show up in your base classes XAML "code"

however, you did not created a DP for Window but for MainWindow

If you would use a <MainWindow /> tag, it would show up

if you could explain what you try to archive, one may could help you further

edit

Think i understood now what your goal is

To get a reference to any object, you do not need a DP but rather have to order everything correctly

things required:

• The Window (obviously)
• A DataContext
• Some Code-Behind
• An Attached-Property

The Attached Property is looking pretty much like this

public class Initialized
{
    public static DependencyProperty CommandProperty =
        DependencyProperty.RegisterAttached("Command",
        typeof(ICommand),
        typeof(Initialized),
        new UIPropertyMetadata(CommandChanged));

    public static DependencyProperty CommandParameterProperty =
        DependencyProperty.RegisterAttached("CommandParameter",
                                            typeof(object),
                                            typeof(Initialized),
                                            new UIPropertyMetadata(null));

    public static void SetCommand(DependencyObject target, ICommand value)
    {
        target.SetValue(CommandProperty, value);
    }

    public static void SetCommandParameter(DependencyObject target, object value)
    {
        target.SetValue(CommandParameterProperty, value);
    }
    public static object GetCommandParameter(DependencyObject target)
    {
        return target.GetValue(CommandParameterProperty);
    }

    private static void CommandChanged(DependencyObject target, DependencyPropertyChangedEventArgs e)
    {
        var type = target.GetType();
        var ev = type.GetEvent("Initialized");
        var method = typeof(Initialized).GetMethod("OnInitialized");

        if ((e.NewValue != null) && (e.OldValue == null))
        {
            ev.AddEventHandler(target, Delegate.CreateDelegate(ev.EventHandlerType, method));
        }
        else if ((e.NewValue == null) && (e.OldValue != null))
        {
            ev.RemoveEventHandler(target, Delegate.CreateDelegate(ev.EventHandlerType, method));
        }
    }

    public static void OnInitialized(object sender, EventArgs e)
    {
        var control = sender as FrameworkElement;
        var command = (ICommand)control.GetValue(CommandProperty);
        var commandParameter = control.GetValue(CommandParameterProperty);
        command.Execute(commandParameter);
    }
}

In your DataContext (lets name it MainWindowDataContext), create a new ICommand property (Lets name it CmdInitialized) that puts the parameter passed to the command into your instance variable

Then, in your XAML code you just use the AttachedProperty like usual

 <!-- `ev:` is the XAML namespace the Initialized class is located in -->
 ev:Initialized.Command="{Binding CmdInitialized}"
 ev:Initialized.CommandParameter="{Binding RelativeSource={RelativeSource Self}}"

the important part however is: the DataContext needs to be already attached in the window BEFORE the compontents are initialized

this means that you have to edit your window code to something like this:

public MainWindow()
{
    this.DataContext = new MainWindowDataContext();
    InitializeComponent();
}

Afterwards, you should be fine

if you need solutions for the ICommand, search for RelayCommand on google :)