GVKun编程网logo

如何设置DataContext绑定？（datecontext）

9

本文的目的是介绍如何设置DataContext绑定？的详细情况，特别关注datecontext的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解如何设置DataCont

本文的目的是介绍如何设置DataContext绑定？的详细情况，特别关注datecontext的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解如何设置DataContext绑定？的机会，同时也不会遗漏关于.net – 在WPF中,如何从包含ListBox的DataTemplate内部数据绑定到Window DataContext？、applicationContext.xml中 和 的区别、asp.net – 将linq连接到sql datacontext到业务层中的httpcontext、asp.net-mvc – DAL – > BLL < - GUI组合根.如何设置DI绑定？的知识。

本文目录一览：

如何设置DataContext绑定？（datecontext）

如何设置DataContext绑定？（datecontext）

我有一个这样设置的DockPanel

<Window ... > <DockPanel x:Name="myDock" DataContext="{Binding HonapokList}" >

在Dockpanel里面有一个TextBox，像这样

<TextBox x:Name="tbCount" Text="{Binding Path=Count,Mode=OneWay}" /> </DockPanel> </Window>

这是我如何设置HonapokList，所以它基本上是一个List String>

public List<String> HonapokList; public MainWindow() { InitializeComponent(); HonapokList = new List<string>(); Honapok.ItemsSource = HonapokList; HonapokList.Add("January"); HonapokList.Add("February"); HonapokList.Add("march"); }

我想我的文本框显示在HonapokList（在这个例子中是3）的元素数量，但是没有任何内容。 这是为什么？

我需要独立的“networking”应用程序的最佳解决scheme

在Python中的特定networking位置打开Windows资源pipe理器

除了PowerShell压缩文件提取

如何直接打印而不显示打印对话框在Windows中使用python脚本？

错误：EPERM：操作不允许

系统托盘上下文菜单不会消失

无法find必要的构build工具。 面对devtools的错误

System.Management.ManagementException：未find

Python 2.7：在Windows控制台中输出utf-8

如何重新使用现有/已打开的Windows资源pipe理器窗口来启动资源pipe理器

Window没有一个默认的DataContext ，但是看起来你假设它被设置为它自己。 您可以将其设置为在构造函数中执行：

DataContext = this;

或者在XAML中：

<Window DataContext="{Binding RelativeSource={RelativeSource Self}}">

您也需要将HonapokList更改为属性，而不是像现在这样的字段，以便与之绑定。

首先你可以绑定Properties而不是fields 。 所以，让HonapokList属性 –

public List<String> HonapokList { get; }

其次，改变你的xaml使用RelativeSource在你的Window类中查找属性 –

<DockPanel x:Name="myDock"> <TextBox x:Name="tbCount" Text="{Binding Path=HonapokList.Count,Mode=OneWay,RelativeSource={RelativeSource Mode=FindAncestor,AncestorType=Window}}"/> </DockPanel>

要么

在你的窗口上设置DataContext

<Window DataContext="{Binding RelativeSource={RelativeSource Self}}">

然后你可以这样做 –

<TextBox x:Name="tbCount" Text="{Binding Path=HonapokList.Count,Mode=OneWay}"/>

总结

以上是小编为你收集整理的如何设置DataContext绑定？全部内容。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。

.net – 在WPF中,如何从包含ListBox的DataTemplate内部数据绑定到Window DataContext？

.net – 在WPF中,如何从包含ListBox的DataTemplate内部数据绑定到Window DataContext？

我有一个 WPF窗口,其视图模型设置为其DataContext,并且具有一个带有DataTemplate的ListBox,其ItemsSource绑定到视图模型,如下例所示：

查看型号：

using System.Collections.Generic;

namespace Example
{
    class Member
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

    class Team
    {
        private List<Member> members = new List<Member>();

        public string TeamName { get; set; }
        public List<Member> Members { get { return members; } }
    }
}

MainWindow.xaml：

<Window x:xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:l="clr-namespace:Example" 
    Title="Example" Height="300" Width="300" Name="Main">

 <Window.DataContext>
  <l:Team TeamName="The best team">
   <l:Team.Members>
    <l:Member Name="John Doe" Age="23"/>
    <l:Member Name="Jane Smith" Age="20"/>
    <l:Member Name="Max Steel" Age="24"/>
   </l:Team.Members>
  </l:Team>
 </Window.DataContext>

 <ListBox ItemsSource="{Binding Path=Members}">
  <ListBox.ItemTemplate>
   <DataTemplate>
    <StackPanel Orientation="Horizontal">
     <TextBlock Text="{Binding Path=TeamName}" Margin="4"/>
     <TextBlock Text="{Binding Path=Name}" Margin="4"/>
    </StackPanel>
   </DataTemplate>
  </ListBox.ItemTemplate>
 </ListBox>
</Window>

当然,TeamBox的TeamName属性不会显示在ListBox项中,因为LisBox的每个项都是List.ItemTemplate的DataContext,它会覆盖Window的DataContext.

问题是：如何从ListBox的DataTemplate中数据绑定到视图模型(Window.DataContext)的TeamName属性？

我将l：Team声明提取到Window.Resources部分,并从DataContext和DataTemplate中引用它： 
<Window x:xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:l="clr-namespace:Example" 
    Title="Example" Height="300" Width="300" Name="Main">

 <Window.Resources>
  <l:Team x:Key="data" TeamName="The best team">
   <l:Team.Members>
    <l:Member Name="John Doe" Age="23"/>
    <l:Member Name="Jane Smith" Age="20"/>
    <l:Member Name="Max Steel" Age="24"/>
   </l:Team.Members>
  </l:Team>
 <Window.Resources>

 <Window.DataContext>
     <StaticResource ResourceKey="data"/>
 </Window.DataContext>

 <ListBox ItemsSource="{Binding Path=Members}">
  <ListBox.ItemTemplate>
   <DataTemplate>
    <StackPanel Orientation="Horizontal">
     <TextBlock Text="{Binding Source={StaticResource data},Path=TeamName}" Margin="4"/>
     <TextBlock Text="{Binding Path=Name}" Margin="4"/>
    </StackPanel>
   </DataTemplate>
  </ListBox.ItemTemplate>
 </ListBox>
</Window>

applicationContext.xml中<context:annotation-config> 和 <context:component-scan>的区别

applicationContext.xml中 和 的区别

Difference between <context:annotation-config> vs <context:component-scan>

<context:annotation-config>是用于激活那些已经在spring容器里注册过的bean（无论是通过xml的方式还是通过package sanning的方式）上面的注解。

<context:component-scan>除了具有<context:annotation-config>的功能之外，<context:component-scan>还可以在指定的package下扫描以及注册javabean。

下面我们通过例子来详细查看他们的区别，

有三个class A,B,C,并且B,C的对象被注入到A中.

package com.xxx;
public class B {
  public B() {
    System.out.println("creating bean B: " + this);
  }
}

package com.xxx;
public class C {
  public C() {
    System.out.println("creating bean C: " + this);
  }
}

package com.yyy;
import com.xxx.B;
import com.xxx.C;
public class A { 
  private B bbb;
  private C ccc;
  public A() {
    System.out.println("creating bean A: " + this);
  }
  public void setBbb(B bbb) {
    System.out.println("setting A.bbb with " + bbb);
    this.bbb = bbb;
  }
  public void setCcc(C ccc) {
    System.out.println("setting A.ccc with " + ccc);
    this.ccc = ccc; 
  }
}

在applicationContext.xml中加入下面的配置 :

<bean id="bBean"class="com.xxx.B"/><bean id="cBean"class="com.xxx.C"/><bean id="aBean"class="com.yyy.A"><property name="bbb" ref="bBean"/><property name="ccc" ref="cBean"/></bean>

加载applicationContext.xml配置文件，将得到下面的结果:

creating bean B: com.xxx.B@c2ff5 creating bean C: com.xxx.C@1e8a1f6 creating bean A: com.yyy.A@1e152c5 setting A.bbb with com.xxx.B@c2ff5 setting A.ccc with com.xxx.C@1e8a1f6

OK,这个结果没什么好说的，就是完全通过xml的方式，不过太过时了，下面通过注解的方式来简化我们的xml配置文件

首先，我们使用autowire的方式将对象bbb和ccc注入到A中：

package com.yyy;
import org.springframework.beans.factory.annotation.Autowired;
import com.xxx.B;
import com.xxx.C;
public class A { 
  private B bbb;
  private C ccc;
  public A() {
    System.out.println("creating bean A: " + this);
  }
  @Autowired
  public void setBbb(B bbb) {
    System.out.println("setting A.bbb with " + bbb);
    this.bbb = bbb;
  }
  @Autowired
  public void setCcc(C ccc) {
    System.out.println("setting A.ccc with " + ccc);
    this.ccc = ccc;
  }
}

然后，我们就可以从applicationContext.xml中移除下面的配置

<property name="bbb" ref="bBean"/><property name="ccc" ref="cBean"/>

移除之后，我们的applicationContext.xml配置文件就简化为下面的样子了

<bean id="bBean"class="com.xxx.B"/><bean id="cBean"class="com.xxx.C"/><bean id="aBean"class="com.yyy.A"/>

当我们加载applicationContext.xml配置文件之后，将得到下面的结果：

creating bean B: com.xxx.B@5e5a50 creating bean C: com.xxx.C@54a328 creating bean A: com.yyy.A@a3d4cf
ottom: 1em; border: 0px; vertical-align: baseline; clear: both; font-family: Arial,结果是错误的的，究竟是因为什么呢？为什么我们的属性没有被注入进去呢？

是因为注解本身并不能够做任何事情，它们只是最基本的组成部分，我们需要能够处理这些注解的处理工具来处理这些注解

这就是<context:annotation-config>所做的事情

我们将applicationContext.xml配置文件作如下修改：

<context:annotation-config /><bean id="bBean"class="com.xxx.B"/><bean id="cBean"class="com.xxx.C"/><bean id="aBean"class="com.yyy.A"/>

creating bean B: com.xxx.B@15663a2 creating bean C: com.xxx.C@cd5f8b creating bean A: com.yyy.A@157aa53 setting A.bbb with com.xxx.B@15663a2 setting A.ccc with com.xxx.C@cd5f8b
ottom: 1em; border: 0px; vertical-align: baseline; clear: both; font-family: Arial,结果正确了

但是如果我们将代码作如下修改：

package com.xxx;
import org.springframework.stereotype.Component;
@Component
public class B {
  public B() {
    System.out.println("creating bean B: " + this);
  }
}

package com.xxx;
import org.springframework.stereotype.Component;
@Component
public class C {
  public C() {
    System.out.println("creating bean C: " + this);
  }
}

package com.yyy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.xxx.B;
import com.xxx.C;
@Component
public class A { 
  private B bbb;
  private C ccc;
  public A() {
    System.out.println("creating bean A: " + this);
  }
  @Autowired
  public void setBbb(B bbb) {
    System.out.println("setting A.bbb with " + bbb);
    this.bbb = bbb;
  }
  @Autowired
  public void setCcc(C ccc) {
    System.out.println("setting A.ccc with " + ccc);
    this.ccc = ccc;
  }
}

applicationContext.xml配置文件修改为：

<context:annotation-config />

当我们加载applicationContext.xml配置文件之后，却没有任何输出，这是为什么呢？

那是因为<context:annotation-config />仅能够在已经在已经注册过的bean上面起作用。对于没有在spring容器中注册的bean，它并不能执行任何操作。

但是不用担心，<context:component-scan>除了具有<context:annotation-config />的功能之外，还具有自动将带有@component,@service,@Repository等注解的对象注册到spring容器中的功能。

<context:component-scan base-package="com.xxx"/>

当我们加载applicationContext.xml的时候，会得到下面的结果：

creating bean B: com.xxx.B@1be0f0a creating bean C: com.xxx.C@80d1ff

这是什么原因呢？

是因为我们仅仅扫描了com.xxx包及其子包的类，而class A是在com.yyy包下，所以就扫描不到了

下面我们在applicationContext.xml中把com.yyy也加入进来：

<context:component-scan basepackage="com.xxx,com.yyy"/><context:component-scan base-package="com.xxx"/> 
然后加载applicationContext.xml就会得到下面的结果：
creating bean B: com.xxx.B@cd5f8b creating bean C: com.xxx.C@15ac3c9 creating bean A: com.yyy.A@ec4a87 setting A.bbb with com.xxx.B@cd5f8b setting A.ccc with com.xxx.C@15ac3c9

哇，结果正确啦 ！

回头看下我们的applicationContext.xml文件，已经简化为：

/><context:component-scan base-package="com.xxx"/>

了。

那如果我们在applicationContext.xml手动加上下面的配置，也就是说既在applicationContext.xml中手动的注册了A的实例对象，同时，通过component-scan去扫描并注册B,C的对象

<context:component-scan base-package="com.xxx"/><bean id="aBean"class="com.yyy.A"/>

结果仍是正确的:

creating bean B: com.xxx.B@157aa53 creating bean C: com.xxx.C@ec4a87 creating bean A: com.yyy.A@1d64c37 setting A.bbb with com.xxx.B@157aa53 setting A.ccc with com.xxx.C@ec4a87

虽然class A并不是通过扫描的方式注册到容器中的 ，但是<context:component-scan>所产生的的处理那些注解的处理器工具，会处理所有绑定到容器上面的bean，不管是通过xml手动注册的还是通过scanning扫描注册的。

那么，如果我们通过下面的方式呢？我们既配置了<context:annotation-config />，又配置了<context:component-scan base-package="com.xxx" />，它们都具有处理在容器中注册的bean里面的注解的功能。会不会出现重复注入的情况呢？

<context:annotation-config /><context:component-scan base-package="com.xxx"/><bean id="aBean"class="com.yyy.A"/>

不用担心，不会出现的：

因为<context:annotation-config />和<context:component-scan>同时存在的时候，前者会被忽略。也就是那些@autowire，@resource等注入注解只会被注入一次

哪怕是你手动的注册了多个处理器，spring仍然只会处理一次：

<context:annotation-config />
<context:component-scan base-package="com.xxx" />
<bean id="aBean"/>
<bean id="bla"/>
<bean id="bla1"/>
<bean id="bla2"/>
<bean id="bla3"/>

结果仍是正确的：

creating bean B: com.xxx.B@157aa53 creating bean C: com.xxx.C@ec4a87 creating bean A: com.yyy.A@25d2b2 setting A.bbb with com.xxx.B@157aa53 setting A.ccc with com.xxx.C@ec4a87

asp.net – 将linq连接到sql datacontext到业务层中的httpcontext

asp.net – 将linq连接到sql datacontext到业务层中的httpcontext

我需要我的 linq to sql datacontext在我的业务/数据层可用,以便我的所有存储库对象都可以访问.但是,由于这是一个Web应用程序,我想根据请求创建并销毁它.我想知道是否有一个可以懒惰创建并将datacontext附加到当前HttpContext的单例类可以工作.我的问题是：当请求结束时,datacontext会自动处理吗？以下是我正在思考的代码.这是否达到了我的目的：拥有一个可以延迟使用的线程安全的datacontext实例,并在请求结束时自动处理？ 
public class SingletonDC
{
    public static northwindDataContext Default
    {
        get
        {
            northwindDataContext defaultInstance = (northwindDataContext)System.Web.HttpContext.Current.Items["datacontext"];
            if (defaultInstance == null)
            {
                defaultInstance = new northwindDataContext();
                System.Web.HttpContext.Current.Items.Add("datacontext",defaultInstance);
            }
            return defaultInstance;
        }
    }
}

解决方法

你想象的是有意义的 – 使用HTTP Request上下文存储东西 – 但是,当请求结束时,存储在当前HttpContext中的一次性对象不会自动神奇地被处理掉.你不得不以某种方式自己解决这个问题.

有一个“结束请求”事件,您可以轻松地挂钩,例如使用您放入Global.asax.cs的代码.在Application_EndRequest()方法中,可以在需要它的列表中的每个对象上手动调用dispose().

一种方法是迭代上下文中的每个项目,测试Idisposable,然后在适当时调用dispose.

protected void Application_EndRequest(Object sender,EventArgs e)
{
    foreach (var key in HttpContext.Current.Items.Keys) 
    {
        var disposable = HttpContext.Current.Items[key] as Idisposable;
        if (disposable != null)
        { 
           disposable.dispose();
           HttpContext.Current.Items[key] = null; 
        } 
    }
}

我认为应该这样做. ASPNET不会自动为您执行此操作.当然,在真实应用程序中使用此代码之前,您需要保护免受异常等的影响.

Vertigo的Keith Craig写了a relevant post on the topic a while ago,描述了你想要做什么作为一种模式,换句话说,一种做一些应该重复的事情.他提供了一个类来帮助解决这个问题,延迟加载DB上下文并将其放入当前上下文中.这种方法存在一些缺陷 – 您可以在该帖子的评论讨论中阅读它们.评论中还引用了一堆相关文章.

asp.net-mvc – DAL – > BLL < - GUI组合根.如何设置DI绑定？

asp.net-mvc – DAL – > BLL < - GUI组合根.如何设置DI绑定？

我已经制作了一个三层应用程序,如 answer所述： 
DAL with Repositories -> BLL with services and IRepository <- Asp.net mvc-app

为了让这个运行依赖注入我看到几个选项：
1.从Web应用程序添加对DAL的引用,以便在应用程序启动时设置绑定.
2.使用带有xml配置的容器
(3.使用反射来加载dal-assembly和查找类型)

选项1.很容易,也可以将DAL.dll复制到bin,但是我突然重新引用了我很努力工作的引用.现在可以直接访问存储库.选项2和3似乎不必要的复杂.

有没有别的办法？

解决方法

将ASP.NET MVC应用程序分为两个：

>一部分是你原来的ASP.NET MVC应用程序,但没有任何逻辑.只需保留组合根和您的Views(.aspx等)在这个项目中.由于这是组合根,您可以引用所有其他项目.然而,由于所有的逻辑都将被提取出来,所以现在是一个Humble Object,所以可以在这个层面上提供所有的参考.
>将所有逻辑(控制器等)解压缩到一个应用程序模型项目中,该项目只是一个引用ASP.NET MVC二进制文件的普通库项目(.dll).这个项目需要参考BLL来获取接口,但是没关系.然而,应用程序模型和BLL都有效地与DAL屏蔽.

最终的分层将如下所示：

> ASP.NET MVC应用程序>应用模型> BLL> DAL

今天关于如何设置DataContext绑定？和datecontext的讲解已经结束，谢谢您的阅读，如果想了解更多关于.net – 在WPF中,如何从包含ListBox的DataTemplate内部数据绑定到Window DataContext？、applicationContext.xml中 和 的区别、asp.net – 将linq连接到sql datacontext到业务层中的httpcontext、asp.net-mvc – DAL – > BLL < - GUI组合根.如何设置DI绑定？的相关知识，请在本站搜索。

本文标签：

上一篇Dstat某个特定进程的CPU使用情况（top 特定进程）

下一篇服装批发推销技巧（服装批发推销技巧和话术）

相关文章