¿Cómo puedo establecer el ancho de un DataGridColumn para que se ajuste a los contenidos ("Auto"), pero complete por completo el espacio disponible para el DataGrid en MVVM?

Question

Tengo un WPF DataGrid que contiene algunos datos. Me gustaría establecer el ancho de las columnas de modo que el contenido encaje y nunca se recorta (en cambio, una barra de desplazamiento horizontal debería ser visible). Además, quiero que el DataGrid llene todo el lugar disponible (estoy trabajando con un DockPanel). Estoy utilizando el siguiente código (simplificado):

<DataGrid ItemsSource="{Binding Table}"> 
    <DataGrid.Columns> 
     <DataGridTextColumn MinWidth="100" Width="Auto" Header="Column 1" Binding="{Binding Property1}" /> 
     <DataGridTextColumn MinWidth="200" Width="Auto" Header="Column 2" Binding="{Binding Property2}" /> 
    </DataGrid.Columns> 
</DataGrid> 

Al parecer, esto no funciona fuera de la caja con Width="Auto", ya que siempre se ve algo como esto:

Esto, obviamente, se ve feo. Me gustaría tener toda la fila seleccionada, o, lo que sería mucho mejor, las columnas para llenar todo el ancho, pero como se puede ver, esto no funciona.

En su lugar, si utilizo Width="*", el contenido de las columnas se recorta, lo que es aún peor para mí.

Encontré un similar question here, y una solución fue publicada allí. Esto puede funcionar, pero estoy trabajando con el patrón MVVM, por lo que el ItemsSource se actualiza en el ViewModel y no puedo pensar en una forma de hacerlo a partir de allí, porque no puedo acceder a la propiedad DataGridColumn del ActualWidth. Además, me gustaría hacerlo solo en XAML si es posible.

Agradeceria cualquier ayuda. ¡Gracias!

Editar: Como todavía no tengo ni idea de qué hacer al respecto, comienzo una pequeña recompensa. Estaría muy feliz con una sugerencia de lo que se podría hacer con mi problema. ¡Gracias de nuevo!

Editar 2: Después de la respuesta de saus, pensé nuevamente en las opciones. El problema es que necesito actualizar las propiedades Width y MinWidth también durante la ejecución de la aplicación, por lo que no solo después de cargar la ventana. Ya he intentado hacer algo como

column.Width = new DataGridLength(1, DataGridLengthUnitType.Auto); 
column.MinWidth = column.ActualWidth; 
column.Width = new DataGridLength(1, DataGridLengthUnitType.Star); 

en algún evento que se dispara cuando el ItemsSource subyacente de la DataGrid es la actualización. Sin embargo, esto no funciona, ya que la propiedad ActualWidth no parece cambiar después de configurar el Width en Auto. ¿Existe una opción para "volver a pintar" de alguna manera para obtener la propiedad ActualWidth actualizada? ¡Gracias!

Answer 1

Si desea que la columna para no cortar sus datos, añadir lo siguiente a la definición de la ventana/control de usuario:

xmlns:System="clr-namespace:System;assembly=mscorlib" 

Luego de la anchura de las columnas se pueden utilizar para siguiente.

Width="{x:Static System:Double.NaN}" 

Esto hace que la columna siempre crezca lo suficiente para acomodar el valor más largo en la columna.

Como el código anterior no funcionaba en la cuadrícula de datos, ¿qué pasa con la adición de un ScrollViewer alrededor de la cuadrícula de datos como esto:

 <ScrollViewer HorizontalScrollBarVisibility="Auto" 
        VerticalScrollBarVisibility="Auto"> 
     <DataGrid ItemsSource="{Binding Table}" AutoGenerateColumns="False"> 
      <DataGrid.Columns> 
       <DataGridTextColumn MinWidth="10" Width="Auto" Header="Column 1" Binding="{Binding Property1}" /> 
       <DataGridTextColumn MinWidth="200" Width="*" Header="Column 2" Binding="{Binding Property2}" />      
      </DataGrid.Columns> 
     </DataGrid> 
    </ScrollViewer> 

Answer 2

Uso TextBlock con ajuste de texto dentro de la columna de plantilla:

<DataGrid ItemsSource="{Binding Table}">  
    <DataGrid.Columns>   
     <DataGridTextColumn MinWidth="100" Width="Auto" Header="Column 1" 
          Binding="{Binding Property1}" />   
     <DataGridTemplateColumn Width="*" Header="Column 2"> 
      <DataGridTemplateColumn.CellTemplate> 
       <DataTemplate> 
        <TextBlock Text="{Binding Property2}" TextWrapping="Wrap" /> 
       </DataTemplate> 
      </DataGridTemplateColumn.CellTemplate> 
     </DataGridTemplateColumn> 
    </DataGrid.Columns> 
</DataGrid> 

Answer 3

¿qué tal esto:

para MinWidth de sus columnas, configura un enlace al ancho de ScrollContent de dataGrid, con un convertidor que divide este ancho por nu mber de columnas

necesita un código para el convertidor, pero esto mantendría intacta su estructura MVVM.

podría ser una posibilidad remota, pero no tuvimos el tiempo para probarlo.

Edité: Puse un poco más de reflexión en este y en otro pb: no funcionará bien si tiene, por ejemplo, una gran columna y algunas pequeñas. Supuse que todos los cols tienen el mismo ancho, lo que obviamente no es el caso aquí.

Es posible que desee explorar de esta manera sin embargo. Usar enlaces en los Anchos con convertidores es lo único que se me ocurre que podría funcionar: dado que básicamente tienes 2 condiciones para tener en cuenta al calcular el ancho de una columna, no habrá una manera fácil de hacerlo.

Answer 4

Sugeriría usar la solución a la que se ha vinculado. Funciona. En el código subyacente de la vista, añadir el siguiente al constructor después de InitializeComponent():

Griddy.Loaded += SetMinWidths; // I named my datagrid Griddy 

y definir SetMinWidths como:

public void SetMinWidths(object source, EventArgs e) 
     { 
      foreach (var column in Griddy.Columns) 
      { 
       column.MinWidth = column.ActualWidth; 
       column.Width = new DataGridLength(1, DataGridLengthUnitType.Star); 
      } 
     } 

Estoy asumiendo que la razón por la que no quiere utilizar esta solución es que usted cree que MVVM prohíbe el código en el código subyacente. Pero dado que esto es completamente lógico de vista específica, creo que está justificado en este caso. Todo el asunto "MVVM prohíbe el código en el código subyacente" es un poco erróneo.

Pero si usted está obligado por las guías de estilo, o si desea esta lógica esté disponible para todos los DataGrids en su aplicación, se puede hacer un comportamiento adjunto que hace el trabajo de esta manera:

public class SetMinWidthToAutoAttachedBehaviour 
    { 
     public static bool GetSetMinWidthToAuto(DependencyObject obj) 
     { 
      return (bool)obj.GetValue(SetMinWidthToAutoProperty); 
     } 

     public static void SetSetMinWidthToAuto(DependencyObject obj, bool value) 
     { 
      obj.SetValue(SetMinWidthToAutoProperty, value); 
     } 

     // Using a DependencyProperty as the backing store for SetMinWidthToAuto. This enables animation, styling, binding, etc... 
     public static readonly DependencyProperty SetMinWidthToAutoProperty = 
      DependencyProperty.RegisterAttached("SetMinWidthToAuto", typeof(bool), typeof(SetMinWidthToAutoAttachedBehaviour), new UIPropertyMetadata(false, WireUpLoadedEvent)); 

     public static void WireUpLoadedEvent(DependencyObject d, DependencyPropertyChangedEventArgs e) 
     { 
      var grid = (DataGrid)d; 

      var doIt = (bool)e.NewValue; 

      if (doIt) 
      { 
       grid.Loaded += SetMinWidths; 
      } 
     } 

     public static void SetMinWidths(object source, EventArgs e) 
     { 
      var grid = (DataGrid)source; 

      foreach (var column in grid.Columns) 
      { 
       column.MinWidth = column.ActualWidth; 
       column.Width = new DataGridLength(1, DataGridLengthUnitType.Star); 
      } 
     } 
    } 

y luego para cualquier cuadrícula de datos que desea aplicar a este comportamiento, agregue lo siguiente:

<DataGrid ItemsSource="{Binding Table}" local:SetMinWidthToAutoAttachedBehaviour.SetMinWidthToAuto="true"> 

Y entonces su conciencia, así como su código subyacente, será claro.

Answer 5

Fuerza de la última columna para tomar todo el espacio restante en la cuadrícula de datos

grid.Columns[grid.Columns.Count -1].Width = new 
        DataGridLength(250, DataGridLengthUnitType.Star); 

Answer 6

he añadido el Event a la DataGrid que redefinir su anchura con respecto a la anchura real de la DataGrid:

private static void OnLoaded(object sender, RoutedEventArgs e) 
    { 
     DataGrid dg = sender as DataGrid; 
     foreach (var column in dg.Columns) 
     { 
      column.Width = new DataGridLength(dg.ActualWidth/dg.Columns.Count, DataGridLengthUnitType.Pixel); 
     } 
    } 

La línea:

column.Width = new DataGridLength(1, DataGridLengthUnitType.Star); 

fue absolutamente indemne. La definición de DataGridLengthUnitType.Star reduce el ancho de las columnas a su ancho mínimo, y hace que su ancho sea estático y no editable.