Ajustar programáticamente el número de filas en una cuadrícula con C #

Solo quería terminar este proyecto

Comprendido. La cuestión es que la idea básica detrás de MVVM no es realmente tan difícil, y si la acepta, es probable que termine el proyecto más rápido que si continúa intentando codificar toda su interfaz de usuario. No puedo garantizar eso, por supuesto. Pero yo he pasado por lo mismo y puedo decirte que puedes pasar mucho tiempo luchando contra WPF tratando de configurar la interfaz de usuario en código subyacente explícitamente.

Sin un buen ejemplo de código mínimo, completo y verificable para empezar, no me resultó práctico replicar exactamente su interfaz de usuario. Pero aquí hay un ejemplo de código simple que muestra el enfoque básico que puede tomar para usar MVVM para crear la interfaz de usuario que desea ...

Primero, es útil tener una clase base que se implemente INotifyPropertyChangedpor usted. Simplifica mucho el texto estándar del modelo de vista:

class NotifyPropertyChangedBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void _UpdateField<T>(ref T field, T newValue, [CallerMemberName] string propertyName = null)
    {
        if (!EqualityComparer<T>.Default.Equals(field, newValue))
        {
            field = newValue;
            _OnPropertyChanged(propertyName);
        }
    }

    protected virtual void _OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Entonces, necesitaremos ver modelos. En esta interfaz de usuario, hay dos componentes básicos: la vista general y los días individuales del mes. Entonces, hice un modelo de vista para cada uno:

class DateViewModel : NotifyPropertyChangedBase
{
    private int _dayNumber;
    private bool _isCurrent;

    public int DayNumber
    {
        get { return _dayNumber; }
        set { _UpdateField(ref _dayNumber, value); }
    }

    public bool IsCurrent
    {
        get { return _isCurrent; }
        set { _UpdateField(ref _isCurrent, value); }
    }
}

y…

class MonthViewViewModel : NotifyPropertyChangedBase
{
    private readonly ObservableCollection<DateViewModel> _dates = new ObservableCollection<DateViewModel>();

    private DateTime _selectedDate;

    public DateTime SelectedDate
    {
        get { return _selectedDate; }
        set { _UpdateField(ref _selectedDate, value); }
    }

    public IReadOnlyCollection<DateViewModel> Dates
    {
        get { return _dates; }
    }

    protected override void _OnPropertyChanged(string propertyName)
    {
        base._OnPropertyChanged(propertyName);

        switch (propertyName)
        {
            case nameof(SelectedDate):
                _UpdateDates();
                break;
        }
    }

    private void _UpdateDates()
    {
        _dates.Clear();

        DateTime firstDayOfMonth = new DateTime(SelectedDate.Year, SelectedDate.Month, 1),
            firstDayOfNextMonth = firstDayOfMonth.AddMonths(1);
        int previousMonthDates = (int)firstDayOfMonth.DayOfWeek; // assumes Sunday-start week
        int daysInView = previousMonthDates + DateTime.DaysInMonth(SelectedDate.Year, SelectedDate.Month);

        // round up to nearest week multiple
        daysInView = ((daysInView - 1) / 7 + 1) * 7;

        DateTime previousMonth = firstDayOfMonth.AddDays(-previousMonthDates);

        for (DateTime date = previousMonth; date < firstDayOfNextMonth; date = date.AddDays(1))
        {
            _dates.Add(new DateViewModel { DayNumber = date.Day, IsCurrent = date == SelectedDate.Date });
        }

        for (int i = 1; _dates.Count < daysInView; i++)
        {
            _dates.Add(new DateViewModel { DayNumber = i, IsCurrent = false });
        }
    }
}

Como puede ver, hasta ahora no se ha mencionado la interfaz de usuario y, sin embargo, ya existe toda la lógica para construir las fechas correspondientes a un mes. La parte de la interfaz de usuario, el XAML, no tendrá idea de que está haciendo algo relacionado con meses o fechas. Lo más cercano que se obtiene es un invariante codificado, es decir, el número de días de una semana que se utilizan para controlar el número de columnas en el UniformGridque se mostrarán sus datos.

El XAML tiene este aspecto:

<Window x:Class="TestSO43147585CalendarMonthView.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:p="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:l="clr-namespace:TestSO43147585CalendarMonthView"
        xmlns:s="clr-namespace:System;assembly=mscorlib"
        mc:Ignorable="d"
        SizeToContent="Height"
        Title="MainWindow" Height="350" Width="525">
  <Window.DataContext>
    <l:MonthViewViewModel SelectedDate="{x:Static s:DateTime.Today}"/>
  </Window.DataContext>

  <Window.Resources>
    <DataTemplate DataType="{x:Type l:MonthViewViewModel}">
      <ItemsControl ItemsSource="{Binding Dates}">
        <ItemsControl.ItemsPanel>
          <ItemsPanelTemplate>
            <UniformGrid IsItemsHost="True" Columns="7"/>
          </ItemsPanelTemplate>
        </ItemsControl.ItemsPanel>
      </ItemsControl>
    </DataTemplate>

    <DataTemplate DataType="{x:Type l:DateViewModel}">
      <Border BorderBrush="Black" BorderThickness="0, 0, 1, 0">
        <StackPanel>
          <TextBlock Text="{Binding DayNumber}">
            <TextBlock.Style>
              <p:Style TargetType="TextBlock">
                <Setter Property="Background" Value="LightBlue"/>
                <p:Style.Triggers>
                  <DataTrigger Binding="{Binding IsCurrent}" Value="True">
                    <Setter Property="Background" Value="Yellow"/>
                  </DataTrigger>
                </p:Style.Triggers>
              </p:Style>
            </TextBlock.Style>
          </TextBlock>
          <Grid Height="{Binding ActualWidth, RelativeSource={x:Static RelativeSource.Self}}"/>
        </StackPanel>
      </Border>
    </DataTemplate>
  </Window.Resources>

  <Grid>
    <ContentControl Content="{Binding}" VerticalAlignment="Top"/>
  </Grid>
</Window>

El XAML hace tres cosas:

1. Declara un MonthViewViewModelobjeto que se utilizará como DataContextpara el Window. Un objeto en el árbol visual, es decir, los hijos de Window, heredará el contexto de su padre si no tiene ninguno propio.
2. Declara plantillas de datos para los dos modelos de vista. Estos le dicen a WPF cómo debe representar visualmente los datos. Un modelo de vista contiene los datos que desea representar, y estos datos se referencian en la plantilla a través de la {Binding...}sintaxis. En muchos casos (por ejemplo, texto, números, valores de enumeración), puede enlazar directamente y la conversión predeterminada hará lo que desee (como es el caso anterior). De lo contrario, puede implementar el suyo IValueConvertere incorporarlo en el enlace.
3. Proporciona un lugar para MonthViewViewModelque se muestre, al declarar a ContentControl, donde el contenido de ese control está vinculado simplemente al contexto de datos actual (una {Binding}expresión sin una ruta se vinculará a la fuente, y la fuente predeterminada es el contexto de datos actual) .

En el contexto del ContentControl, así como de los elementos individuales que se muestran en el ItemsControl, WPF buscará la plantilla que sea apropiada para el objeto de datos definido para ese contexto, y automáticamente poblará su árbol visual, vinculando las propiedades necesarias, según a ese objeto.

Hay una serie de ventajas en este enfoque, las principales son que puede describir su interfaz de usuario en lugar de tener que codificarla , y que mantiene el principio de POO de "separación de preocupaciones", que es clave para reducir el trabajo mental. carga involucrada al permitirle concentrarse en una cosa a la vez, en lugar de tener que lidiar con la interfaz de usuario y la lógica de datos juntos.

Un par de notas al margen sobre el XAML anterior:

• Puede notar que agregué el p:espacio de nombres XML y lo usé para el Styleelemento. Esto solo es una solución a un error de desbordamiento de pila, en el que el Styleelemento por sí mismo confunde al formateador XML y evita que el elemento y sus elementos secundarios se formatee correctamente. El XAML se compilará bien así, pero en realidad no es necesario en código real. En su XAML habitual, puede omitirlo de forma segura.
• Incluí una característica que su código no incluía, solo con el propósito de ilustrar. Es decir, la fecha actual se resalta en amarillo. La técnica que se muestra aquí es muy útil, ya que le permite personalizar la apariencia de un elemento en una sola plantilla, según los valores de propiedad del modelo de vista. Pero hay una pequeña trampa: en WPF, si establece explícitamente la propiedad de un elemento a través de la sintaxis del atributo, por ejemplo, algo así <TextBlock Text="{Binding DayNumber}" Background="LightBlue">, esa sintaxis tendrá prioridad sobre cualquier <Setter...>elemento en un estilo. Debe recordar establecer el valor predeterminado de cualquier propiedad que desee establecer a través de un disparador, en su propio <Setter...>estilo también (como se muestra arriba).