В названии говорится все. Иногда кажется, что атрибуты Name и x:Name являются взаимозаменяемыми.
Итак, каковы окончательные различия между ними, и когда предпочтительнее использовать один над другим?
Имеются ли какие-либо последствия для производительности или памяти для их неправильного использования?
В XAML есть только одно имя x:Name. Структура, такая как WPF, может при необходимости сопоставить один из ее свойств с XAML x:Name, используя RuntimeNamePropertyAttribute в классе, который обозначает одно из свойств классов как отображение атрибута x: Name XAML.
Причина этого заключалась в том, чтобы позволить фреймворкам, которые уже имеют концепцию "Имя" во время выполнения, например WPF. Например, в WPF FrameworkElement вводит свойство Name.
В общем, классу не нужно сохранять имя для x:Name которое можно использовать. Все x:Name означает, что XAML генерирует поле для хранения значения в коде за классом. То, что среда выполнения делает с этим сопоставлением, зависит от структуры.
Итак, почему есть два способа сделать одно и то же? Простой ответ заключается в том, что на одно свойство отображаются два понятия. WPF хочет, чтобы имя элемента сохранялось во время выполнения (которое можно использовать через Bind, между прочим), и XAML должен знать, какие элементы вы хотите получить по полям в классе за классом. WPF связывает эти два вместе, отмечая свойство Name как псевдоним x: Name.
В будущем XAML будет иметь больше применений для x: Name, например, позволяя вам устанавливать свойства, ссылаясь на другие объекты по имени, но в 3.5 и ранее он используется только для создания полей.
Следует ли вам использовать тот или иной вопрос, это вопрос стиля, а не технический. Я оставлю это другим для рекомендации.
См. Также AutomationProperties.Name VS x: Name, AutomationProperties.Name используется средствами доступности и некоторыми инструментами тестирования.
Они не одно и то же.
x:Name - это концепция xaml, используемая в основном для ссылки на элементы. Когда вы даете элементу атрибут x: Name xaml, "указанное x:Name становится именем поля, которое создается в базовом коде при обработке xaml, и это поле содержит ссылку на объект". (MSDN) Итак, это сгенерированное дизайнером поле, которое по умолчанию имеет внутренний доступ.
Name - это существующее строковое свойство FrameworkElement, которое отображается как любое другое свойство элемента wpf в форме атрибута xaml.
Как следствие, это также означает, что x:Name может использоваться для более широкого диапазона объектов. Это техника, позволяющая ссылаться на что-либо в xaml по заданному имени.
x: Имя и имя ссылаются на разные пространства имен.
x: name - это ссылка на пространство имен x, определенное по умолчанию в верхней части файла Xaml.
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Просто говоря, что имя использует пространство имен по умолчанию ниже.
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
x: Имя говорит, что используется пространство имен с псевдонимом x. x по умолчанию, и большинство людей оставляют его, но вы можете изменить его на все, что вам нравится
xmlns:foo="http://schemas.microsoft.com/winfx/2006/xaml"
поэтому ваша ссылка будет foo: name
Определение и использование пространств имен в WPF
OK давайте посмотрим на это по-другому. Скажем, вы перетащите кнопку на свою страницу Xaml. Вы можете ссылаться на это два способа : имя и имя. Все xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" и xmlns: x = "http://schemas.microsoft.com/winfx/2006/xaml" являются ссылками на несколько пространств имен, Поскольку xaml содержит пространство имен Control (не 100% на нем), а представление содержит FrameworkElement, а класс Button имеет шаблон наследования:
Button : ButtonBase
ButtonBase : ContentControl, ICommandSource
ContentControl : Control, IAddChild
Control : FrameworkElement
FrameworkElement : UIElement, IFrameworkInputElement,
IInputElement, ISupportInitialize, IHaveResources
Так как можно было бы ожидать, что все, что наследует от FrameworkElement, будет иметь доступ ко всем его публичным атрибутам. поэтому в случае Button он получает свой атрибут Name из FrameworkElement, на самой вершине дерева иерархии. Таким образом, вы можете сказать x: имя или имя, и оба они будут обращаться к получателю/сеттеру из элемента FrameworkElement.
WPF определяет атрибут CLR, который потребляется процессорами XAML, чтобы сопоставить несколько пространств имен CLR с одним пространством имен XML. Атрибут XmlnsDefinitionAttribute помещается на уровне сборки в исходном коде, который создает сборку. Исходный код сборки WPF использует этот атрибут для сопоставления различных общих пространств имен, таких как System.Windows и System.Windows.Controls, с пространством имен http://schemas.microsoft.com/winfx/2006/xaml/presentation.
Таким образом, атрибуты сборки будут выглядеть примерно так:
PresentationFramework.dll - XmlnsDefinitionAttribute:
[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")]
Они оба одинаковы, многие элементы фреймворка сами выставляют свойство имени, но для тех, кому вы не можете использовать x: name - я обычно просто придерживаюсь x: name, потому что он работает на все.
Элементы управления могут выставлять имя как свойство зависимости, если они хотят (потому что они должны использовать это свойство зависимостей внутри), или они могут отказаться.
Подробнее в msdn здесь и здесь:
Некоторые приложения на уровне Framework WPF могут быть в состоянии избежать использования атрибута x: Name, поскольку свойство зависимостей Name, указанное в пространстве имен WPF для нескольких важных базовых классов, таких как FrameworkElement/FrameworkContentElement, удовлетворяет этой же цели. Есть еще некоторые распространенные сценарии XAML и framework, где необходим доступ к коду элемента без свойства Name, особенно в определенных классах поддержки анимации и раскадровки. Например, вы должны указать x: Name на временных шкалах и преобразованиях, созданных в XAML, если вы собираетесь ссылаться на них из кода.
Если имя доступно как свойство класса, имя и x: Name могут быть взаимозаменяемы в качестве атрибутов, но будет возникать ошибка, если оба они указаны в одном элементе.
X: Имя может вызвать проблемы с памятью, если у вас есть настраиваемые элементы управления. Он сохранит ячейку памяти для записи NameScope.
Я говорю, никогда не используйте x: Name, если вам не нужно.
Единственное отличие состоит в том, что если вы используете пользовательские элементы управления в элементе управления из той же сборки, то Name не будет идентифицировать ваш элемент управления, и вы получите сообщение об ошибке "Используйте x: имя для элементов управления в той же сборке". Итак, x: Name - это управление версиями элементов управления именами WPF в WPF. Имя используется как наследие Winform. Они хотели различать имена элементов управления в WPF и winforms, поскольку они используют атрибуты в Xaml для идентификации элементов управления из других сборок, которые они использовали x: для имен управления.
Просто имейте в виду, не помещайте имя для элемента управления только ради сохранения его, поскольку оно находится в памяти как пустое, и оно даст вам предупреждение о том, что имя было применено для элемента управления, но оно никогда не использовалось.
Имя
х: Name
Использование обеих директив в XAML для одного элемента FrameworkElement или FrameworkContentElement вызовет исключение: если XAML скомпилирован с разметкой, исключение произойдет при компиляции разметки, иначе это произойдет при загрузке.
x:Name означает: создать поле в коде позади, чтобы сохранить ссылку на этот объект.
Name означает: задайте свойство name этого объекта.
Я всегда использую вариант x: Name. Я понятия не имею, влияет ли это на какую-либо производительность, я просто нахожу это проще по следующей причине. Если у вас есть собственные пользовательские элементы управления, которые находятся в другой сборке, свойство "Имя" не всегда будет достаточным. Это упрощает просто придерживаться свойства x: Name.
Это не элемент WPF, а стандартный XML-код и BtBh правильно ответил на него, x относится к пространству имен по умолчанию. В XML, когда вы не префикс element/attribute с пространством имен, предполагается, что вы хотите использовать пространство имен по умолчанию.
Так что печатать только Name - это не более чем короткая рука для x:Name. Более подробную информацию о пространствах имен XML можно найти в текст ссылки
Один из ответов заключается в том, что x: имя должно использоваться внутри разных языков программы, таких как С#, и имя должно использоваться для фреймворка. Честно говоря, это то, что мне кажется.
Когда вы объявляете элемент Button в XAML, вы ссылаетесь на класс, определенный во время выполнения Windows под названием Button.
У кнопки есть много атрибутов, таких как фон, текст, маржа,..... и атрибут Name.
Теперь, когда вы объявляете кнопку в XAML, это похоже на создание анонимного объекта, у которого был атрибут Name.
В общем случае вы не можете ссылаться на анонимный объект, но в среде WPF XAML-процессор позволяет вам ссылаться на этот объект по любому значению, присвоенному атрибуту Name.
Пока все хорошо.
Другой способ создания объекта - создать именованный объект вместо анонимного объекта. В этом случае пространство имен XAML имеет атрибут для объекта с именем Name (и поскольку в пространстве имен XAML есть X:), который вы можете установить, чтобы вы могли идентифицировать свой объект и ссылаться на него.
Вывод:
Имя является атрибутом определенного объекта, но X: Name является одним из атрибутов этого объекта (существует класс, который определяет общий объект).
Указанный x: Имя становится именем поля, которое создается в базовом коде при обработке XAML, и это поле содержит ссылку на объект. В Silverlight, используя управляемый API, процесс создания этого поля выполняется шагами назначения MSBuild, которые также отвечают за объединение частичных классов для файла XAML и его кода. Это поведение не обязательно указано на языке XAML; это особая реализация, которую Silverlight применяет для использования x: Имя в своих моделях программирования и приложений.
Мое исследование - x:Name как глобальная переменная. Однако, Name как локальная переменная. Означает ли это x: Name, вы можете называть его в любом месте вашего файла XAML, но Name is not.
Пример:
<StackPanel>
<TextBlock Text="{Binding Path=Content, ElementName=btn}" />
<Button Content="Example" Name="btn" />
</StackPanel>
<TextBlock Text="{Binding Path=Content, ElementName=btn}" />
Вы не можете Свойство Binding Content Button с именем "btn", потому что оно находится за пределами StackPanel