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 :)