public class Model
    {

        public string ConnectionStrings { get; }
        public Model(string connectionStrings) => ConnectionStrings = connectionStrings;
        public DataTable TrenSelect(string dateStart, string dateEnd)
        {

            //MainWindow MainWindow = new MainWindow();

            string SqlText = @"select TREN.ID, convert(VarChar, DT, 104) as 'DT', format(cast(TM as time), N'hh\:mm') as 'TM', SPR.ST, COM " +
          "from TREN left join SPR on SPR.ID = TREN.TP where TREN.DT between @DateStart and @DateEnd order by DT";

            using (SqlConnection connection = new SqlConnection(ConnectionStrings /*ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString*/))
                try
                {
                    connection.Open();
                    SqlDataAdapter adapter = new SqlDataAdapter(SqlText, connection);
                    adapter.SelectCommand.Parameters.AddWithValue("@DateStart", dateStart);
                    adapter.SelectCommand.Parameters.AddWithValue("@DateEnd", dateEnd);
                    DataSet ds = new DataSet();
                    adapter.Fill(ds);

                    //MainWindow.GridTren.ItemsSource = ds.Tables[0].DefaultView;

                    return ds.Tables[0];
                }

                catch (SqlException ex)
                {
                    throw new Exception("Ошибка: " + ex);
                    //MessageBox.Show("Ошибка: " + ex);
                }
        }
    }

    public class ViewModel : OnPropertyChangedClass
    {
        private readonly Model model;
        public ViewModel()
        {
            /// Данные времени конструирования
            DataTable table = new DataTable();
            table.Columns.Add("ID", typeof(string));
            table.Columns.Add("DT", typeof(string));
            table.Columns.Add("TM", typeof(string));
            table.Columns.Add("ST", typeof(string));
            table.Columns.Add("COM", typeof(string));

            var newRow = table.NewRow();
            newRow["ID"] = "123";
            newRow["DT"] = "dddtttt";
            newRow["TM"] = "tttmmmm";
            newRow["ST"] = "ssssttttt";
            newRow["COM"] = "comcocmcom";
            table.Rows.Add(newRow);

            newRow = table.NewRow();
            newRow["ID"] = "567";
            newRow["DT"] = "DT Dt";
            newRow["TM"] = "TM TM";
            newRow["ST"] = "ST ST";
            newRow["COM"] = "COM COM";
            table.Rows.Add(newRow);

            TrenSelectTable = table;
        }
        public ViewModel(string connectionStrings)
        {
            model = new Model(connectionStrings);
        }

        private DataTable _trenSelectTable;

        public DataTable TrenSelectTable { get => _trenSelectTable; private set => SetProperty(ref _trenSelectTable, value); }
        public DataView TrenSelectView => TrenSelectTable.DefaultView;

        protected override void PropertyNewValue<T>(ref T fieldProperty, T newValue, string propertyName)
        {
            base.PropertyNewValue(ref fieldProperty, newValue, propertyName);
            if (propertyName == nameof(TrenSelectTable))
                OnPropertyChanged(nameof(TrenSelectView));
        }

        private RelayCommand _getTrenSelectCommand;

        public RelayCommand GetTrenSelectCommand => _getTrenSelectCommand
            ?? (_getTrenSelectCommand = new RelayCommand(GetTrenSelectMethod));

        private DateTime _dateStart;
        private DateTime _dateEnd;
        public DateTime DateStart { get => _dateStart; set => SetProperty(ref _dateStart, value); }
        public DateTime DateEnd { get => _dateEnd; set => SetProperty(ref _dateEnd, value); }

        private void GetTrenSelectMethod(object parameter)
        {
            if (model != null)
                TrenSelectTable = model.TrenSelect(DateStart.ToString(), DateEnd.ToString());
        }
    }

    <d:Window.DataContext>
        <local:ViewModel />
    </d:Window.DataContext>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition/>
        </Grid.RowDefinitions>
        <Grid>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="0.2*"/>
                <ColumnDefinition/>
                <ColumnDefinition Width="0.2*"/>
                <ColumnDefinition/>
                <ColumnDefinition/>
            </Grid.ColumnDefinitions>
            <TextBlock Text="От:" Margin="5" HorizontalAlignment="Right"/>
            <TextBox Grid.Column="1" Text="{Binding DateStart, StringFormat=\{0:d\}}"
                     VerticalContentAlignment="Center" HorizontalContentAlignment="Center"/>
            <TextBlock Grid.Column="2" Text="До:" Margin="5" HorizontalAlignment="Right"/>
            <TextBox Grid.Column="3" Text="{Binding DateEnd, StringFormat=\{0:d\}}"
                     VerticalContentAlignment="Center" HorizontalContentAlignment="Center"/>
            <Button Grid.Column="4" Content="Получить" Command="{Binding GetTrenSelectCommand, Mode=OneWay}"
                    HorizontalAlignment="Center" VerticalAlignment="Center"
                    Padding="5"/>
        </Grid>
        <DataGrid Grid.Row="1" IsReadOnly="True" AutoGenerateColumns="False" FontSize="14"
                  ItemsSource="{Binding TrenSelectView}">
            <DataGrid.Columns>
                <DataGridTextColumn Header="ID" Binding="{Binding Path=ID}" Width="50" Visibility="Hidden" FontSize="14"/>
                <DataGridTextColumn Header="Дата" Binding="{Binding Path=DT}" Width="100"/>
                <DataGridTextColumn Header="Время" Binding="{Binding Path=TM}" Width="100"/>
                <DataGridTextColumn Header="Тип" Binding="{Binding Path=ST}" Width="130"/>
                <DataGridTextColumn Header="Комментарий" Binding="{Binding Path=COM}" Width="*"/>
            </DataGrid.Columns>
        </DataGrid>
    </Grid>
</Window>

    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            DataContext = new ViewModel(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString);
        }

    }

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;

namespace Common
{
    /// <summary>Базовый класс с реализацией INPC </summary>
    public abstract class OnPropertyChangedClass : INotifyPropertyChanged
    {
        #region Событие PropertyChanged
        /// <summary>Событие для извещения об изменения свойства</summary>
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion

        #region Методы вызова события PropertyChanged
        /// <summary>Метод для вызова события извещения об изменении свойства</summary>
        /// <param name="propertyName">Изменившееся свойство</param>
        public void OnPropertyChanged([CallerMemberName]string propertyName = "")
            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

        /// <summary>Метод для вызова события извещения об изменении списка свойств</summary>
        /// <param name="propList">Список имён свойств</param>
        public void OnPropertyChanged(IEnumerable<string> propList)
        {
            foreach (string propertyName in propList.Where(name => !string.IsNullOrWhiteSpace(name)))
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        /// <summary>Метод для вызова события извещения об изменении перечня свойств</summary>
        /// <param name="propList">Список имён свойств</param>
        public void OnPropertyChanged(params string[] propList)
        {
            foreach (string propertyName in propList.Where(name => !string.IsNullOrWhiteSpace(name)))
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        /// <summary>Метод для вызова события извещения об изменении всех свойств</summary>
        /// <param name="propList">Список свойств</param>
        public void OnAllPropertyChanged()
            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(null));

        #endregion

        #region Виртуальные защищённые методы для изменения значений свойств
        /// <summary>Виртуальный метод определяющий изменения в значении поля значения свойства</summary>
        /// <param name="fieldProperty">Ссылка на поле значения свойства</param>
        /// <param name="newValue">Новое значение</param>
        /// <param name="propertyName">Название свойства</param>
        protected virtual void SetProperty<T>(ref T fieldProperty, T newValue, [CallerMemberName]string propertyName = "")
        {
            if ((fieldProperty != null && !fieldProperty.Equals(newValue)) || (fieldProperty == null && newValue != null))
                PropertyNewValue(ref fieldProperty, newValue, propertyName);
        }

        /// <summary>Виртуальный метод изменяющий значение поля значения свойства</summary>
        /// <param name="fieldProperty">Ссылка на поле значения свойства</param>
        /// <param name="newValue">Новое значение</param>
        /// <param name="propertyName">Название свойства</param>
        protected virtual void PropertyNewValue<T>(ref T fieldProperty, T newValue, string propertyName)
        {
            fieldProperty = newValue;
            OnPropertyChanged(propertyName);
        }
        #endregion
    }

}

using System;
using System.Windows;
using System.Windows.Input;

namespace Common
{
    #region Делегаты для методов WPF команд
    /// <summary>Делегат исполнительного метода команды</summary>
    /// <param name="parameter">Параметр команды</param>
    public delegate void ExecuteHandler(object parameter);
    /// <summary>Делегат исполнительного метода статуса команды</summary>
    /// <param name="parameter">Параметр команды</param>
    /// <returns><see langword="true"/> если выполнение команды разрешено</returns>
    public delegate bool CanExecuteHandler(object parameter);
    #endregion

    #region Класс команд - RelayCommand
    /// <summary>Класс реализующий интерфейс ICommand для создания WPF команд</summary>
    public class RelayCommand : ICommand
    {
        private readonly CanExecuteHandler _canExecute;
        private readonly ExecuteHandler _onExecute;
        private readonly EventHandler _requerySuggested;

        /// <summary>Событие извещающее об измении состояния команды</summary>
        public event EventHandler CanExecuteChanged;

        /// <summary>Конструктор команды</summary>
        /// <param name="execute">Выполняемый метод команды</param>
        /// <param name="canExecute">Метод разрешающий выполнение команды</param>
        public RelayCommand(ExecuteHandler execute, CanExecuteHandler canExecute = null)
        {
            _onExecute = execute;
            _canExecute = canExecute;

            _requerySuggested = (o, e) => Invalidate();
            CommandManager.RequerySuggested += _requerySuggested;
        }

        public void Invalidate()
            => Application.Current.Dispatcher.BeginInvoke
            (
                new Action(() => CanExecuteChanged?.Invoke(this, EventArgs.Empty)),
                null
            );

        /// <summary>Вызов разрешающего метода команды</summary>
        /// <param name="parameter">Параметр команды</param>
        /// <returns>True - если выполнение команды разрешено</returns>
        public bool CanExecute(object parameter) => _canExecute == null ? true : _canExecute.Invoke(parameter);

        /// <summary>Вызов выполняющего метода команды</summary>
        /// <param name="parameter">Параметр команды</param>
        public void Execute(object parameter) => _onExecute?.Invoke(parameter);
    }

    #endregion

}

    public partial class MainWindow : Window
    {
        public MainWindow() => InitializeComponent();
    }