精华内容
下载资源
问答
  • WPF DataContext

    千次阅读 2020-08-25 10:57:53
    如果有子元素没有通过本地值或样式建立的DataContext的其他值,则属性系统会将该值设置为已分配此值的最近父元素的DataContext值。 在 XAML 中,DataContext通常设置为Binding声明。可以使用属性元素语法或特性...

    简介:

            获取或设置元素参与数据绑定时的数据上下文。数据上下文是一种概念,允许元素从父元素继承有关用于绑定的数据源以及绑定的其他特征(如路径)的信息。此依赖属性继承属性值。 如果有子元素没有通过本地值或样式建立的 DataContext 的其他值,则属性系统会将该值设置为已分配此值的最近父元素的 DataContext 值。

            在 XAML 中,DataContext 通常设置为 Binding 声明。 可以使用属性元素语法或特性语法。 还可以使用代码设置 DataContextDataContext 是一种可绑定的属性,可用于在一个上下文可能绑定到另一个上下文的情况下实现。 但是,如果绑定到 DataContext,请注意不要创建循环绑定引用(不将 DataContext 绑定到其自身,因为 DataContext 属性的属性值继承特性)。

     

    使用:

        public class PersonNP:INotifyPropertyChanged
        {
            public event PropertyChangedEventHandler PropertyChanged;
    
            private string name;
            public string Name
            {
                get { return name;  }
                set { name = value; Notify(); }
            }
             
            private void Notify([CallerMemberName]string obj ="")
            {
                if (PropertyChanged != null)
                {
                    this.PropertyChanged (this, new PropertyChangedEventArgs(obj));
                }
            }
        }

     

    6种方法绑定DataContext

    1.方法①,后台实例化

            private PersonNP pNP;
            public MainWindow()
            {
                InitializeComponent();
                pNP = new PersonNP
                {
                    Name = "test"
                };
                this.DataContext = pNP;  //DataContext设置
            }

     

     2.方法②,DataContext设置

    系统默认查找父元素控件的DataContext,不直接声明使用父元素的DataContext。亦可以在其它父元素上声明DataContext。

        <Window.DataContext>
            <local:PersonNP Name="test"/>
        </Window.DataContext>
        <Grid>
            <StackPanel>
                <TextBox  Text="{Binding Path=Name,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay}"></TextBox>
                <TextBlock Text="{Binding Path=Name}"></TextBlock>
            </StackPanel>
        </Grid>
        <Grid>
            <StackPanel>
                <StackPanel.DataContext>
                    <local:PersonNP Name="test"/>
                </StackPanel.DataContext>
                <TextBox Text="{Binding Path=Name,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay}"></TextBox>
                <TextBlock Text="{Binding Name}"></TextBlock>
            </StackPanel>
        </Grid>

     

    3.方法③,Resources设置

    声明为Resources作为DataContext,系统默认查找父元素的DataContext。亦可以在其它父元素上声明DataContext。

        <Window.Resources>
            <local:PersonNP x:Key="p" Name="test"></local:PersonNP>
        </Window.Resources>
        <Grid>
            <StackPanel DataContext="{StaticResource p}">
                <TextBox  Text="{Binding Path=Name,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay}"></TextBox>
                <TextBlock Text="{Binding Path=Name}"></TextBlock>
            </StackPanel>
        </Grid>
        <Grid>
            <StackPanel>
                <StackPanel.Resources>
                    <local:PersonNP x:Key="p" Name="test"></local:PersonNP>
                </StackPanel.Resources>
                <TextBox  Text="{Binding Path=Name,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay}" DataContext="{StaticResource p}"></TextBox>
                <TextBlock Text="{Binding Path=Name}" DataContext="{StaticResource p}"></TextBlock>
            </StackPanel>
        </Grid>

     

    1.方法④,查找父元素控件的DataContext

    指定查找父元素的类型,即是StackPanel设置的DataContext。

        <Window.Resources>
            <local:PersonNP x:Key="p" Name="test"></local:PersonNP>
        </Window.Resources>
        <Grid>
            <StackPanel DataContext="{StaticResource p}">
                <TextBox  Text="{Binding Path=Name,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay}"></TextBox>
                <TextBlock Text="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type StackPanel}},Path=DataContext.Name}"></TextBlock>
            </StackPanel>
        </Grid>

     

    2.方法⑤,查找自身控件的DataContext

    虽然没有显式设置,但是系统默认会查找父元素控件的DataContext。 

        <Window.Resources>
            <local:PersonNP x:Key="p" Name="test"></local:PersonNP>
        </Window.Resources>
        <Grid>
             <StackPanel DataContext="{StaticResource p}">
                <TextBox  Text="{Binding Path=Name,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay}"></TextBox>
                <TextBlock Text="{Binding RelativeSource={RelativeSource Self},Path=DataContext.Name}"></TextBlock>
            </StackPanel>
        </Grid>

     

    3.方法⑥,分别设置控件的DataContext

    每个控件分别设置DataContext,但都需要指定ResourceKey,确认DataContext对象是相同的。

        <Window.Resources>
            <local:PersonNP x:Key="p" Name="test"></local:PersonNP>
        </Window.Resources>
        <Grid>
            <StackPanel>
                <TextBox Text="{Binding Path=Name,UpdateSourceTrigger=PropertyChanged,Mode=TwoWay}">
                    <TextBox.DataContext>
                        <StaticResource ResourceKey="p"/>
                    </TextBox.DataContext>
                </TextBox>
                <TextBlock Text="{Binding Name}">
                    <TextBlock.DataContext>
                        <StaticResource ResourceKey="p"/>
                    </TextBlock.DataContext>
                </TextBlock>
            </StackPanel>
        </Grid>

     

    简写: 

    如下两种写法是等价的。

     <StackPanel DataContext="{StaticResource p}">
     <StackPanel DataContext="{Binding Source={StaticResource ResourceKey=p}}">

     

    Source:

    1.一般指定特定的Resources。

        <Window.Resources>
            <local:PersonNP x:Key="p" Name="test"></local:PersonNP>
        </Window.Resources>

     

    2 后台获取前台设置的Resource

    PersonNP p =(PersonNP)this.FindResource("p");

     

     结果:

     

    展开全文
  • WPF 中 数据绑定 ItemSource和 DataContext的不同点:(1)DataContext 一般是一个非集合性质的对象,而ItemSource 更期望数据源是 集合对象。(2)DataContext 是 FrameworkElement 类中定义的一个依赖属性...

    WPF 中 数据绑定 ItemSource和 DataContext的不同点:

    (1)DataContext 一般是一个非集合性质的对象,而ItemSource 更期望数据源是 集合对象。

    (2)DataContext 是 FrameworkElement 类中定义的一个依赖属性(Dependency property),ItemsSource是 在ItemsControl 类中定义的。所有继承自FrameworkElement 的类(控件)都可以使用DataContext属性并给其赋值,但我们只能给ItemsSource赋值为集合对象

    (3)DataContext不能产生模板,它只能用来筛选出数据,供其它控件来绑定。而ItemsSource主要作用就是给模板提供数据。

    (4)DataContext主要用来抓取一些子元素需要使用的数据,以保证子元素能够顺利的使用数据。ItemsSource不会用来分享数据,它只是对定义好的元素有效。
    以上可参照博客:
    https://www.cnblogs.com/flytigger/p/4113121.html

    下面来看下Itemsource,这里没有用到DataConetext,下面这个例子说明了(1)中的ItemSource 更期望数据源是 集合对象:
    后台代码:

    public partial class MainWindow : Window
        {       
            public MainWindow()
            {
                InitializeComponent();
                List<string> listStrings = new List<string>();
                for (int i = 0; i < 50; i++)
                {
                    listStrings.Add(i.ToString());
                }
                listBox.ItemsSource = listStrings;
            }
        }

    前台代码:

    <Window x:Class="WpfApplication5.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:WpfApplication5"
            mc:Ignorable="d"
            Title="MainWindow" Height="350" Width="525">
        <Grid>
            <ListBox Name="listBox"></ListBox> 
        </Grid>
    </Window>

    下面再来看看Datacontext和itemsource一起用的情况,从下面可以看出(2)中说明的情况,从调试中的代码可以看得更清楚一些,DataContext 一般是一个非集合性质的对象,然后前台的listbox绑定的是Datacontext中的MyListString的对象:
    后台代码:

        public partial class MainWindow : Window
        {    
            public List<string> MyListString { get; set; }   
            public MainWindow()
            {
                InitializeComponent();
                List<string> listStrings = new List<string>();
                for (int i = 0; i < 50; i++)
                {
                    listStrings.Add(i.ToString());
                }
                MyListString = listStrings;
                DataContext = this;
            }
        }

    前台代码:

    <Window x:Class="WpfApplication5.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:WpfApplication5"
            mc:Ignorable="d"
            Title="MainWindow" Height="350" Width="525">
        <Grid>
            <ListBox Name="listBox" ItemsSource="{Binding Path=MyListString}"></ListBox> 
        </Grid>
    </Window>

    这里写图片描述

    接着来看一个常用的绑定模式,DataContext直接绑定到类,itemsource直接绑定到类的字段:
    首先来一个MainViewModel的类,并给予一个Student的字段,给字段赋值。

        public class MainViewModel
        {
            public List<Student> listStudent { get; set; }
            public MainViewModel()
            {
                listStudent = new List<Student> { new Student("小王", 001), new Student("小张", 002), new Student("小李", 002) };
            }
        }
        public class Student
        {
            public string Name { get; set; }
            public int Id { get; set; }
    
            public Student(string name, int id)
            {
                Name = name;
                Id = id;
            }
        }

    然后直接在前台用resourc绑定这个类,listbox的itemsource绑定这个类的字段Student。
    前台绑定这个类的时候,实际上就相当于把这个类实例化了,listbox的itemsource只需要静态跟踪这个类的字段。

    <Window x:Class="WpfApplication5.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:WpfApplication5"
            mc:Ignorable="d"
            Title="MainWindow" Height="350" Width="525">
        <Window.Resources>
            <local:MainViewModel x:Key="mvm"/>
        </Window.Resources>
        <Grid>
            <ListBox Name="listBox"  ItemsSource="{Binding Source={StaticResource mvm},Path=listStudent}"  DisplayMemberPath="Name"></ListBox> 
        </Grid>
    </Window>

    以上也可以换到后台表示:
    换掉之后,前后台代码(这里需要在后台实例化):

    public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
                MainViewModel mvm = new MainViewModel();            
                listBox.ItemsSource = mvm.listStudent;
            }
        }
    <Window x:Class="WpfApplication5.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:WpfApplication5"
            mc:Ignorable="d"
            Title="MainWindow" Height="350" Width="525">
    
        <Grid>
            <ListBox Name="listBox"   DisplayMemberPath="Name"></ListBox> 
        </Grid>
    </Window>

    也可以稍微换一下绑定方式,不用Window.Resources,而改用Window.DataContext也可以:

    <Window x:Class="WpfApplication5.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:WpfApplication5"
            mc:Ignorable="d"
            Title="MainWindow" Height="350" Width="525">
        <Window.DataContext>
            <local:MainViewModel/>
        </Window.DataContext>
        <Grid>
            <ListBox Name="listBox" ItemsSource="{Binding Path=listStudent}"  DisplayMemberPath="Name"></ListBox> 
        </Grid>
    </Window>

    其实,我更喜欢最后一个绑定方式,然而我并不知道这个绑定方式和Window.Resources绑定方式究竟有什么内在的区别。

    展开全文
  • WPF-DataContext

    千次阅读 2017-10-24 15:29:53
    看到的最好的关于DataContext的介绍文章

    看到一篇较好的关于WPF DataContext文章,原文虽是英文的,但是用词比较简单,我这种只过了四级的英语渣也能看懂,但是英语毕竟看起来不舒服,就顺手翻译了一遍,希望可以帮到看到的人,文章全文如下:

    你所说的“DataContext” 到底是什么?

    我经常看到一些初学WPF的人十分困惑DataContext到底是个什么东西,到底怎么用。幸运的是,这篇文章可以帮你清晰的了解DataContext,并且学会使用他。

    什么是DataContext?

    在WPF中, 每个应用程序都有两层: UI层和Data层.

    Data层在程序初始化时是null, 你可以通过DataContext属性查看到他.所有的UI对象都会从他们的父级对象继承DataContext属性,除非你特别指定。

    When using the Model-View-ViewModel (MVVM) Design Pattern, the DataContext (Data Layer) is your application, while UI objects, like Buttons, Labels, DataGrids, and even Windows, are all just user-friendly items that allow a user to easily interact with the DataContext, which is your actual application and is typically comprised of ViewModels and Models.

    How is it used

    Whenever you do a basic binding in WPF, you are binding to the DataContext.

    For example, when you write

    < Label Name = "myLabel" Content = "{Binding Path=Name}" />

    you are binding to myLabel.DataContext.Name, and not to myLabel.Name.

    Other binding properties, such as ElementName or RelativeSource, can be used to tell the binding to lookup the property in something other than the current DataContext.

    An Example

    Lets start with a regular Window. Without setting the DataContext, the window still displays but there is no data behind it.

    < Window x:Name = "MyWindow" ...>
        ...
    </ Window >

    Now suppose we set the DataContext to an object of type ClassA in the code-behind when this Window initializes:

    public partial class MyWindow: Window
    {
         public MyWindow()
         {
            InitializeComponent();
            this .DataContext = new ClassA();
         }
    }

    Now the data layer behind that the Window is an object of type ClassA.

    If ClassA has a property called Name, I could add a Label to the window and bind it to Name property of the DataContext, and whatever value is stored in ClassA.Name would get displayed.

    < Window x:Name = "MyWindow" ...>
        < Label Content = "{Binding Name}" />
    </ Window >

    Now, suppose ClassA has a property called ClassB, and both classes have a property called Name. Here is a block of XAML which illustrates how the DataContext works. It also includes an example of how a control would refer to a property not in its own DataContext.

    <!-- DataContext set to ClassA in initialization code -->
    < Window x:Name = "MyWindow" >
     
         <!-- DataContext here is not specified, so it's inherited
              from its parent's DataContext, which is ClassA -->
         < StackPanel >
     
             <!-- DataContext inherited from parent, which is
                  ClassA, so this will display ClassA.Name -->
             < Label Content = "{Binding Name}" />
     
              <!-- DataContext is still ClassA, however we are
                   setting it to ClassA.ClassB with a binding -->
             < StackPanel DataContext = "{Binding ClassB}" >
     
                 <!-- DataContext inherited from parent, which is
                      ClassB, so this will display ClassB.Name -->
                 < Label Content = "{Binding Name}" />
     
                 <!-- DataContext is still ClassB, but we are
                      binding to the Window's DataContext.Name,
                      which is ClassA.Name -->
                 < Label Content="{Binding
                            ElementName = MyWindow ,
                            Path = DataContext .Name}" />
             </ StackPanel >
     
             <!-- We've left the StackPanel with its DataContext
                  bound to ClassB, so this Label's DataContext
                  is ClassA (inherited from parent StackPanel),
                  and we are binding to ClassA.ClassB.Name -->
             < Label Content = "{Binding ClassB.Name}" />
         </ StackPanel >
    </ Window >

    As you can see, all the basic bindings look for their value in the data layer (DataContext) of the UI object

    Summary

    So to summarize, WPF applications have two layers: the UI layer and the Data layer. The data layer for an application starts out as null, and can be set using the DataContext property. UI objects without a DataContext set will inherit their data layer from their parent object. Bindings are used to look up values in the data layer, and display them in the UI layer.

    When using the MVVM design pattern, the data layer is your application, while the UI layer just provides a user-friendly way to access the Data layer.

    展开全文
  • WPF--DataContext

    2020-06-19 20:04:33
    WPF中,应用程序有两层:UI层和Data层。这里新建一个项目说明哪些是UI层,哪些是数据层。 UI层很明显,就是用户看到的界面。但是数据层并不是下图所示: 上图中是UI层view的后台代码。当然,你可以使用事件的方式...

    在WPF中,应用程序有两层:UI层和Data层。这里新建一个项目说明哪些是UI层,哪些是数据层。

    UI层很明显,就是用户看到的界面。但是数据层并不是下图所示:

    上图中是UI层view的后台代码。当然,你可以使用事件的方式把所有的业务逻辑代码写到这里,但是我们采用MVVM的时候业务逻辑是与这里解耦的,数据层是DataContext,此时并没有指定。
    接下来我们新建个目录,然后添加个类文件:

    然后指定VM类为DataContext:

    此时我们才算为MVVM模式的wpf应用程序创建了数据层,也就是MainViewModel类。

    默认,应用程序的数据层(DataContext)是null,我们可以使用DataContext属性对其进行设置。
    除非另行指定,否则所有UI对象都将从其父对象继承其DataContext
    实际上DataContext才算是我们的实际应用程序(业务逻辑),他通常由ViewModels和Models组成。
    UI对象(如按钮,标签,DataGrids甚至Windows)实际作用是允许用户轻松与DataContext交互。
    当你写<Label Name="myLabel" Content="{Binding Path=Name}" />你是绑定到myLabel.DataContext.Name,而不是myLabel.Name。

    <!-- 注意此时我已经在初始化代码中设置DataContext 为 ClassA,DataContext = new ClassA  -->
    <Window x:Name="MyWindow"> 
     
        <!-- DataContext 没有被指定,所以继承自父类
             的 DataContext,也就是 ClassA -->
        <StackPanel> 
     
            <!-- DataContext 继承自父类,也就是 
                 ClassA, 所以这里会显示 ClassA.Name -->
            <Label Content="{Binding Name}" />
     
             <!-- DataContext 仍然是ClassA, 但是我们通过binding设置为ClassA.ClassB-->
            <StackPanel DataContext="{Binding ClassB}">
     
                <!-- DataContext 继承自父类,也就是ClassB,所以这里会显示 ClassB.Name -->
                <Label Content="{Binding Name}" />
     
                <!-- DataContext i仍然是 ClassB, 但是我们binding 到了Window's DataContext.Name, 也就是 ClassA.Name -->
                <Label Content="{Binding 
                           ElementName=MyWindow, 
                           Path=DataContext.Name}" /> 
            </StackPanel>
     
            <!-- We've left the StackPanel with its DataContext 
                 bound to ClassB, so this Label's DataContext 
                 is ClassA (inherited from parent StackPanel), 
                 and we are binding to ClassA.ClassB.Name -->
            <Label Content="{Binding ClassB.Name}" />
        </StackPanel>
    </Window>
    

    所有基本绑定都在UI对象的数据层(DataContext)中寻找它们的值。
    综上所述,WPF应用程序具有两层:UI层和数据层。应用程序的数据层以null开头,可以使用DataContext属性设置。未设置DataContext的UI对象将从其父对象继承其数据层。绑定用于在数据层中查找值,并在UI层中显示它们。
    使用MVVM设计模式时,数据层是您的应用程序,而UI层只是提供了一种用户友好的方式来访问数据层。

    datacontext的绑定

    pis:(直接在XAML上指定根datacontext貌似不行,必须通过代码或者引入资源(此方式还未实践)的方式来指定,后续子元素的datacontext可以通过binding来指定则是可行的,它们的根都是之前设定的根datacontext)
    可以在view的后台代码中手动指定例如在构造函数中:

    var cont = new MainViewModle();
    DataContext = cont;
    

     

    另外也可以写到资源中,首先需要写一个viewmodel类:

    public MainViewModel()
    {
        plusCommand = new PlusCommand(this);
    }
    

     

    然后把vm类放到资源中:

    <!--需要指定名称空间vm:
    xmlns:vm="clr-namespace:SimpleCommandDemoApp.ViewModels"-->
    <UserControl.Resources>
        <vm:CalculatorViewModel x:Key="calculatorVM" />
    </UserControl.Resources>
    

     

    最后就可以在xaml中指定了:

    DataContext="{Binding Source={StaticResource calculatorVM}}"
    

     

    WPF使用DataContext将数据层与UI层实现了解耦,那么他们之间是如何交互的?实际上上面已经略有涉猎,那就是Binding,上面实例的ClassA、ClassB的Name就是通过Binding来展示到UI上的,详细介绍在下一篇文章中再做说明。

    展开全文
  • 按照现在网上关于DataContext的普遍说法,WPF的UI是树状的,每个节点都是控件,所以每个节点都有DataContext属性,如果一个Binding找不到自己的Source那他就会沿着这个UI树一直往上找,直到找到和Path对应的那个属性...
  •  例如下边代码,textBox1绑定textBlock2的Text属性的时候,数据上下文就是Grid或者Grid父容器的DataContext,上下文中能用到就是界面元素的属性。 二、可以在任何时候显式设置上下文,但是设置上下文以后绑定才...
  • WPF ContentControl绑定父元素的DataContext

    千次阅读 2017-12-15 17:31:53
    在一个涉及用户权限显示不同的布局需求中,使用了ContentControl的ContentTemplate,发现DataTemplate中按钮的绑定事件失效,原因是ContentControl的DataContext已经和父元素的DataContext断开,需要手动绑定一下: ...
  • UI元素树的每一个结点都有DataContext,当Binding只知道自己的path ,而不知道source时,会沿着 UI元素树一路的向树根部找过去,路过节点,比较结点的DataContext是否具有Path所指定的属性,有的话,把对应的节点...
  • 给目标DataContext节点一个Name <StackPanel DataContext="{Binding ElementName=mylist, Path=DataContext}"> <Button Command="{Binding DeleteItemCmd}" Content="删
  • 刚刚试了一下数据绑定,几次都没有成功,后来发现是DataContext搞得鬼。 我暂时有两点结论:  1、如果没有显式设置上下文,那么数据上下文就是界面;  例如下边代码,textBox1绑定textBlock2的Text...
  • WPF学习笔记——DataContext 与 ItemSource
  • WPF教程(二)DataContext绑定数据(转)

    千次阅读 2019-05-15 16:34:00
    WPF教程(二)DataContext绑定数据 2018年08月02日 09:34:43yangwenxue1989阅读数:1340 (一)基础知识 DataContext属性是绑定的默认源,除非你具体指定了另外一个源,比如我们使用了...
  • 2、Guide2_1View作为一个多次使用的控件,对应一个LViewModel,设置自己的DataContext(这里的背景是该视图的使用个数确定的。当然也可以用ListBox代替): <view:Guide2_1View DataContext= " {Binding Path=...
  • 假设 page 是在 Frame 里面的 Page ,通过下面的代码是可以拿到 DataContext ,而且假设 Frame 的 DataContext 就是一个定义的类 Foo var frame = page.Parent as Frame; // frame.DataContext == foo 但是如果...
  • 经过一段时间的接触,对WPF有了点更深的理解,随之而来的也是更多的难题。 -2020,3,07 ItemsControl的itemssoure绑定一个数据源后,内部的ItemTemplate里面的控件再使用Binding却无法找到外层DataContext中的数据...
  • wpf——数据绑定DataContext

    千次阅读 2014-07-31 14:51:31
    恩,前几天初学wpf,最难得就是ban
  • WPF教程(三十五)使用DataContext

    万次阅读 多人点赞 2016-11-17 22:56:57
    它由FrameworkElement类定义,大部分UI控件包括WPF窗口都继承于此类。简单地说,它允许你指定一个绑定的基。 DateContext并没有默认源(刚开始的时候是NULL),但是它贯穿整个空间层次结构,你可以为窗口设置一个...
  • wpfDataContext当绑定MainWindow时,会出错:![图片说明](https://img-ask.csdn.net/upload/202002/21/1582260419_673587.png) 但是如果新建一个类的话去绑定就没问题。这是为什么?代码如下: ![图片说明]...
  • 有关WPF中DataGrid控件的基础应用总结

    万次阅读 多人点赞 2018-06-07 19:48:00
    DataGrid是WPF提供的基础控件,它可以非常轻松的呈现出一张表格,本文章会按照从易到难的顺序依次将DataGrid的使用方法进行解说,除了MSDN上给出的最基本的例子之外,给出了三个比较常见的在真实使用场景下使用的...
  • 1、当为ContextMenu指定DataContext时,因为ContextMenu属于弹出层,在VisualTree中与所在的设计视图已经分离,所以无法将DataContext绑定到任何父级元素,即使整个视图已指定了DataContext,也无法设置MenuItem的...
  • 当其父级的数据上下文更改时,ContextMenu的数据上下文不会更新
  • 主要是x:Reference的...不过仔细看代理类发现我们并没有必要手动创建一个类,直接从wpf现有的类型中找一个类似的类即可 <wpf:MapControl x:Name="Root"> <wpf:MapControl.Resources> <DiscreteObj
  • 1、Source指向数据源对象的使用,经常配合Window.Resources使用。 如 < Window.Resources > ..."{Binding ...3、DataContext见上一篇博客: http://blog.csdn.net/niuge8905/article/details/78760872
  • namespace DataContext_ItemSource_Demo { public class Person { public string Name; } public class ViewModel { public MainWindow win; public Person person; ...
  • WPFDataContext

    2014-04-25 18:09:00
    1. 继承属性: DataContext is a property on FrameworkElement (base class for all WPF Controls) and is implemented as a DependencyProperty. DataContext是一个财产上的FrameworkElement的(所有WPF控件的基类...
  • WPF学习笔记:数据绑定与DataContext

    千次阅读 2016-01-16 14:33:00
    http://www.cnblogs.com/ceachy/archive/2012/10/30/Binding_DataContext.html 前一段半心半意地学习了一下WPF,是从控件入手的,发现巨容易,甚至有些无趣。昨天面试,被问到了很多WPF的特性的东西,直接就...
  • 1. 窗体的XAML设置DataContext view 1 <Window x:Class="MVVM_Binding_ViewModelMainWindow" 2 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 3 xmlns:x="http://sche...
  • WPF 自定义控件无法找到DataContext

    千次阅读 2014-08-05 22:32:51
    DataContext="{TemplateBinding DataContext}" HorizontalAlignment="Stretch" Content="{TemplateBinding ContentView}"> DataContext="{TemplateBinding DataContext}" HorizontalAlignment="Stretch" ...
  • 前面两节介绍了通过把CLR对象指定赋值给Binding ....下面我们介绍没有Source的Binding,将DataContext作为Binding的源的方法。 DataContext,顾名思义就是数据上下文,它被定义在FrameworkElement类里
  • 在DataTemplate中访问DataContext

    千次阅读 2018-02-04 14:05:24
    解决:为了访问到datacontext中的命令,我们需要改变命令源,通过指定父级来访问全局的datacontext 代码: ,10,10,10"> ,0,15,0" Width="350px" /> 复制" Command="{Binding ElementName=CommitList,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,597
精华内容 2,638
关键字:

datacontextwpf