.net - para - que significa alt en una imagen

En WPF, ¿cuáles son las diferencias entre los atributos x: Nombre y Nombre? (14)

El título lo dice todo. A veces parece que los atributos Name y x:Name son intercambiables.

Entonces, ¿cuáles son las diferencias definitivas entre ellos, y cuándo es preferible usar uno sobre el otro?

¿Hay alguna implicación de rendimiento o memoria para usarlos de manera incorrecta?

Ambos son la misma cosa, muchos elementos del marco exponen una propiedad de nombre, pero para aquellos que no lo hacen, puedes usar x: name: normalmente me quedo con x: name porque funciona para todo.

Los controles pueden exponerse a sí mismos como una propiedad de dependencia si lo desean (porque necesitan usar esa propiedad de dependencia internamente), o pueden elegir no hacerlo.

Más detalles en msdn here y here :

Algunas aplicaciones de WPF a nivel de marco podrían evitar cualquier uso del atributo x: Name, ya que la propiedad de dependencia Nombre como se especifica en el espacio de nombres de WPF para varias de las clases base importantes como FrameworkElement / FrameworkContentElement cumple este mismo propósito. Todavía hay algunos escenarios de XAML y marcos comunes donde el acceso de código a un elemento sin propiedad de nombre es necesario, especialmente en ciertas clases de soporte de animación y storyboard. Por ejemplo, debe especificar x: Name en las líneas de tiempo y las transformaciones creadas en XAML, si tiene la intención de hacer referencia a ellas desde el código.
Si Name está disponible como una propiedad en la clase, Name y x: Name se pueden usar indistintamente como atributos, pero se producirá un error si ambos están especificados en el mismo elemento.

Cuando declara un elemento Button en XAML, se refiere a una clase definida en el tiempo de ejecución de Windows llamado Button.

El botón tiene muchos atributos como fondo, texto, margen, ..... y un atributo llamado Nombre.

Ahora, cuando declara un Botón en XAML es como crear un objeto anónimo que tiene un atributo llamado Nombre.

En general, no puede referirse a un objeto anónimo, pero en el marco de trabajo de WPF, el procesador XAML le permite referirse a ese objeto por cualquier valor que le haya dado al atributo Nombre.

Hasta ahora tan bueno.

Otra forma de crear un objeto es crear un objeto con nombre en lugar de un objeto anónimo. En este caso, el espacio de nombres XAML tiene un atributo para un objeto llamado Nombre (y como está en el espacio de nombres XAML, tiene X :) que puede establecer para que pueda identificar su objeto y referirse a él.

Conclusión:

Nombre es un atributo de un objeto específico, pero X: Nombre es un atributo de ese objeto (hay una clase que define un objeto general).

El x: Nombre especificado se convierte en el nombre de un campo que se crea en el código subyacente cuando se procesa XAML, y ese campo contiene una referencia al objeto. En Silverlight, utilizando la API administrada, el proceso de creación de este campo se realiza mediante los pasos de destino de MSBuild, que también son responsables de unir las clases parciales para un archivo XAML y su código subyacente. Este comportamiento no está necesariamente especificado en el lenguaje XAML; Es la implementación particular que Silverlight aplica para usar x: Name en su programación y modelos de aplicación.

Leer más en MSDN ...

La única diferencia es que si está utilizando los controles de usuario en un control del mismo conjunto, entonces Name no identificará su control y obtendrá un error "Use x: Name para los controles en el mismo conjunto". Entonces x: Nombre es la versión de WPF de los controles de nombres en WPF. El nombre solo se usa como un legado de Winform. Querían diferenciar el nombre de los controles en WPF y en las formas de ganancia, ya que usan atributos en Xaml para identificar controles de otros ensamblajes que usaban x: para los Nombres de control.

Solo tenga en cuenta que no ponga un nombre para un control solo por el hecho de mantenerlo como reside en la memoria como un espacio en blanco y le dará una advertencia de que el Nombre se ha aplicado para un control pero nunca se usó.

Mi búsqueda es x:Name como variable global . Sin embargo, el Name como variable local . ¿Significa eso que x: Nombre, puedes llamarlo en cualquier parte de tu archivo XAML pero Nombre no lo es?
Ejemplo:

<StackPanel> <TextBlock Text="{Binding Path=Content, ElementName=btn}" /> <Button Content="Example" Name="btn" /> </StackPanel> <TextBlock Text="{Binding Path=Content, ElementName=btn}" />

No se puede Binding Content de la propiedad del Button con nombre es "btn" porque está fuera de StackPanel

No es un elemento de WPF, pero uno de XML estándar y BtBh ha respondido correctamente, x se refiere al espacio de nombres predeterminado. En XML, cuando no prefieres un elemento / atributo con un espacio de nombres, se supone que quieres el espacio de nombres predeterminado. Así que escribir solo Name no es más que una mano corta para x:Name . Más detalles sobre los espacios de nombres XML se pueden encontrar en el texto del enlace

No són la misma cosa.

x:Name es un concepto xaml, usado principalmente para hacer referencia a elementos. Cuando le da a un elemento el atributo x: Name xaml, "el x:Name especificado se convierte en el nombre de un campo que se crea en el código subyacente cuando se procesa xaml, y ese campo contiene una referencia al objeto". ( MSDN ) Entonces, es un campo generado por el diseñador, que tiene acceso interno por defecto.

Name es la propiedad de cadena existente de FrameworkElement , que aparece como cualquier otra propiedad de elemento wpf en la forma de un atributo xaml.

Como consecuencia, esto también significa que x:Name se puede utilizar en una gama más amplia de objetos. Esta es una técnica para permitir que cualquier nombre en xaml sea referenciado por un nombre dado.

Realmente solo hay un nombre en XAML, el x:Name . Un marco, como WPF, puede asignar opcionalmente una de sus propiedades a XAML''s x:Name usando RuntimeNamePropertyAttribute en la clase que designa una de las propiedades de las clases como mapeo al atributo x: Name de XAML.

La razón por la que se hizo esto fue para permitir marcos que ya tienen un concepto de "Nombre" en tiempo de ejecución, como WPF. En WPF, por ejemplo, FrameworkElement introduce una propiedad de nombre.

En general, una clase no necesita almacenar el nombre para que x:Name sea utilizable. Todo x:Name significa que XAML es generar un campo para almacenar el valor en el código detrás de la clase. Lo que hace el tiempo de ejecución con esa asignación depende del marco.

Entonces, ¿por qué hay dos formas de hacer lo mismo? La respuesta simple es porque hay dos conceptos asignados a una propiedad. WPF desea que el nombre de un elemento se mantenga en tiempo de ejecución (que se puede usar a través de Bind, entre otras cosas) y XAML necesita saber qué elementos desea que sean accesibles por los campos en el código detrás de la clase. WPF une estos dos juntos marcando la propiedad Nombre como un alias de x: Nombre.

En el futuro, XAML tendrá más usos para x: Name, como permitirle establecer propiedades al referirse a otros objetos por nombre, pero en 3.5 y anteriores, solo se usa para crear campos.

Si debe usar uno o el otro es realmente una cuestión de estilo, no técnica. Dejaré eso a otros para una recomendación.

Vea también AutomationProperties.Name VS x: Name , AutomationProperties.Name es usado por las herramientas de accesibilidad y algunas herramientas de prueba.

Siempre uso la variante x: Name. No tengo idea de si esto afecta algún rendimiento, simplemente lo encuentro más fácil por la siguiente razón. Si tiene sus propios controles de usuario que residen en otro conjunto, la propiedad "Nombre" no siempre será suficiente. Esto hace que sea más fácil pegar también la propiedad x: Name.

Una de las respuestas es que x: name se debe usar dentro de diferentes lenguajes de programa como c # y name se debe usar para el marco. Honestamente eso es lo que me suena.

X: El nombre puede causar problemas de memoria si tiene controles personalizados. Mantendrá una ubicación de memoria para la entrada NameScope.

Yo digo que nunca uses x: Nombre a menos que tengas que hacerlo.

x: Nombre y Nombre hacen referencia a diferentes espacios de nombres.

x: nombre es una referencia al espacio de nombres x definido de forma predeterminada en la parte superior del archivo Xaml.

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

Solo diciendo que Nombre usa el siguiente espacio de nombres predeterminado.

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

x: el nombre está diciendo usar el espacio de nombres que tiene el alias x . X es el valor predeterminado y la mayoría de las personas lo dejan, pero puedes cambiarlo a lo que quieras

xmlns:foo="http://schemas.microsoft.com/winfx/2006/xaml"

por lo que su referencia sería foo: nombre

Definir y usar espacios de nombres en WPF

OK vamos a ver esto de una manera diferente. Diga que arrastra y suelta un botón en su página de Xaml. Puede hacer referencia a esta 2 maneras x: nombre y nombre . Todo xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" y xmlns: x = "http://schemas.microsoft.com/winfx/2006/xaml" son referencias a múltiples espacios de nombres . Dado que xaml contiene el espacio de nombres de Control (no el 100% en eso) y la presentación contiene el elemento FrameworkElement Y la clase Button tiene un patrón de herencia de:

Button : ButtonBase ButtonBase : ContentControl, ICommandSource ContentControl : Control, IAddChild Control : FrameworkElement FrameworkElement : UIElement, IFrameworkInputElement, IInputElement, ISupportInitialize, IHaveResources

Entonces, como era de esperar, todo lo que se hereda de FrameworkElement tendría acceso a todos sus atributos públicos. por lo tanto, en el caso de Button, obtiene su atributo Name de FrameworkElement, en la parte superior del árbol jerárquico. Así que puedes decir x: Nombre o Nombre y ambos accederán al getter / setter desde FrameworkElement.

Referencia de MSDN

WPF define un atributo CLR que consumen los procesadores XAML para asignar múltiples espacios de nombres CLR a un único espacio de nombres XML. El atributo XmlnsDefinitionAttribute se coloca en el nivel de ensamblaje en el código fuente que produce el ensamblaje. El código fuente del ensamblaje de WPF utiliza este atributo para asignar los diversos espacios de nombres comunes, como System.Windows y System.Windows.Controls, al espacio de nombres http://schemas.microsoft.com/winfx/2006/xaml/presentation .

Así que los atributos de ensamblaje se verán como:

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 significa: crear un campo en el código detrás para contener una referencia a este objeto.

Name significa: establece la propiedad del nombre de este objeto.

Nombre :

solo se puede utilizar para los descendientes de FrameworkElement y FrameworkContentElement;
se puede establecer desde el código subyacente a través de SetValue () y como propiedad.

x: Nombre :

se puede utilizar para casi todos los elementos XAML;
NO se puede establecer desde el código subyacente a través de SetValue (); solo se puede establecer utilizando la sintaxis de atributo en los objetos porque es una directiva.

El uso de ambas directivas en XAML para un FrameworkElement o FrameworkContentElement causará una excepción: si el XAML se compila como marca, la excepción se producirá en la compilación de marcas;