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

<!-- Чтобы выполнились сразу 2 действия, нужно в качестве Condition указать 1 у обоих действий -->
 <Publish Dialog="SettingsDlg" Control="Next" Event="DoAction" Value="DoMethodAction2" Order="1" >1</Publish>
<Publish Dialog="SettingsDlg" Control="Next" Event="NewDialog" Value="SettingsPreviewDlg" Order="2">1</Publish>

public class Person
    {
        public string Name { get; set; }

        public int Age { get; set; }
    }

class Program
    {
        static void Main(string[] args)
        {
            var source = new Person[]
                {
                    new Person { Age = 20, Name = "Сергей" },
                    new Person { Age = 32, Name = "Дмитрий" },
                    new Person { Age = 18, Name = "Андрей" }
                };

            var copy = new Person[source.Length];
            Array.Copy(source, copy, source.Length);

            DisplayPersons(copy);
            Console.WriteLine();

            int index = 0;
            foreach (Person person in copy)
            {
                Console.WriteLine(person.Name + " удалён из исходного массива");
                source[index++] = null;
            }

            if (source.Any(p => p != null))
            {
                Console.WriteLine("Не удалось удалить все элементы исходного массива.");
            }

            Console.ReadKey();
        }

        static void DisplayPersons(IEnumerable<Person> persons)
        {
            foreach (Person person in persons)
            {
                Console.WriteLine("Имя: {0}, возраст: {1}", person.Name, person.Age);
            }
        }
    }

<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;
        }
    }
}

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

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
    }

private void DoWork()
{
    Canvas CnMapField = new Canvas();

    Image[] images = CopyFrom<Image>(CnMapField.Children);
    foreach (Image img in images)
    {
        if (img.Margin.Left == x)
            CnMapField.Children.Remove(img);
    }
}

private T[] CopyFrom<T>(UIElementCollection collection) where T : UIElement
{
    var images = new List<T>(collection.Count);
    images.AddRange(collection.Cast<T>());
    return images.ToArray();
}

public DbPicture[] GetImages(string[] keys)
        {
            return _context.Pictures.Where(p => keys.Any(k => k == p.FileName)).ToArray();
        }