Борис Животное

Константа вычисляется статически на этапе компиляции. Константы подставляются в виде литералов в места использования этих констант. Если создать отдельную сборку только для констант, сослаться на эту сборку из основного проекта, собрать проект, то эту сборку можно будет удалить и всё будет работать, так как в основном проекте не будет ссылок на классы этой сборки, все константы будут подставлены в виде литералов. Так же изменение в сборке с константами потребует пересобрать сборку, которая использует константы.
Здесь наглядный пример.

readonly поле - это поле только для чтения, которое можно задать в конструкторе типа, в котором оно определено или в месте объявления поля. Если поле помечено модификатором static, то его значение можно задать только в статическом конструкторе типа, в котором оно определено или в месте объявления поля.

Как организовать постоянное обновление DataGrid в отдельном потоке, чтобы при этом DataGrid был доступен, т.к. планируется добавить возможность выбирать строку из DataGrid и смотреть подробную информацию.

Нельзя обновлять элементы UI из не UI потока. Можно получать данные в другом потоке, но обновлять UI нужно из UI потока. Я бы просто пробегал по ObservableCollection<{T}>, где T это класс, реализующий интерфейс INotifyPropertyChanged и обновлял нужные объекты уже в UI потоке. Судя по всему, проект не придерживается паттерна MVVM, а лучше бы придерживался.

Список процессов нужно получать как раз в Task.Run(...), а вот вызывать обновление процессов в UI через Dispatcher или SynchronizationContext.

Посмотри мои ответы здесь:
Как осуществить ввод и вывод данных WPF?
Здесь про Task.Delay и вообще цикл в Task.Run Как сделать цикл на основе ответа на Web запрос в C#?
Здесь как перенаправлять выполнение через SynchronizationContext в UI поток С# Taks и Invoke почему то блокируется форма?

Ещё, ожидание в методах, которые запускаются тасками нужно делать через вызов await Task.Delay(...), но точно не через Thread.Sleep(...):

using System;
using System.Threading.Tasks;

namespace Tasks
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Так
            await Task.Run(async () =>
            {
                while (true)
                {
                    await Task.Delay(1000);
                    Console.Write("=");
                }
            });

            // Или так (обрати внимание на Unwrap()) 
            await Task.Factory.StartNew(async () =>
            {
                while (true)
                {
                    await Task.Delay(1000);
                    Console.Write("=");
                }
            }).Unwrap();
        }
    }
}

Читай комментарии в коде, в том числе зачем там lock. Вдруг ты будешь использовать такой поиск с отменой не в UI потоке (не именно этот код, а саму логику).

Models/SearchAlgorithm.cs

using System;
using System.Threading;
using System.Threading.Tasks;

namespace EventsInModel.Models
{
    public class SearchAlgorithm
    {
        public string CurrentFolder { get; private set; }

        public event EventHandler ProgressChanged;

        public async Task Search(CancellationToken cancellationToken)
        {
            for (int i = 0; i < 5; i++)
            {
                await Task.Delay(1200, cancellationToken);

                cancellationToken.ThrowIfCancellationRequested();

                // Можно прогресс передавать и в качестве аргумента события,
                // но в данном случае, вряд ли это оправдано. Обработав событие можно получить
                // доступ к отправителю события и прочитать его свойства.
                CurrentFolder = i.ToString();
                ProgressChanged?.Invoke(this, EventArgs.Empty);
            }
        }
    }
}

ViewModels/MainViewModel.cs

using System;
using System.Threading;
using System.Windows.Input;
using EventsInModel.Models;
using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;

namespace EventsInModel.ViewModels
{
    // ViewModelBase из библиотеки MvvmLight
    public class MainViewModel : ViewModelBase
    {
        //private readonly object _sync = new object();
        private readonly SearchAlgorithm _search;

        private string _currentFolder;
        // Логику с отменой можно вынести в отдельный класс, чтобы не писать простыню
        // с отменой в каждом таком месте с операцией, которая может быть отменена, а 
        // в UI приложениях такое сплошь и рядом.
        private volatile CancellationTokenSource _lastCancellationTokenSource;

        public string CurrentFolder
        {
            get { return _currentFolder; }
            private set { Set(ref _currentFolder, value); }
        }

        public ICommand SearchCommand { get; }

        public MainViewModel(SearchAlgorithm search)
        {
            _search = search;
            _search.ProgressChanged += OnSearchProgressChanged;
            SearchCommand = new RelayCommand(Search);
        }

        public override void Cleanup()
        {
            //lock (_sync)
            {
                _lastCancellationTokenSource?.Cancel();
            }

            _search.ProgressChanged -= OnSearchProgressChanged;
            base.Cleanup();
        }

        /// <summary>
        /// Прерывает прошлый поиск и запускает новый.
        /// </summary>
        private async void Search()
        {
            CancellationTokenSource currentTokenSource;
            // В случае, если такой метод вызывать не из UI потока, то lock здесь нужен
            // Если использовать только из UI потока как здесь, то lock можно удалить.
            // Ещё бы я вынес логику в отдельный класс и использовал в других проектах в том числе.
            //lock (_sync)
            {
                _lastCancellationTokenSource?.Cancel();
                currentTokenSource = new CancellationTokenSource();
                _lastCancellationTokenSource = currentTokenSource;
            }

            try
            {
                await _search.Search(currentTokenSource.Token);
            }
            catch (OperationCanceledException)
            {
                // Ignored.
            }
            finally
            {
                //lock (_sync)
                {
                    currentTokenSource.Dispose();
                    if (ReferenceEquals(_lastCancellationTokenSource, currentTokenSource))
                    {
                        _lastCancellationTokenSource = null;
                    }
                }
            }
        }

        private void OnSearchProgressChanged(object sender, EventArgs e)
        {
            var search = (SearchAlgorithm)sender;
            CurrentFolder = search.CurrentFolder;
        }
    }
}

Затестил я по быстрому так. Это тебе не особо нужно:

MainWindow.xaml.cs

using System.Windows;
using EventsInModel.Models;
using EventsInModel.ViewModels;

namespace EventsInModel
{
    public partial class MainWindow : Window
    {
        private readonly MainViewModel _viewModel;

        public MainWindow()
        {
            InitializeComponent();
            _viewModel = new MainViewModel(new SearchAlgorithm());
            DataContext = _viewModel;

            Loaded += OnLoaded;
            Closing += OnClosing;
        }

        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            _viewModel.SearchCommand.Execute(null);
            _viewModel.SearchCommand.Execute(null);
        }

        private void OnClosing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            _viewModel.Cleanup();
        }
    }
}

Проект с зависимостями

<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <UseWPF>true</UseWPF>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="MvvmLightLibsStd10" Version="5.4.1.1" />
  </ItemGroup>

</Project>

Разобрался. В общем, для Visual Studio 2017 v15.3.5 у меня заработало всё с таким конфигом:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netcoreapp2.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0-preview-20170914-09" />
    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\src\RazorLesson.Model\RazorLesson.Model.csproj" />
  </ItemGroup>

</Project>

https://www.nuget.org/packages/Microsoft.NET.Test....
https://www.nuget.org/packages/xunit/2.3.0-beta5-b...
https://www.nuget.org/packages/xunit.runner.visual...

https://docs.microsoft.com/en-us/dotnet/core/testi...

Для Linux:

using System;
using System.Diagnostics;
using System.IO;

namespace Test
{
	class MainClass
	{
		public static void Main (string[] args)
		{          
			string result = LinuxTerminal.GetOutput("find /sys/class/input -maxdepth 1  -name \"mouse*\"|wc -l");
			int outputValue = int.Parse (result);
			Console.WriteLine (outputValue);
			Console.ReadKey ();
		}
	}
}

using System;
using System.Diagnostics;

namespace Test
{
	public static class LinuxTerminal
	{
		private const string TerminalPath = "/bin/bash";

		public static void ExecuteCommand(string command)
		{
			var proc = new Process();
			proc.StartInfo.FileName = TerminalPath;
			proc.StartInfo.Arguments = "-c \" " + command + " \"";
			proc.StartInfo.UseShellExecute = false;
			proc.Start();
		}

		public static int GetExitCode(string command)
		{
			var proc = new Process();
			proc.StartInfo.FileName = TerminalPath;
			proc.StartInfo.Arguments = "-c \" " + command + " \"";
			proc.StartInfo.UseShellExecute = false;
			proc.StartInfo.RedirectStandardOutput = true;
			proc.Start();
			proc.WaitForExit();
			return proc.ExitCode;
		}

		public static string GetOutput(string command)
		{
			var proc = new Process();
			proc.StartInfo.FileName = TerminalPath;
			proc.StartInfo.Arguments = "-c \" " + command + " \"";
			proc.StartInfo.UseShellExecute = false;
			proc.StartInfo.RedirectStandardOutput = true;
			proc.Start();
			proc.WaitForExit();
			return proc.StandardOutput.ReadToEnd();
		}
	}
}

Из под винды так работает запуск программы и получение ExitCode

using System.Diagnostics;

namespace ProcessStart
{
    public static class CommandLine
    {
        public static int ExecuteCommand(string applicationPath, string command = "")
        {
            var proc = new Process();
            proc.StartInfo.FileName = applicationPath;
            proc.StartInfo.Arguments = command;
            proc.StartInfo.UseShellExecute = false;
            proc.StartInfo.CreateNoWindow = true;
            proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            proc.Start();
            proc.WaitForExit();
            return proc.ExitCode;
        }
    }
}

using System;
using System.IO;

namespace ProcessStart
{
    class Program
    {
        private static Program _program;

        static void Main(string[] args)
        {
            _program = new Program();
            _program.Run();
        }

        private void Run()
        {
            const string ProgramName = "ReturnRandomNumber.exe";
            string appName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ProgramName);

            int exitCode = CommandLine.ExecuteCommand(appName); 
            Console.WriteLine(exitCode.ToString());

            Console.ReadKey();
        }
    }
}

В итоге решил это дело так. На место {0} в C# коде подставляется сгенерированный GUID

BEGIN TRANSACTION
SET TRANSACTION ISOLATION LEVEL READ COMMITTED

SET DEADLOCK_PRIORITY LOW;
DECLARE @Quantity INT = 5;

IF OBJECT_ID('tempdb..##GroupIDs_{0}') IS NULL
BEGIN
	CREATE TABLE ##GroupIDs_{0} (
		ID INT NOT NULL,
		CONSTRAINT PK_GroupIDs_ID_{0} PRIMARY KEY(ID),
	);
END

INSERT INTO ##GroupIDs_{0} (ID) 
SELECT TOP(@Quantity) ID FROM SOME_GROUP WITH(UPDLOCK, READPAST) WHERE REPLICATED <> 1

-- Первый запрос, вызываемый из C# кода в одной транзакции.
-- 1 ------------------------------------------------------------------
UPDATE SOME_GROUP SET REPLICATED = 2 
OUTPUT 
  INSERTED.ID
 ,INSERTED.NAME
WHERE ID IN(SELECT ID FROM ##GroupIDs_{0})

-- Второй запрос, вызываемый из C# кода в одной транзакции.
-- 2------------------------------------------------------------------
UPDATE SOME_CHILD_ONE SET REPLICATED = 2 
OUTPUT 
  INSERTED.ID
 ,INSERTED.GROUP_ID
 ,INSERTED.UPDATED
WHERE GROUP_ID IN(SELECT ID FROM ##GroupIDs_{0}) AND REPLICATED <> 1

-- Третий запрос, вызываемый из C# кода в одной транзакции.
-- 3 ------------------------------------------------------------------
UPDATE SOME_CHILD_TWO SET REPLICATED = 2 
OUTPUT 
  INSERTED.ID
 ,INSERTED.GROUP_ID
 ,INSERTED.NAME
 ,INSERTED.CREATED
WHERE GROUP_ID IN(SELECT ID FROM ##GroupIDs_{0}) AND REPLICATED <> 1

DROP TABLE ##GroupIDs_{0};
-- 3 ------------------------------------------------------------------

COMMIT TRANSACTION

Ты для авторизации создаёшь целый поток. Почему тормоза тебе уже сказали, ты вызываешь authVK.join() в основном потоке и тем самым его сам же стопоришь, пока не выполнится второй поток. Вообще благодаря этому коду ты тратишь больше ресурсов и вызываешь ещё большие тормоза, если бы вообще не юзал поток.

В данном случае использовать нужно Task. Или ещё уйму способов выполнить код не в основном потоке и не создавать новый. Почитай про пул потоков и задачи (Task).

Я смотрю ты создал константу Empty с пустой строкой!? Так есть же string.Empty стандартный.

<Window x:Class="Wpf_Task.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow"
        Width="525"
        Height="350"
        WindowStartupLocation="CenterScreen">
   <Window.Resources>
      <Storyboard x:Key="OnLoaded1"
                  RepeatBehavior="Forever">
         <DoubleAnimationUsingKeyFrames Storyboard.TargetName="border"
                                        Storyboard.TargetProperty="(UIElement.RenderTransform).(TransformGroup.Children)[2].(RotateTransform.Angle)">
            <EasingDoubleKeyFrame KeyTime="0"
                                  Value="0" />
            <EasingDoubleKeyFrame KeyTime="0:0:1"
                                  Value="360" />
         </DoubleAnimationUsingKeyFrames>
      </Storyboard>
   </Window.Resources>

   <Window.Triggers>
      <EventTrigger RoutedEvent="FrameworkElement.Loaded">
         <BeginStoryboard Storyboard="{StaticResource OnLoaded1}" />
      </EventTrigger>
   </Window.Triggers>

   <Grid>

      <Button x:Name="executeButton"
              Width="75"
              Margin="0,216,0,0"
              HorizontalAlignment="Center"
              VerticalAlignment="Top"
              Click="Button_Click"
              Content="Выполнить"
              TextOptions.TextFormattingMode="Display" />

      <Rectangle x:Name="border"
                 Width="100"
                 Height="100"
                 Margin="208,57,208,161"
                 HorizontalAlignment="Center"
                 VerticalAlignment="Center"
                 RenderTransformOrigin="0.5,0.5">
         <Rectangle.Fill>
            <LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
               <GradientStop Offset="0" Color="#FFD1BD69" />
               <GradientStop Offset="1" Color="#FFFFF5C9" />
            </LinearGradientBrush>
         </Rectangle.Fill>
         <Rectangle.RenderTransform>
            <TransformGroup>
               <ScaleTransform />
               <SkewTransform />
               <RotateTransform />
               <TranslateTransform />
            </TransformGroup>
         </Rectangle.RenderTransform>
      </Rectangle>

      <TextBlock x:Name="_result"
                 Margin="0,187,0,0"
                 HorizontalAlignment="Center"
                 VerticalAlignment="Top"
                 Text="..."
                 TextOptions.TextFormattingMode="Display"
                 TextWrapping="Wrap" />

   </Grid>
</Window>

using System.Threading;
using System.Threading.Tasks;
using System.Windows;

namespace Wpf_Task
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            executeButton.IsEnabled = false;
            Task<int>.Factory.StartNew(() =>
            {
               return Auth.Login();
            })
            .ContinueWith(task => //Выполнить код в основном потоке (TaskScheduler.FromCurrentSynchronizationContext())
            {
                executeButton.IsEnabled = true;
                _result.Text = task.Result.ToString();
            }, TaskScheduler.FromCurrentSynchronizationContext());
        }
    }

    public static class Auth
    {
        private static int _counter;

        public static int Login()
        {
            Thread.Sleep(1000);
            return ++_counter;
        }
    }
}

Обновлено: 10.07.2015
В общем решил проблему так. В конструкторе ViewModelLocator почти ничего не выполняю в режиме дизайнера кода, а свойство сделал таким:

public MainViewModel Main
        {
            get
            {
                return !ViewModelBase.IsInDesignModeStatic ?
                    _container.Resolve<MainViewModel>() :
                    _designerMainVm ?? (_designerMainVm = 
                    new MainViewModel(null, null, null, null) { Settings = new AppSettings() });
            }
        }

Конец обновленного текста

ViewModelLocator.cs

public class ViewModelLocator : ViewModelLocatorBase
    {
        private readonly IContainer _container;
        private static ViewModelLocator _locator;

        public ViewModelLocator()
        {
            _locator = this;

            if (!ViewModelBase.IsInDesignModeStatic)
            {
                Application.Current.DispatcherUnhandledException += Current_DispatcherUnhandledException;
                Application.Current.MainWindow.Loaded += MainWindow_Loaded;
                Application.Current.MainWindow.Closing += MainWindow_Closing;
            }

            LogManager.Logger.LogPath = LocalConfiguration.Instance.Folders.Logs;

            DispatcherHelper.Initialize();
            CorrelationsLocator.Initialize();

            if (!ViewModelBase.IsInDesignModeStatic)
            {
                ProgramIdentification.Initialize(ProgramIdentifier.CbpOperator);

                LocalConfiguration.Instance.Folders.CheckFolders();
                LocalConfiguration.Instance.LoadAppConfig();
                LocalConfiguration.Instance.LoadLocalSettings();

                WpfSingleInstance.AppIsAlreadyRunning += (sender, args) =>
                    MessageBox.Show(string.Format("Приложение: {0} уже запущено", args.AppName));
                WpfSingleInstance.Make();
            }
            _container = RegisterDependencies(LocalConfiguration.Instance);
        }

        private IContainer RegisterDependencies(LocalConfiguration config)
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<LauncherViewModel>().SingleInstance();
            builder.RegisterType<ShutdownViewModel>().SingleInstance();
            builder.RegisterType<CommandManager>().SingleInstance();
            builder.RegisterType<AccountControllerVm>().SingleInstance();
            builder.RegisterType<ComponentEditorViewModel>().SingleInstance();
            builder.RegisterType<ComponentSelectorViewModel>().SingleInstance();
            builder.RegisterType<RecipeTimeSetEditorViewModel>().SingleInstance();
            builder.RegisterType<CategoryEditorViewModel>().SingleInstance();
            builder.RegisterType<AboutDialogViewModel>().SingleInstance();
            builder.RegisterType<L1ApplicationManagerViewModel>().SingleInstance();

            builder.RegisterType<CarEditorViewModel>() //Редактор машин
                .OnActivated(e =>
                {
                    e.Instance.WindowSettings = config.Settings.CarsWindowSettings; //Настройки окна (положение, размер, состояние)
                }).SingleInstance();

            builder.RegisterType<ClientsEditorViewModel>() //Редактор клиентов
                .OnActivated(e =>
                {
                    e.Instance.WindowSettings = config.Settings.ClientsWindowSettings; //Настройки окна (положение, размер, состояние)
                }).SingleInstance();

            builder.RegisterType<ReportsWindowViewModel>() //Отчёты
                .OnActivated(e =>
                {
                    e.Instance.WindowSettings = config.Settings.ReportsWindowSettings; //Настройки окна (положение, размер, состояние)
                    e.Instance.ReportsFolder = config.Folders.Documents;
                    e.Instance.ReportMode = ReportMode.Applications;
                });

            builder.RegisterType<EventLogViewModel>() //Журнал событий
                .OnActivated(e =>
                {
                    e.Instance.WindowSettings = config.Settings.EventLogWindowSettings; //Настройки окна (положение, размер, состояние)
                    e.Instance.SetConfiguration(config.Config, config.Folders.EventReportFolder);
                });

            builder.RegisterType<RecipesEditorViewModel>() //Редактор рецептов
                .OnActivated(e =>
                {
                    e.Instance.WindowSettings = config.Settings.RecipeWindowSettings; //Настройки окна (положение, размер, состояние)
                    e.Instance.SetEditorSettings(config.Settings.RecipeEditorConfig);
                })
                .SingleInstance();

            builder.RegisterType<ApplicationsEditorViewModel>() //Редактор заявок
                .OnActivated(e =>
                {
                    e.Instance.LastSelectedItems = config.Settings.LastSelectedItemsInAppWindow; //Состояние последних выбранных элементов.
                    e.Instance.WindowSettings = config.Settings.AppEditorWindowSettings;
                })
                .SingleInstance();

            builder.RegisterType<MainViewModel>() 
                .OnActivated(e =>
                {
                    var appManager = e.Context.Resolve<L1ApplicationManagerViewModel>();
                    appManager.Main = e.Instance;
                    if (!ViewModelBase.IsInDesignModeStatic)
                    {
                        e.Instance.Title = ProgramIdentification.GetCurrentProgramName();
                    }
                    e.Instance.Settings = config.Settings.ApplicationSettings;
                })
                .SingleInstance();

            return builder.Build();
        }

        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            WindowManager.Instance.Initialize(Application.Current.MainWindow, Main);
            Main.OnWindowLoaded();
        }

        private void MainWindow_Closing(object sender, CancelEventArgs e)
        {
            Debug.WriteLine("Начало: MainWindow_Closing");
            Window window = (Window)sender;

            Debug.WriteLine("Конец: MainWindow_Closing");

            if (WindowManager.Instance.OpenMessageDialog(DialogIcons.Help, DialogButtons.YesNo,
                "Выход из программы",
                "Вы действительно хотите завершить работу приложения?") == UserDialogResult.No)
                e.Cancel = true;
            else
            {
                window.Closing -= MainWindow_Closing;
                try
                {
                    LocalConfiguration.Instance.SaveLocalSettings();
                    LocalConfiguration.Instance.SaveCurrentAppConfig();
                }
                catch (Exception ex)
                {
                    LogManager.Logger.AppendException(ex);
                }
            }
        }

        private void Current_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
        {
            LogManager.Logger.AppendException(e.Exception);
            MessageBox.Show(e.Exception.ToString());
        }

        #region Свойства

        public static ViewModelLocator Current
        {
            get { return _locator; }
        }

        public MainViewModel Main
        {
            get { return _container.Resolve<MainViewModel>(); }
        }

        public L1ApplicationManagerViewModel ApplicationsManager
        {
            get { return _container.Resolve<L1ApplicationManagerViewModel>(); }
        }

        public AccountControllerVm AccountController
        {
            get { return _container.Resolve<AccountControllerVm>(); }
        }

        public ShutdownViewModel Shutdown
        {
            get { return _container.Resolve<ShutdownViewModel>(); }
        }

        public CategoryEditorViewModel CategoryEditor
        {
            get { return _container.Resolve<CategoryEditorViewModel>(); }
        }

        public ApplicationsEditorViewModel ApplicationsEditor
        {
            get { return _container.Resolve<ApplicationsEditorViewModel>(); }
        }

        public RecipesEditorViewModel RecipesEditor
        {
            get { return _container.Resolve<RecipesEditorViewModel>(); }
        }

        public ComponentEditorViewModel ComponentEditor
        {
            get { return _container.Resolve<ComponentEditorViewModel>(); }
        }

        public ComponentSelectorViewModel ComponentsSelector
        {
            get { return _container.Resolve<ComponentSelectorViewModel>(); }
        }

        /// <summary>Редактор клиентов</summary>
        public ClientsEditorViewModel ClientsEditor
        {
            get { return _container.Resolve<ClientsEditorViewModel>(); }
        }

        public CarEditorViewModel CarsEditor
        {
            get { return _container.Resolve<CarEditorViewModel>(); }
        }

        public CommandManager CommonCommands
        {
            get { return _container.Resolve<CommandManager>(); }
        }

        public LauncherViewModel Launcher
        {
            get { return _container.Resolve<LauncherViewModel>(); }
        }

        public AboutDialogViewModel About
        {
            get { return _container.Resolve<AboutDialogViewModel>(); }
        }

        /// <summary>
        /// Возвращает новый экземпляр модели представления Отчётов
        /// </summary>
        public ReportsWindowViewModel NewReport
        {
            get { return _container.Resolve<ReportsWindowViewModel>(); }
        }

        /// <summary>
        /// Возвращает новый экземпляр модели представления Журнала событий
        /// </summary>
        public EventLogViewModel NewEventLog
        {
            get { return _container.Resolve<EventLogViewModel>(); }
        }


        #endregion

        #region Методы


        #endregion
    }

Вот решение проблемы с максимизацией окна
blogs.msdn.com/b/llobo/archive/2006/08/01/maximizi...

Но в конкретно этом примере есть проблема, там сбрасывается минимальный размер окна. Его тоже нужно задавать.