En WPF, ¿cuáles son las diferencias entre los atributos x: Name y Name?

No son lo mismo.

x:Name es un concepto xaml, utilizado principalmente para hacer referencia a elementos. Cuando se asigna 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 ) Por lo tanto, es un campo generado por el diseñador, que tiene acceso interno por defecto.

Name es la propiedad string existente de un FrameworkElement, listada como cualquier otro wpf propiedad del elemento en forma de atributo xaml.

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

X:Name y Name hacen referencia a diferentes espacios de nombres.

X: name es una referencia al espacio de nombres x definido por defecto en la parte superior del archivo Xaml.

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

Simplemente diciendo Nombre usa el espacio de nombres predeterminado debajo.

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

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

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

Así que su referencia sería foo: nombre

Definir y Usar Espacios de nombres en WPF

Ok veamos esto de una manera diferente. Digamos que arrastras y sueltas un botón en tu página de Xaml. Puede hacer referencia a este 2 maneras x:nombre y nombre. All 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 tiene la Control namespace (not 100% on that) and presentation holds the FrameworkElement AND the Button class has a inheritance pattern of:

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

Así que uno esperaría que cualquier cosa que hereda de FrameworkElement tuviera acceso a todos sus atributos públicos. así que en el caso de Button está obteniendo su atributo Name de FrameworkElement, en la parte superior del árbol de jerarquía. Tan se puede decir x:Nombre o Nombre a y ellos ambos accederán al getter / setter desde el Framework.

Referencia MSDN

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

Así que los atributos del ensamblado se verán algo así 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")]  

Ambos son la misma cosa, muchos elementos del framework exponen una propiedad name ellos mismos, pero para aquellos que no lo hacen, puedes usar x:name - usualmente me quedo con x:name porque funciona para todo.

Los controles pueden exponer name 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 aquí y aquí:

Algún WPF aplicaciones a nivel de marco podría ser capaz de evitar cualquier uso de la x: Atributo Name, porque el nombre propiedad de dependencia como se especifica dentro del espacio de nombres WPF para varios de las clases base importantes como Estructura / estructura satisface este mismo propósito. Hay todavía algunos XAML y framework comunes escenarios en los que el código de acceso a un elemento sin nombre propiedad es necesario, sobre todo en ciertos animación y soporte de storyboard clase. Por ejemplo, usted debe especifique x: Nombre en las líneas de tiempo y transformaciones creadas en XAML, si la intención de hacer referencia a ellos desde el código.

Si el nombre está disponible como una propiedad en se pueden usar la clase, Nombre y x:Nombre indistintamente como atributos, pero un se producirá un error si ambos son especificado en el mismo elemento.

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

Digo que nunca uses x:Name a menos que tengas que hacerlo.

La única diferencia es que si está utilizando Controles de usuario en un control del Mismo ensamblado, entonces Name no identificará su control y obtendrá un error "Use x:Name for controls in the same Assembly". So x: Name es el versionado de WPF de los controles de nomenclatura en WPF. Nombre solo se utiliza como un legado Winform. Querían diferenciar el nombre de los controles en WPF y winforms ya que usan atributos en Xaml para identificar controles de otros ensamblajes que usaron x: para Nombres de control.

Solo tenga en cuenta que no ponga un nombre para un control solo por el bien de mantenerlo, ya que 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 utiliza.

Nombre:

1. solo se puede usar para descendientes de FrameworkElement y FrameworkContentElement;
2. se puede establecer desde code-behind vía setValue() y property-like.

X: Nombre :

1. se puede usar para casi todos los elementos XAML;
2. NO se puede establecer desde code-behind vía setValue (); solo se puede establecer usando atributo sintaxis en objetos porque es una directiva.

Usando ambas directivas en XAML para un Framework o FrameworkContentElement causará una excepción: si el XAML está compilado, la excepción se producirá en la compilación de marcado, de lo contrario se producirá en load.

x:Name medios: cree un campo en el código detrás para contener una referencia a este objeto.

Name significa: establece la propiedad name de este objeto.

Siempre uso la variante x:Name. No tengo ni idea de si esto afecta a cualquier rendimiento, solo me resulta más fácil por la siguiente razón. Si tiene sus propios controles de usuario que residen en otro ensamblado, solo la propiedad" Name " no siempre será suficiente. Esto hace que sea más fácil simplemente pegar también la propiedad x:Name.

No es un elemento WPF sino un elemento XML estándar y BtBh lo ha respondido correctamente, x se refiere al espacio de nombres predeterminado. En XML, cuando no antepone un elemento/atributo con un espacio de nombres, asume que desea el espacio de nombres predeterminado. Así que escribir solo Name no es más que una mano corta para x:Name. Puede encontrar más detalles sobre los espacios de nombres XML en link text

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

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

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

Ahora, cuando declaras un botón en XAML es como crear un objeto anónimo que tiene un atributo llamado Name.

En general, no puede hacer referencia a un objeto anónimo, pero en el marco de WPF el procesador XAML le permite hacer referencia a ese objeto por cualquier valor que hayas dado al atributo Name.

Hasta ahora todo bien.

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 Name (y dado que está en el espacio de nombres XAML, por lo tanto, tiene X:) que puede configurar para que pueda identificar su objeto y hacer referencia a él.

Conclusión:

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

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. En Silverlight, utilizando la API administrada, el proceso de creación de este campo es realizado por los pasos de destino de MSBuild, que también son responsables de unir las clases parciales para un archivo XAML y su código detrás. Este comportamiento no está necesariamente especificado en el lenguaje XAML; es la implementación particular que Silverlight aplica para usar x: Name en sus modelos de programación y aplicación.

Más información en MSDN...

Mi investigación es x:Name como variable global . Sin embargo, Name como variable local. X: Nombre puede llamarlo en cualquier lugar de su archivo XAML, pero Name 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 puedes Binding propiedad Content de Button con Nombre es " btn " porque está fuera StackPanel