MARKUS

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

    <startup> 

        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2" />

    </startup>

</configuration>

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProjectGuid>{9D5B0CA0-329D-40AF-BA0D-B727080C19EB}</ProjectGuid>

    <OutputType>Exe</OutputType>

    <RootNamespace>Markus.Service.ConvertProcess</RootNamespace>

    <AssemblyName>Markus.Service.ConvertProcess</AssemblyName>

    <TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>

    <FileAlignment>512</FileAlignment>

    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>

    <Deterministic>true</Deterministic>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <PlatformTarget>AnyCPU</PlatformTarget>

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>bin\Debug\</OutputPath>

    <DefineConstants>DEBUG;TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <PlatformTarget>AnyCPU</PlatformTarget>

    <DebugType>pdbonly</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>bin\Release\</OutputPath>

    <DefineConstants>TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <ItemGroup>

    <Reference Include="System" />

    <Reference Include="System.Core" />

    <Reference Include="System.Xml.Linq" />

    <Reference Include="System.Data.DataSetExtensions" />

    <Reference Include="Microsoft.CSharp" />

    <Reference Include="System.Data" />

    <Reference Include="System.Net.Http" />

    <Reference Include="System.Xml" />

  </ItemGroup>

  <ItemGroup>

    <Compile Include="Program.cs" />

    <Compile Include="Properties\AssemblyInfo.cs" />

  </ItemGroup>

  <ItemGroup>

    <None Include="App.config">

      <SubType>Designer</SubType>

    </None>

  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

</Project>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Markus.ConvertProcessTest

{

    class Program

    {

        static void Main(string[] args)

        {

            while (true)

            {

                System.Threading.Thread.Sleep(10000);

            }

        }

    }

}

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

// 어셈블리에 대한 일반 정보는 다음 특성 집합을 통해 

// 제어됩니다. 어셈블리와 관련된 정보를 수정하려면

// 이러한 특성 값을 변경하세요.

[assembly: AssemblyTitle("Markus.ConvertProcessTest")]

[assembly: AssemblyDescription("")]

[assembly: AssemblyConfiguration("")]

[assembly: AssemblyCompany("")]

[assembly: AssemblyProduct("Markus.ConvertProcessTest")]

[assembly: AssemblyCopyright("Copyright ©  2020")]

[assembly: AssemblyTrademark("")]

[assembly: AssemblyCulture("")]

// ComVisible을 false로 설정하면 이 어셈블리의 형식이 COM 구성 요소에 

// 표시되지 않습니다. COM에서 이 어셈블리의 형식에 액세스하려면

// 해당 형식에 대해 ComVisible 특성을 true로 설정하세요.

[assembly: ComVisible(false)]

// 이 프로젝트가 COM에 노출되는 경우 다음 GUID는 typelib의 ID를 나타냅니다.

[assembly: Guid("9d5b0ca0-329d-40af-ba0d-b727080c19eb")]

// 어셈블리의 버전 정보는 다음 네 가지 값으로 구성됩니다.

//

//      주 버전

//      부 버전 

//      빌드 번호

//      수정 버전

//

// 모든 값을 지정하거나 아래와 같이 '*'를 사용하여 빌드 번호 및 수정 번호가 자동으로

// 지정되도록 할 수 있습니다.

// [assembly: AssemblyVersion("1.0.*")]

[assembly: AssemblyVersion("1.0.0.0")]

[assembly: AssemblyFileVersion("1.0.0.0")]

using System;

using System.Threading.Tasks;

using System.Windows.Input;

namespace Markus.Mvvm.ToolKit

{

    public class AsyncCommand : IAsyncCommand

    {

        public event EventHandler CanExecuteChanged;

        private bool _isExecuting;

        private readonly Func<Task> _execute;

        private readonly Func<bool> _canExecute;

        private readonly IErrorHandler _errorHandler;

        public AsyncCommand(

            Func<Task> execute,

            Func<bool> canExecute = null,

            IErrorHandler errorHandler = null)

        {

            _execute = execute;

            _canExecute = canExecute;

            _errorHandler = errorHandler;

        }

        public bool CanExecute()

        {

            return !_isExecuting && (_canExecute?.Invoke() ?? true);

        }

        public async Task ExecuteAsync()

        {

            if (CanExecute())

            {

                try

                {

                    _isExecuting = true;

                    await _execute();

                }

                finally

                {

                    _isExecuting = false;

                }

            }

            RaiseCanExecuteChanged();

        }

        public void RaiseCanExecuteChanged()

        {

            CanExecuteChanged?.Invoke(this, EventArgs.Empty);

        }

        #region Explicit implementations

        bool ICommand.CanExecute(object parameter)

        {

            return CanExecute();

        }

        void ICommand.Execute(object parameter)

        {

            ExecuteAsync().FireAndForgetSafeAsync(_errorHandler);

        }

#endregion

    }

	public class AsyncCommand<T> : IAsyncCommand<T>

    {

        public event EventHandler CanExecuteChanged;

        private bool _isExecuting;

        private readonly Func<T, Task> _execute;

        private readonly Func<T, bool> _canExecute;

        private readonly IErrorHandler _errorHandler;

        public AsyncCommand(Func<T, Task> execute, Func<T, bool> canExecute = null, IErrorHandler errorHandler = null)

        {

            _execute = execute;

            _canExecute = canExecute;

            _errorHandler = errorHandler;

        }

        public bool CanExecute(T parameter)

        {

            return !_isExecuting && (_canExecute?.Invoke(parameter) ?? true);

        }

        public async Task ExecuteAsync(T parameter)

        {

            if (CanExecute(parameter))

            {

                try

                {

                    _isExecuting = true;

                    await _execute(parameter);

                }

                finally

                {

                    _isExecuting = false;

                }

            }

            RaiseCanExecuteChanged();

        }

        public void RaiseCanExecuteChanged()

        {

            CanExecuteChanged?.Invoke(this, EventArgs.Empty);

        }

#region Explicit implementations

        bool ICommand.CanExecute(object parameter)

        {

            return CanExecute((T)parameter);

        }

        void ICommand.Execute(object parameter)

        {

            ExecuteAsync((T)parameter).FireAndForgetSafeAsync(_errorHandler);

        }

#endregion

    }

}

using System.Threading.Tasks;

using System.Windows.Input;

namespace Markus.Mvvm.ToolKit

{

    public interface IAsyncCommand : ICommand

    {

        Task ExecuteAsync();

        bool CanExecute();

    }

	public interface IAsyncCommand<T> : ICommand

    {

        Task ExecuteAsync(T parameter);

        bool CanExecute(T parameter);

    }

}

using System;

namespace Markus.Mvvm.ToolKit

{

    public interface IErrorHandler

    {

        void HandleError(Exception ex);

    }

}

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />

  <PropertyGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('$(TargetFramework)', '^net\d'))">

    <DefineConstants>NETFRAMEWORK</DefineConstants>

  </PropertyGroup>

  <PropertyGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('$(TargetFramework)', '^netstandard\d'))">

    <DefineConstants>NETSTANDARD</DefineConstants>

  </PropertyGroup>

  <PropertyGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('$(TargetFramework)', '^netcoreapp\d'))">

    <DefineConstants>NETCORE</DefineConstants>

  </PropertyGroup>

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProjectGuid>{9EFE95D6-9985-422A-A76F-285C8CF73617}</ProjectGuid>

    <OutputType>Library</OutputType>

    <AppDesignerFolder>Properties</AppDesignerFolder>

    <RootNamespace>Markus.Mvvm.ToolKit</RootNamespace>

    <AssemblyName>Markus.Mvvm.ToolKit</AssemblyName>

    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>

    <FileAlignment>512</FileAlignment>

    <Deterministic>true</Deterministic>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>bin\Debug\</OutputPath>

    <DefineConstants>TRACE;DEBUG</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

    <PlatformTarget>x64</PlatformTarget>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <DebugType>pdbonly</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>bin\Release\</OutputPath>

    <DefineConstants>TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <ItemGroup>

    <Reference Include="PresentationCore" />

    <Reference Include="PresentationFramework" />

    <Reference Include="System" />

    <Reference Include="System.Core" />

    <Reference Include="System.Xaml" />

    <Reference Include="System.Xml.Linq" />

    <Reference Include="System.Data.DataSetExtensions" />

    <Reference Include="Microsoft.CSharp" />

    <Reference Include="System.Data" />

    <Reference Include="System.Net.Http" />

    <Reference Include="System.Xml" />

    <Reference Include="WindowsBase" />

  </ItemGroup>

  <ItemGroup>

    <Compile Include="AsyncCommand\AsyncCommand.cs" />

    <Compile Include="RelayCommand\EventRaiser.cs" />

    <Compile Include="RelayCommand\RelayCommand.cs" />

    <Compile Include="AsyncCommand\IAsyncCommand.cs" />

    <Compile Include="AsyncCommand\IErrorHandler.cs" />

    <Compile Include="Notification.cs" />

    <Compile Include="Properties\AssemblyInfo.cs" />

    <Compile Include="TaskUtilities.cs" />

    <Compile Include="ViewModelBase.cs" />

  </ItemGroup>

  <ItemGroup>

    <Page Include="Themes\Generic.xaml">

      <Generator>MSBuild:Compile</Generator>

      <SubType>Designer</SubType>

    </Page>

  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

</Project>

using System;

using System.ComponentModel;

using System.Linq.Expressions;

namespace Markus.Mvvm.ToolKit

{

    public class NotifyExpectation : INotifyPropertyChanged

    {

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(Expression<Func<object>> propertyExpression)

        {

            PropertyChangedEventHandler handler = PropertyChanged;

            if (handler != null) handler(this, new PropertyChangedEventArgs(GetPropertyName(propertyExpression)));

        }

        private string GetPropertyName(Expression<Func<object>> propertyExpression)

        {

            var unaryExpression = propertyExpression.Body as UnaryExpression;

            var memberExpression = unaryExpression == null ? (MemberExpression)propertyExpression.Body : (MemberExpression)unaryExpression.Operand;

            var propertyName = memberExpression.Member.Name;

            return propertyName;

        }

    }

}

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

using System.Windows;

// 어셈블리에 대한 일반 정보는 다음 특성 집합을 통해 

// 제어됩니다. 어셈블리와 관련된 정보를 수정하려면

// 이러한 특성 값을 변경하세요.

[assembly: AssemblyTitle("Markus.Mvvm.ToolKit")]

[assembly: AssemblyDescription("")]

[assembly: AssemblyConfiguration("")]

[assembly: AssemblyCompany("")]

[assembly: AssemblyProduct("Markus.Mvvm.ToolKit")]

[assembly: AssemblyCopyright("Copyright ©  2019")]

[assembly: AssemblyTrademark("")]

[assembly: AssemblyCulture("")]

// ComVisible을 false로 설정하면 이 어셈블리의 형식이 COM 구성 요소에 

// 표시되지 않습니다. COM에서 이 어셈블리의 형식에 액세스하려면

// 해당 형식에 대해 ComVisible 특성을 true로 설정하세요.

[assembly: ComVisible(false)]

[assembly: ThemeInfo(

    ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located

                                     //(used if a resource is not found in the page, 

                                     // or application resource dictionaries)

    ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located

                                              //(used if a resource is not found in the page, 

                                              // app, or any theme specific resource dictionaries)

)]

// 이 프로젝트가 COM에 노출되는 경우 다음 GUID는 typelib의 ID를 나타냅니다.

[assembly: Guid("9efe95d6-9985-422a-a76f-285c8cf73617")]

// 어셈블리의 버전 정보는 다음 네 가지 값으로 구성됩니다.

//

//      주 버전

//      부 버전 

//      빌드 번호

//      수정 버전

//

// 모든 값을 지정하거나 아래와 같이 '*'를 사용하여 빌드 번호 및 수정 번호를

// 기본값으로 할 수 있습니다.

// [assembly: AssemblyVersion("1.0.*")]

[assembly: AssemblyVersion("1.0.0.0")]

[assembly: AssemblyFileVersion("1.0.0.0")]

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Mvvm.ToolKit

{

    public static class EventRaiser

    {

        public static void Raise(this EventHandler handler, object sender)

        {

            handler?.Invoke(sender, EventArgs.Empty);

        }

        public static void Raise<T>(this EventHandler<EventArgs<T>> handler, object sender, T value)

        {

            handler?.Invoke(sender, new EventArgs<T>(value));

        }

        public static void Raise<T>(this EventHandler<T> handler, object sender, T value) where T : EventArgs

        {

            handler?.Invoke(sender, value);

        }

        public static void Raise<T>(this EventHandler<EventArgs<T>> handler, object sender, EventArgs<T> value)

        {

            handler?.Invoke(sender, value);

        }

    }

    public class EventArgs<T> : EventArgs

    {

        public EventArgs(T value)

        {

            Value = value;

        }

        public T Value { get; private set; }

    }

}

using System;

using System.Collections.Generic;

using System.Diagnostics.CodeAnalysis;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Input;

namespace Markus.Mvvm.ToolKit

{

    public class RelayCommand<T> : ICommand

    {

        private readonly Predicate<T> _canExecute;

        private readonly Action<T> _execute;

        public RelayCommand(Action<T> execute)

           : this(execute, null)

        {

            _execute = execute;

        }

        public RelayCommand(Action<T> execute, Predicate<T> canExecute)

        {

            if (execute == null)

            {

                throw new ArgumentNullException("execute");

            }

            _execute = execute;

            _canExecute = canExecute;

        }

        public bool CanExecute(object parameter)

        {

            return _canExecute == null || _canExecute((T)parameter);

        }

        public void Execute(object parameter)

        {

            _execute((T)parameter);

        }

        public event EventHandler CanExecuteChanged

        {

            add { CommandManager.RequerySuggested += value; }

            remove { CommandManager.RequerySuggested -= value; }

        }

    }

    public class RelayCommand : ICommand

    {

        private readonly Predicate<object> _canExecute;

        private readonly Action<object> _execute;

        public RelayCommand(Action<object> execute)

           : this(execute, null)

        {

            _execute = execute;

        }

        public RelayCommand(Action<object> execute, Predicate<object> canExecute)

        {

            if (execute == null)

            {

                throw new ArgumentNullException("execute");

            }

            _execute = execute;

            _canExecute = canExecute;

        }

        public bool CanExecute(object parameter)

        {

            return _canExecute == null || _canExecute(parameter);

        }

        public void Execute(object parameter)

        {

            _execute(parameter);

        }

        // Ensures WPF commanding infrastructure asks all RelayCommand objects whether their

        // associated views should be enabled whenever a command is invoked 

        public event EventHandler CanExecuteChanged

        {

            add

            {

                CommandManager.RequerySuggested += value;

                CanExecuteChangedInternal += value;

            }

            remove

            {

                CommandManager.RequerySuggested -= value;

                CanExecuteChangedInternal -= value;

            }

        }

        private event EventHandler CanExecuteChangedInternal;

        public void RaiseCanExecuteChanged()

        {

            CanExecuteChangedInternal.Raise(this);

        }

    }

}

using System;

using System.Threading.Tasks;

namespace Markus.Mvvm.ToolKit

{

    public static class TaskUtilities

    {

#pragma warning disable RECS0165 // Asynchronous methods should return a Task instead of void

        public static async void FireAndForgetSafeAsync(this Task task, IErrorHandler handler = null)

#pragma warning restore RECS0165 // Asynchronous methods should return a Task instead of void

        {

            try

            {

                await task;

            }

            catch (Exception ex)

            {

                handler?.HandleError(ex);

            }

        }

    }

}

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

                       xmlns:local="clr-namespace:Markus.Mvvm.ToolKit"

                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <!--<Style TargetType="local:PackIcon">

        <Setter Property="Width" Value="20" />

        <Setter Property="Height" Value="20" />

        <Setter Property="Kind"  Value="Abc"/>

        <Setter Property="IconBrush" Value="White"/>

        <Setter Property="Template">

            <Setter.Value>

                <ControlTemplate>

                    <Grid Width="{TemplateBinding Width}" Height="{TemplateBinding Height}">

                        <Path x:Name="PART_PATH" Fill="{TemplateBinding IconBrush}" Stroke="{TemplateBinding IconBrush}"/>

                    </Grid>

                </ControlTemplate>

            </Setter.Value>

        </Setter>

    </Style>-->

</ResourceDictionary>

using System.ComponentModel;

using System.Windows;

using System.Windows.Input;

namespace Markus.Mvvm.ToolKit

{

    public abstract class ViewModelBase : NotifyExpectation

    {

        #region ViewModel Base Binding

        ViewModelBase viewModel;

        public ViewModelBase ViewModel

        {

            get { return viewModel; }

            set { viewModel = value; }

        }

        public string Name

        {

            get { return ViewModel?.Name; }

            set

            {

                if (ViewModel?.Name != value)

                {

                    ViewModel.Name = value;

                    OnPropertyChanged(()=>Name);

                }

            }

        }

        private bool isAcitve;

        public bool IsAcitve

        {

            get { return isAcitve; }

            set

            {

                if (isAcitve != value)

                {

                    isAcitve = value;

                    OnPropertyChanged(() => isAcitve);

                }

            }

        }

        #endregion

        #region Command

        private ICommand _ClosingCommand;

        public ICommand ClosingCommand

        {

            get => _ClosingCommand ?? (_ClosingCommand = new RelayCommand(param => this.Closed()));

        }

        private ICommand _LoadedCommand;

        public ICommand LoadedCommand

        {

            get => _LoadedCommand ?? (_LoadedCommand = new RelayCommand(param => this.Loaded()));

        }

        #endregion Command

        public virtual void Closed()

        {

            isAcitve = false;

        }

        public virtual void Loaded()

        {

            isAcitve = true;

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Linq.Expressions;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public static class CollectionExtensions

    {

        //public static void Update<T>(this IList<T> source,IList<T> Target,IList<string> Keys)

        //{

        //    for (int i = source.Count; i == 0 ; --i)

        //    {

        //        var item = source[i];

        //         Target.Where(f=>)

        //        item.GetType().GetProperty()

        //    }

        //}

        /// <summary>

        /// Changes all elements of IEnumerable by the change function

        /// </summary>

        /// <param name="enumerable">The enumerable where you want to change stuff</param>

        /// <param name="change">The way you want to change the stuff</param>

        /// <returns>An IEnumerable with all changes applied</returns>

        public static IEnumerable<T> Change<T>(this IEnumerable<T> enumerable, Func<T, T> change)

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(change, "change");

            foreach (var item in enumerable)

            {

                yield return change(item);

            }

        }

        /// <summary>

        /// Changes all elements of IEnumerable by the change function, that fullfill the where function

        /// </summary>

        /// <param name="enumerable">The enumerable where you want to change stuff</param>

        /// <param name="change">The way you want to change the stuff</param>

        /// <param name="where">The function to check where changes should be made</param>

        /// <returns>

        /// An IEnumerable with all changes applied

        /// </returns>

        public static IEnumerable<T> ChangeWhere<T>(this IEnumerable<T> enumerable,

                                                    Func<T, T> change,

                                                    Func<T, bool> @where)

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(change, "change");

            ArgumentCheck.IsNullorWhiteSpace(@where, "where");

            foreach (var item in enumerable)

            {

                if (@where(item))

                {

                    yield return change(item);

                }

                else

                {

                    yield return item;

                }

            }

        }

        public static class ArgumentCheck

        {

            /// <summary>

            /// Checks if a value is string or any other object if it is string

            /// it checks for nullorwhitespace otherwhise it checks for null only

            /// </summary>

            /// <typeparam name="T">Type of the item you want to check</typeparam>

            /// <param name="item">The item you want to check</param>

            /// <param name="nameOfTheArgument">Name of the argument</param>

            public static void IsNullorWhiteSpace<T>(T item, string nameOfTheArgument = "")

            {

                Type type = typeof(T);

                if (type == typeof(string) ||

                    type == typeof(String))

                {

                    if (string.IsNullOrWhiteSpace(item as string))

                    {

                        throw new ArgumentException(nameOfTheArgument + " is null or Whitespace");

                    }

                }

                else

                {

                    if (item == null)

                    {

                        throw new ArgumentException(nameOfTheArgument + " is null");

                    }

                }

            }

        }

        /// <summary>

        /// Changes all elements of IEnumerable by the change function that do not fullfill the except function

        /// </summary>

        /// <param name="enumerable">The enumerable where you want to change stuff</param>

        /// <param name="change">The way you want to change the stuff</param>

        /// <param name="where">The function to check where changes should not be made</param>

        /// <returns>

        /// An IEnumerable with all changes applied

        /// </returns>

        public static IEnumerable<T> ChangeExcept<T>(this IEnumerable<T> enumerable,

                                                     Func<T, T> change,

                                                     Func<T, bool> @where)

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(change, "change");

            ArgumentCheck.IsNullorWhiteSpace(@where, "where");

            foreach (var item in enumerable)

            {

                if (!@where(item))

                {

                    yield return change(item);

                }

                else

                {

                    yield return item;

                }

            }

        }

        /// <summary>

        /// Update all elements of IEnumerable by the update function (only works with reference types)

        /// </summary>

        /// <param name="enumerable">The enumerable where you want to change stuff</param>

        /// <param name="update">The way you want to change the stuff</param>

        /// <returns>

        /// The same enumerable you passed in

        /// </returns>

        public static IEnumerable<T> Update<T>(this IEnumerable<T> enumerable,

                                               Action<T> update) where T : class

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(update, "update");

            foreach (var item in enumerable)

            {

                update(item);

            }

            return enumerable;

        }

        /// <summary>

        /// Update all elements of IEnumerable by the update function (only works with reference types)

        /// where the where function returns true

        /// </summary>

        /// <param name="enumerable">The enumerable where you want to change stuff</param>

        /// <param name="update">The way you want to change the stuff</param>

        /// <param name="where">The function to check where updates should be made</param>

        /// <returns>

        /// The same enumerable you passed in

        /// </returns>

        public static IEnumerable<T> UpdateWhere<T>(this IEnumerable<T> enumerable,

                                               Action<T> update, Func<T, bool> where) where T : class

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(update, "update");

            foreach (var item in enumerable)

            {

                if (where(item))//UpdateWhere에서 맨마지막 조건

                {//그리드 collection 돌면서 where절 조건 만족하면 update

                    update(item);//그리드 status와 디비 status 같으면  업데이트

                }//업데이트 함수 

            }

            return enumerable;

        }

        /// <summary>

        /// Update all elements of IEnumerable by the update function (only works with reference types)

        /// Except the elements from the where function

        /// </summary>

        /// <param name="enumerable">The enumerable where you want to change stuff</param>

        /// <param name="update">The way you want to change the stuff</param>

        /// <param name="where">The function to check where changes should not be made</param>

        /// <returns>

        /// The same enumerable you passed in

        /// </returns>

        public static IEnumerable<T> UpdateExcept<T>(this IEnumerable<T> enumerable,

                                               Action<T> update, Func<T, bool> where) where T : class

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(update, "update");

            foreach (var item in enumerable)

            {

                if (!where(item))

                {

                    update(item);

                }

            }

            return enumerable;

        }

    }

}

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public class Encrypt

    {

        public static class AESEncrypter

        {

            private static RijndaelManaged _rManaged = new RijndaelManaged();

            private static UTF8Encoding _utf8Encoder = new UTF8Encoding();

            static AESEncrypter()

            {

                MD5 _md5 = new MD5CryptoServiceProvider();

                _rManaged.KeySize = 256;

                _rManaged.BlockSize = 128;

                _rManaged.Mode = CipherMode.CBC;

                _rManaged.Padding = PaddingMode.PKCS7;

                _rManaged.Key = _md5.ComputeHash(_utf8Encoder.GetBytes("zxcvbnmasdfghjklqwertyuiop098765"));

                _rManaged.IV = _md5.ComputeHash(_utf8Encoder.GetBytes("qwertyuiopasdfghjklzxcvbnm123456"));

            }

            /// <summary>암호화</summary>

            /// <param name="val">암호화할 값</param>

            /// <returns>암호화된 값</returns>

            public static string Encrypt(string val)

            {

                string _resVal = string.Empty;

                byte[] _utf8Val = null;

                byte[] _encryptVal = null;

                ICryptoTransform tForm = _rManaged.CreateEncryptor();

                try

                {

                    if (!string.IsNullOrEmpty(val))

                    {

                        _utf8Val = _utf8Encoder.GetBytes(val);

                        _encryptVal = tForm.TransformFinalBlock(_utf8Val, 0, _utf8Val.Length);

                        _resVal = Convert.ToBase64String(_encryptVal);

                    }

                    else

                        _resVal = string.Empty;

                }

                catch

                {

                    _resVal = string.Empty;

                }

                return _resVal;

            }

            /// <summary>복호화</summary>

            /// <param name="val">복호화할 값</param>

            /// <returns>복호화된 값</returns>

            public static string Decrypt(string val)

            {

                string _resVal = string.Empty;

                byte[] _decryptVal = null;

                byte[] _encryptVal = null;

                ICryptoTransform tForm = _rManaged.CreateDecryptor();

                try

                {

                    if (!string.IsNullOrEmpty(val))

                    {

                        _encryptVal = Convert.FromBase64String(val);

                        _decryptVal = tForm.TransformFinalBlock(_encryptVal, 0, _encryptVal.Length);

                        _resVal = _utf8Encoder.GetString(_decryptVal);

                    }

                    else

                        _resVal = string.Empty;

                }

                catch

                {

                    _resVal = string.Empty;

                }

                return _resVal;

            }

        }

    }

}

/*

   Copyright 2013 Christoph Gattnar

   Licensed under the Apache License, Version 2.0 (the "License");

   you may not use this file except in compliance with the License.

   You may obtain a copy of the License at

	   http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software

   distributed under the License is distributed on an "AS IS" BASIS,

   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   See the License for the specific language governing permissions and

   limitations under the License.

*/

using System;

using System.Collections.Generic;

using System.IO;

using System.Reflection;

namespace Markus.Service.Extensions

{

	public static class GenericPluginLoader<T>

	{

		public static ICollection<T> LoadPlugins(string path)

		{

			string[] dllFileNames = null;

			if(Directory.Exists(path))

			{

				dllFileNames = Directory.GetFiles(path, "*.dll");

				ICollection<Assembly> assemblies = new List<Assembly>(dllFileNames.Length);

				foreach(string dllFile in dllFileNames)

				{

					AssemblyName an = AssemblyName.GetAssemblyName(dllFile);

					Assembly assembly = Assembly.Load(an);

					assemblies.Add(assembly);

				}

				Type pluginType = typeof(T);

				ICollection<Type> pluginTypes = new List<Type>();

				foreach(Assembly assembly in assemblies)

				{

					if(assembly != null)

					{

						Type[] types = assembly.GetTypes();

						foreach(Type type in types)

						{

							if(type.IsInterface || type.IsAbstract)

							{

								continue;

							}

							else

							{

								if(type.GetInterface(pluginType.FullName) != null)

								{

									pluginTypes.Add(type);

								}

							}

						}

					}

				}

				ICollection<T> plugins = new List<T>(pluginTypes.Count);

				foreach(Type type in pluginTypes)

				{

					T plugin = (T)Activator.CreateInstance(type);

					plugins.Add(plugin);

				}

				return plugins;

			}

			return null;

		}

	}

}

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Management;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public static class ProcessExtension

    {

        /// <summary>

        /// 프로세스의 명령줄을 가져온다.

        /// </summary>

        /// <param name="process"></param>

        /// <returns></returns>

        public static ProcessArguments Arguments(this Process process)

        {

            ProcessArguments result = new ProcessArguments();

            var commandLine = ProcessCommandLinesQuery(process.Id);

            try

            {

                result.WorkingDirectory = ProcessWorkingDirectory(commandLine);

                result.CommandLine = SplitArguments(RemoveCommadLinesFilePath(commandLine)).ToList();

            }

            catch (Exception ex)

            {

                System.Diagnostics.Debug.WriteLine(ex.ToString());

            }

            return result;

        }

        /// <summary>

        /// 프로세스의 실행 경로

        /// </summary>

        /// <param name="process"></param>

        /// <returns></returns>

        public static string WorkingDirectory(this Process process)

        {

            var commandLine = ProcessCommandLinesQuery(process.Id);

            return ProcessWorkingDirectory(commandLine);

        }

        private static string ProcessCommandLinesQuery(int processId)

        {

            string result = "";

            string wmiQuery = string.Format("select CommandLine from Win32_Process where ProcessId ='{0}'", processId);

            ManagementObjectSearcher searcher = new ManagementObjectSearcher(wmiQuery);

            ManagementObjectCollection retObjectCollection = searcher.Get();

            if (retObjectCollection.Count > 0)

            {

                if (retObjectCollection.Cast<ManagementObject>().First()["CommandLine"] != null)

                {

                    result = retObjectCollection.Cast<ManagementObject>().First()["CommandLine"]?.ToString();

                }

                else

                {

                    result = "";

                }

            }

            return result;

        }

        private static string ProcessWorkingDirectory(string commandLine)

        {

           if (IO.FileExists(commandLine.Replace("\"", "")))

            {

                var file = new System.IO.FileInfo(commandLine.Replace("\"", ""));

                return file.DirectoryName;

            }

            var splitCommand = commandLine.Split(' ');

            string filePath = "";

            for (int i = 0; i < splitCommand.Count(); i++)

            {

                filePath += " " + splitCommand[i].Replace("\"", "");

                if (IO.FileExists(filePath))

                {

                    System.IO.FileInfo info = new System.IO.FileInfo(filePath);

                    filePath = info.DirectoryName;

                    break;

                }

                else if (i == splitCommand.Count() - 1)

                {

                    var firstCmd = splitCommand.First();

                    if (firstCmd.StartsWith("\"") && firstCmd.EndsWith("\""))

                    {

                        filePath = firstCmd.Replace("\"", "");

                    }

                }

                else

                {

                    filePath = commandLine;

                }

            }

            return filePath;

        }

        /// <summary>

        /// command line에서 처음에 있는 파일 경로가 \"로 묶여 있거나 묶여 있지 않은 경우가 있다.

        /// 파일 경로를 제거하기 위한 코드

        /// </summary>

        /// <param name="commandLine"></param>

        /// <returns></returns>

        private static string RemoveCommadLinesFilePath(string commandLine)

        {

            string result = "";

            var splitCommand = commandLine.Split(' ');

            string filePath = "";

            for (int i = 0; i < splitCommand.Count(); i++)

            {

                filePath += " " + splitCommand[i];