blocks|key|3608846|text|我总是使用x:Name变量。我不知道这是否会影响性能，我只是发现它更容易，原因如下。如果您自己的用户控件驻留在另一个程序集中，那么"Name“属性并不总是足够的。这使得只粘贴x:Name属性变得更容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3608847|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I always use the x:Name variant.
I have no idea if this affects any performance, I just find it easier for the following reason.
If you have your own usercontrols that reside in another assembly just the "Name" property won't always suffice. This makes it easier to just stick too the x:Name property.

blocks|key|3608909|text|它们都是一回事，很多框架元素本身都公开了name属性，但对于那些没有公开name属性的元素，你可以使用x:name+-我通常只使用x:name，因为它适用于所有东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3608910|控件可以将自己的name公开为依赖属性(因为它们需要在内部使用该依赖属性)，也可以选择不这样做。|3608911|有关更多详细信息，请参阅msdn+here和here|offset|length|3608912|3608913|某些WPF框架级别的应用程序可能能够避免使用x:Name属性，因为在WPF命名空间中为几个重要基类(如FrameworkElement/FrameworkContentElement+)指定的Name+dependency属性可以满足同样的目的。在一些常见的XAML和框架方案中，需要对没有Name属性的元素进行代码访问，最明显的是在某些动画和情节提要支持类中。例如，如果您打算从代码中引用在XAML中创建的时间轴和转换，则应该在它们上指定x:Name。|blockquote|3608914|3608915|如果Name可用作类的属性，则Name和x:Name可以互换用作属性，但如果在同一元素上指定两者，则会导致错误。|3608916|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms752290.aspx|1|http://msdn.microsoft.com/en-us/library/system.windows.frameworkelement.name.aspx^0|0|0|H|4|0|M|4|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$F|11|G|12|1|13]|$F|14|G|15|1|16]]|A|$]]|$1|H|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|18|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

They're both the same thing, a lot of framework elements expose a name property themselves, but for those that don't you can use x:name - I usually just stick with x:name because it works for everything.

Controls can expose name themselves as a Dependency Property if they want to (because they need to use that Dependency Property internally), or they can choose not to. 

More details in msdn <a href="http://msdn.microsoft.com/en-us/library/ms752290.aspx" rel="noreferrer">here</a> and <a href="http://msdn.microsoft.com/en-us/library/system.windows.frameworkelement.name.aspx" rel="noreferrer">here</a>:

<blockquote>
 Some WPF framework-level applications
 might be able to avoid any use of the
 x:Name attribute, because the Name
 dependency property as specified
 within the WPF namespace for several
 of the important base classes such as
 FrameworkElement/FrameworkContentElement
 satisfies this same purpose. There are
 still some common XAML and framework
 scenarios where code access to an
 element with no Name property is
 necessary, most notably in certain
 animation and storyboard support
 classes. For instance, you should
 specify x:Name on timelines and
 transforms created in XAML, if you
 intend to reference them from code.
 
 If Name is available as a property on
 the class, Name and x:Name can be used
 interchangeably as attributes, but an
 error will result if both are
 specified on the same element.
</blockquote>

blocks|key|3608967|text|x:Name和Name引用了不同的名称空间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3608968|Xaml+x:name是对默认情况下在文件顶部定义的x名称空间的引用。|offset|length|style|BOLD|3608969|xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"|code-block|syntax|javascript|3608970|只是说Name使用默认的下面的名称空间。|3608971|xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"|3608972|x:Name是说使用具有x别名的命名空间。X是默认值，大多数人都会保留它，但您可以将其更改为您喜欢的任何值|3608973|xmlns:foo="http://schemas.microsoft.com/winfx/2006/xaml"|3608974|因此，您的引用应该是foo:name|3608975|Define+and+Use+Namespaces+in+WPF|3608976|3608977|好的，让我们以不同的方式来看待这个问题。假设您将一个按钮拖放到Xaml页面上。你可以通过两种方式来引用它：和name。所有xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation“和+xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml”都是对多个名称空间的引用。由于presentation持有FrameworkElement，xaml持有控件名称空间(而不是100%25+)，因此按钮类具有如下继承模式：|3608978|Button+:+ButtonBase
ButtonBase+:+ContentControl,+ICommandSource
ContentControl+:+Control,+IAddChild
Control+:+FrameworkElement
FrameworkElement+:+UIElement,+IFrameworkInputElement,+
++++++++++++++++++++IInputElement,+ISupportInitialize,+IHaveResources|3608979|因此，正如人们所期望的那样，从FrameworkElement继承的任何东西都可以访问它的所有公共属性。因此，在Button的情况下，它从FrameworkElement获取其名称属性，位于层次结构树的最顶端。所以你可以说x：或Name，它们都将从FrameworkElement访问getter/setter。|3608980|MSDN+Reference|3608981|WPF定义了一个由XAML处理器使用的CLR属性，以便将多个CLR命名空间映射到单个XML命名空间。在生成程序集的源代码中，XmlnsDefinitionAttribute属性放置在程序集级。WPF程序集源代码使用此属性将各种常用命名空间(如System.Windows和System.Windows.Controls+)映射到http://schemas.microsoft.com/winfx/2006/xaml/presentation命名空间。|3608982|因此，程序集属性将如下所示：|3608983|PresentationFramework.dll+-+XmlnsDefinitionAttribute：|3608984|[assembly:+XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation",+"System.Windows")]

[assembly:+XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation",+"System.Windows.Data")]

[assembly:+XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation",+"System.Windows.Navigation")]

[assembly:+XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation",+"System.Windows.Shapes")]

[assembly:+XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation",+"System.Windows.Documents")]

[assembly:+XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation",+"System.Windows.Controls")]++|3608985|entityMap|0|LINK|mutability|MUTABLE|url|http://windowsclient.net/learn/video.aspx?v=31429|1|http://schemas.microsoft.com/winfx/2006/xaml/presentation|2|http://schemas.microsoft.com/winfx/2006/xaml|3|http://msdn.microsoft.com/en-us/library/ms747086.aspx|4^0|0|J|G|0|0|0|K|0|0|0|1H|0|0|0|I|0|0|W|0|W|0|0|0|0|7D|1W|1L|1|3T|18|2|0|0|0|4C|0|0|E|0|E|3|0|0|6A|4K|1L|4|0|0|E|0|0|1H|0|0^^$0|@$1|2|3|4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1V|8|@$D|1W|E|1X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1Z|8|@$D|20|E|21|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|22|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|23|8|@$D|24|E|25|F|G]]|9|@]|A|$]]|$1|S|3|T|5|J|7|26|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|27|8|@$D|28|E|29|F|G]]|9|@]|A|$]]|$1|W|3|X|5|6|7|2A|8|@$D|2B|E|2C|F|G]]|9|@$D|2D|E|2E|1|2F]]|A|$]]|$1|Y|3|-4|5|6|7|2G|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2H|8|@$D|2I|E|2J|F|G]]|9|@$D|2K|E|2L|1|2M]|$D|2N|E|2O|1|2P]]|A|$]]|$1|11|3|12|5|J|7|2Q|8|@]|9|@]|A|$K|L]]|$1|13|3|14|5|6|7|2R|8|@$D|2S|E|2T|F|G]]|9|@]|A|$]]|$1|15|3|16|5|6|7|2U|8|@$D|2V|E|2W|F|G]]|9|@$D|2X|E|2Y|1|2Z]]|A|$]]|$1|17|3|18|5|6|7|30|8|@$D|31|E|32|F|G]]|9|@$D|33|E|34|1|35]]|A|$]]|$1|19|3|1A|5|6|7|36|8|@$D|37|E|38|F|G]]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|39|8|@$D|3A|E|3B|F|G]]|9|@]|A|$]]|$1|1D|3|1E|5|J|7|3C|8|@]|9|@]|A|$K|L]]|$1|1F|3|-4|5|6|7|3D|8|@]|9|@]|A|$]]]|1G|$1H|$5|1I|1J|1K|A|$1L|1M]]|1N|$5|1I|1J|1K|A|$1L|1O]]|1P|$5|1I|1J|1K|A|$1L|1Q]]|1R|$5|1I|1J|1K|A|$1L|1S]]|1T|$5|1I|1J|1K|A|$1L|1O]]]]

x:Name and Name are referencing different namespaces. 

x:name is a reference to the x namespace defined by default at the top of the Xaml file.

<pre><code>xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
</code></pre>

Just saying Name uses the default below namespace. 

<pre><code>xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
</code></pre>

x:Name is saying use the namespace that has the x alias. x is the default and most people leave it but you can change it to whatever you like

<pre><code>xmlns:foo="http://schemas.microsoft.com/winfx/2006/xaml"
</code></pre>

so your reference would be foo:name

<a href="http://windowsclient.net/learn/video.aspx?v=31429" rel="noreferrer">Define and Use Namespaces in WPF</a>

<hr>

OK lets look at this a different way. Say you drag and drop an button onto your Xaml page. You can reference this 2 ways x:name and name. All xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" and
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" are is references to multiple namespaces. Since xaml holds the Control namespace(not 100% on that) and presentation holds the FrameworkElement AND the Button class has a inheritance pattern of: 

<pre><code>Button : ButtonBase
ButtonBase : ContentControl, ICommandSource
ContentControl : Control, IAddChild
Control : FrameworkElement
FrameworkElement : UIElement, IFrameworkInputElement, 
 IInputElement, ISupportInitialize, IHaveResources
</code></pre>

So as one would expect anything that inherits from FrameworkElement would have access to all its public attributes. so in the case of Button it is getting its Name attribute from FrameworkElement, at the very top of the hierarchy tree. So you can say x:Name or Name and they will both be accessing the getter/setter from the FrameworkElement. 

<a href="http://msdn.microsoft.com/en-us/library/ms747086.aspx" rel="noreferrer">MSDN Reference</a>

WPF defines a CLR attribute that is consumed by XAML processors in order to map multiple CLR namespaces to a single XML namespace. The XmlnsDefinitionAttribute attribute is placed at the assembly level in the source code that produces the assembly. The WPF assembly source code uses this attribute to map the various common namespaces, such as System.Windows and System.Windows.Controls, to the <a href="http://schemas.microsoft.com/winfx/2006/xaml/presentation" rel="noreferrer">http://schemas.microsoft.com/winfx/2006/xaml/presentation</a> namespace.

So the assembly attributes will look something like:

PresentationFramework.dll - XmlnsDefinitionAttribute:

<pre><code>[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "System.Windows")]

[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "System.Windows.Data")]

[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "System.Windows.Navigation")]

[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "System.Windows.Shapes")]

[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "System.Windows.Documents")]

[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "System.Windows.Controls")] 
</code></pre>

blocks|key|390914|text|它不是一个WPF项，而是一个标准的XML项，BtBh已经正确地回答了这个问题，x指的是默认名称空间。在XML中，如果没有为元素/属性加上名称空间前缀，它会假定您需要缺省名称空间。因此，对于x:Name来说，只输入Name只不过是一种速记。有关XML名称空间的更多详细信息，请参阅link+text|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|390915|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/6088/btbh|1|http://www.w3schools.com/XML/xml_namespaces.asp^0|2M|6|2Y|4|M|4|0|3V|9|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]|$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

It's not a WPF item but a standard XML one and <a href="https://stackoverflow.com/users/6088/btbh">BtBh</a> has correctly answered it, x refers to the default namespace. In XML when you do not prefix an element/attribute with a namespace it assumes you want the default namespace.
So typing just <code>Name</code> is nothing more than a short hand for <code>x:Name</code>. More details on XML namespaces can be found at <a href="http://www.w3schools.com/XML/xml_namespaces.asp" rel="nofollow noreferrer">link text</a>

blocks|key|3609067|text|在XAML中只有一个名字，那就是x:Name。框架(如WPF+)可以有选择地将其属性之一映射到XAML的x:Name，方法是在类上使用RuntimeNamePropertyAttribute，该类将一个类属性指定为映射到XAML的x:Name属性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3609068|这样做的原因是为了允许框架在运行时已经有了“名称”的概念，比如WPF。例如，在WPF中，FrameworkElement引入了Name属性。|3609069|通常，类不需要存储x:Name的名称即可使用。对于XAML，所有的x:Name手段都是生成一个字段来存储代码背后的类中的值。运行时对该映射执行的操作依赖于框架。|3609070|那么，为什么有两种方法可以做同样的事情呢？答案很简单，因为有两个概念映射到一个属性上。WPF希望在运行时保留元素的名称(可通过绑定等方式使用)，而XAML需要知道您希望哪些元素可由类后台代码中的字段访问。WPF通过将Name属性标记为x:Name的别名将这两者联系在一起。|3609071|将来，XAML将对x:Name有更多的用途，比如允许您通过按名称引用其他对象来设置属性，但在3.5及更早版本中，它仅用于创建字段。|3609072|你是否应该使用其中之一，实际上是一个风格问题，而不是一个技术问题。我将把这个问题留给其他人来推荐。|3609073|另请参阅AutomationProperties.Name+VS+x:Name，AutomationProperties.Name由辅助工具和一些测试工具使用。|3609074|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/4605777/automationproperties-name-vs-xname^0|G|6|1G|6|1V|S|0|18|G|0|9|6|X|6|0|0|0|0|4|Z|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1E|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1F|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1G|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1H|8|@]|D|@$9|1I|A|1J|1|1K]]|E|$]]|$1|R|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|S|$T|$5|U|V|W|E|$X|Y]]]]

There really is only one name in XAML, the <code>x:Name</code>. A framework, such as WPF, can optionally map one of its properties to XAML's <code>x:Name</code> by using the <code>RuntimeNamePropertyAttribute</code> on the class that designates one of the classes properties as mapping to the x:Name attribute of XAML.

The reason this was done was to allow for frameworks that already have a concept of "Name" at runtime, such as WPF. In WPF, for example, <code>FrameworkElement</code> introduces a Name property.

In general, a class does not need to store the name for <code>x:Name</code> to be useable. All <code>x:Name</code> means to XAML is generate a field to store the value in the code behind class. What the runtime does with that mapping is framework dependent.

So, why are there two ways to do the same thing? The simple answer is because there are two concepts mapped onto one property. WPF wants the name of an element preserved at runtime (which is usable through Bind, among other things) and XAML needs to know what elements you want to be accessible by fields in the code behind class. WPF ties these two together by marking the Name property as an alias of x:Name.

In the future, XAML will have more uses for x:Name, such as allowing you to set properties by referring to other objects by name, but in 3.5 and prior, it is only used to create fields.

Whether you should use one or the other is really a style question, not a technical one. I will leave that to others for a recommendation.

See also <a href="https://stackoverflow.com/questions/4605777/automationproperties-name-vs-xname">AutomationProperties.Name VS x:Name</a>, AutomationProperties.Name is used by accessibility tools and some testing tools.

blocks|key|3609111|text|它们不是一回事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3609112|x:Name是一个xaml概念，主要用于引用元素。当您为元素赋予x:Name+xaml属性时，“指定的x:Name将成为处理xaml时在底层代码中创建的字段的名称，该字段包含对对象的引用。”(MSDN)因此，它是设计器生成的字段，默认情况下具有内部访问权限。|offset|length|style|CODE|3609113|Name是FrameworkElement的现有字符串属性，与任何其他wpf元素属性一样以xaml属性的形式列出。|3609114|因此，这也意味着x:Name可以在更广泛的对象上使用。这是一种使xaml中的任何内容都能被给定名称引用的技术。|3609115|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/framework/xaml-services/x-name-directive^0|0|0|6|1F|6|2O|4|0|0|0|4|5|G|0|8|6|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@$D|13|E|14|F|G]|$D|15|E|16|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@$D|18|E|19|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

They are not the same thing.

<code>x:Name</code> is a xaml concept, used mainly to reference elements. When you give an element the x:Name xaml attribute, "the specified <code>x:Name</code> becomes the name of a field that is created in the underlying code when xaml is processed, and that field holds a reference to the object." (<a href="https://docs.microsoft.com/en-us/dotnet/framework/xaml-services/x-name-directive" rel="noreferrer">MSDN</a>) So, it's a designer-generated field, which has internal access by default.

<code>Name</code> is the existing string property of a <code>FrameworkElement</code>, listed as any other wpf element property in the form of a xaml attribute.

As a consequence, this also means <code>x:Name</code> can be used on a wider range of objects. This is a technique to enable anything in xaml to be referenced by a given name.

blocks|key|3609134|text|X:Name可能会导致内存问题，如果您有自定义控件。它将为NameScope条目保留一个内存位置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3609135|我建议除非迫不得已，否则永远不要使用x:Name。|3609136|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

X:Name can cause memory issues if you have custom controls. It will keep a memory location for the NameScope entry. 

I say never use x:Name unless you have to.

blocks|key|1058485|text|唯一的区别是，如果你使用用户控件到来自同一程序集的控件中，那么Name将不能识别你的控件，并且你会得到一个错误“Use+x:Name+for+Controls+in+The+Same+Assembly”。So+x:Name是WPF中命名控件的WPF版本控制。Name仅用作Winform+Legacy。他们希望在WPF和winforms中区分控件的命名，因为他们使用Xaml中的属性来标识控件与其他程序集，他们使用x:作为控件的名称。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1058486|请记住，不要仅仅为了保留控件的名称而给它命名，因为它作为空白驻留在内存中，它会给你一个警告，说明名称已经应用于控件，但它从未使用过。|1058487|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The only difference is that if you are using user Controls into a control from Same Assembly then Name will not identify your control and you will get an error " Use x:Name for controls in the same Assembly". 
So x:Name is the WPF versioning of naming controls in WPF. Name is just used as a Winform Legacy. They wanted to differentiate the naming of controls in WPF and winforms as they use attributes in Xaml to identify controls from other assemblies they used x: for Names of control. 

Just keep in mind dont put a name for a control just for the sake of keeping it as it resides in memory as a blank and it will give you a warning that Name has been applied for a control buts its never used.

blocks|key|1063007|text|名称|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1063008|1063009|只能用于从代码隐藏通过SetValue()和property-like.|ordered-list-item|1063010|设置的SetValue和FrameworkContentElement;|1063011|can的子代|unordered-list-item|1063012|1063013|x:Name|1063014|1063015|可用于几乎所有的XAML+elements;|1063016|can不能通过SetValue()从代码隐藏设置；它只能使用对象上的属性语法设置，因为它是一个指令。|1063017|1063018|在XAML中为一个FrameworkElement或FrameworkContentElement使用这两个指令将导致异常:如果XAML是标记编译的，则异常将在标记编译时发生，否则将在加载时发生。|1063019|entityMap^0|0|2|0|0|0|0|0|0|0|6|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|15|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|16|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|17|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|18|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]|$1|S|3|T|5|I|7|1D|8|@]|D|@]|E|$]]|$1|U|3|V|5|I|7|1E|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|1G|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|10|$]]

Name:

<ol>
<li>can be used only for descendants of FrameworkElement and FrameworkContentElement;</li>
<li>can be set from code-behind via SetValue() and property-like.</li>
</ol>

x:Name:

<ol>
<li>can be used for almost all XAML elements;</li>
<li>can NOT be set from
code-behind via SetValue(); it can only be set using attribute
syntax on objects because it is a directive.</li>
</ol>

Using both directives in XAML for one FrameworkElement or FrameworkContentElement will cause an exception: if the XAML is markup compiled, the exception will occur on the markup compile, otherwise it occurs on load.

blocks|key|391583|text|其中一个答案是x:name将在不同的编程语言中使用，例如c#，而name将用于框架。老实说，这就是我听起来的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|391584|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

One of the answers is that x:name is to be used inside different program languages such as c# and name is to be used for the framework. Honestly that is what it sounds like to me.

blocks|key|4456272|text|x:Name的意思是:在后台代码中创建一个字段来保存对此对象的引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4456273|Name表示:设置此对象的name属性。|4456274|entityMap^0|0|6|0|0|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

<code>x:Name</code> means: create a field in the code behind to hold a reference to this object.

<code>Name</code> means: set the name property of this object.

blocks|key|1058571|text|指定的x：将成为处理XAML时在基础代码中创建的字段的名称，该字段包含对对象的引用。在Silverlight中，使用托管API，创建此字段的过程由MSBuild目标步骤执行，这些步骤还负责联接XAML文件的分部类及其代码隐藏。此行为不一定是XAML语言指定的；它是Silverlight在其编程和应用程序模型中使用x:Name的特定实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1058572|1058573|entityMap^0|3|2|4D|6|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@$9|J|A|K|B|C]|$9|L|A|M|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|N|8|@]|D|@]|E|$]]|$1|G|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|H|$]]

The specified x:Name becomes the name of a field that is created in the underlying code when XAML is processed, and that field holds a reference to the object. In Silverlight, using the managed API, the process of creating this field is performed by the MSBuild target steps, which also are responsible for joining the partial classes for a XAML file and its code-behind. This behavior is not necessarily XAML-language specified; it is the particular implementation that Silverlight applies to use x:Name in its programming and application models.

<a href="https://msdn.microsoft.com/en-us/library/cc189028(VS.95).aspx" rel="nofollow">Read More on MSDN...</a>

blocks|key|1058616|text|在XAML中声明Button元素时，您引用的是在windows运行时中定义的一个名为Button的类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1058617|按钮有许多属性，如背景、文本、边距、.....以及一个名为Name的属性。|1058618|现在，当您在XAML中声明一个Button时，就像创建一个恰好有一个名为Name的属性的匿名对象。|1058619|一般而言，您不能引用匿名对象，但在WPF框架中，XAML处理器使您能够通过为Name属性指定的任何值来引用该对象。|1058620|到目前一切尚好。|1058621|创建对象的另一种方法是创建命名对象而不是匿名对象。在本例中，XAML名称空间有一个名为Name的对象的属性(由于它在XAML名称空间中，因此可以使用X:)，您可以设置该属性，以便标识对象并引用它。|1058622|结论：|1058623|Name是一个特定对象的属性，但X:Name是该对象的一个属性(有一个定义通用对象的类)。|1058624|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|Q|$]]

When you declare a Button element in XAML you are referring to a class defined in windows run time called Button.

Button has many attribute such as background, text, margin, ..... and an attribute called Name.

Now when you declare a Button in XAML is like creating an anonymous object that happened to have an attribute called Name.

In general you can not refer to an anonymous object, but in WPF framework XAML processor enables you to refer to that object by whatever value you have given to Name attribute.

So far so good.

Another way to create an object is create a named object instead of anonymous object. In this case XAML namespace has an attribute for an object called Name (and since it is in XAML name space thus have X:) that you may set so you can identify your object and refer to it.

Conclusion:

Name is an attribute of a specific object, but X:Name is one attribute of that object (there is a class that defines a general object).

blocks|key|1058690|text|也可以使用带有内部文本的属性元素语法来设置Name，但这种情况并不常见。相反，x:Name不能在XAML属性元素语法中设置，也不能在使用SetValue的代码中设置；它只能使用对象上的属性语法设置，因为它是指令。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|1058691|如果Name作为类的属性可用，则Name和x:Name可以互换用作属性，但如果在同一元素上指定这两个属性，则会导致解析异常。如果XAML是标记编译的，则异常将在标记编译时发生，否则将在加载时发生。|1058692|entityMap^0|L|4|13|6|1C|4|1W|8|2V|2|0|2|4|G|4|L|6|0^^$0|@$1|2|3|4|5|6|7|K|8|@$9|L|A|M|B|C]|$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|E|@]|F|$]]|$1|I|3|-4|5|6|7|12|8|@]|E|@]|F|$]]]|J|$]]

<code>Name</code> can also be set using property element syntax with inner text, but that is uncommon. In contrast, <code>x:Name</code> cannot be set in <code>XAML</code> property element syntax, or in code using <code>SetValue</code>; it can only be set using attribute syntax on objects because it is a directive.
 
If <code>Name</code> is available as a property on the class, <code>Name</code> and <code>x:Name</code> can be used interchangeably as attributes, but a parse exception will result if both are specified on the same element. If the XAML is markup compiled, the exception will occur on the markup compile, otherwise it occurs on load.

Sometimes it seems that the <code>Name</code> and <code>x:Name</code> attributes are interchangeable.
So, what are the definitive differences between them, and when is it preferable to use one over the other?
Are there any performance or memory implications to using them the wrong way?

In WPF, what are the differences between the x:Name and Name attributes?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

有时，Name和x:Name属性似乎是可以互换的。那么，它们之间的明确区别是什么，什么时候使用一种比另一种更可取？以错误的方式使用它们是否会对性能或内存产生影响？

问在WPF中，x:Name和Name属性有什么不同？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在WPF中，x:Name和Name属性有什么不同？EN