/ - Diff - MARKUS - 일정관리

     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>
       </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="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="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>
       <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;
     // 어셈블리에 대한 일반 정보는 다음 특성 집합을 통해
     // 제어됩니다. 어셈블리와 관련된 정보를 수정하려면
     // 이러한 특성 값을 변경하세요.
     [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)]
     // 이 프로젝트가 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);
+                }
+            }
+        }
+    }

     namespace Markus.Mvvm.ToolKit
+    {
         public abstract class ViewModelBase : NotifyExpectation
+        {
             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);
+                    }
+                }
+            }
+        }
+    }

     <?xml version="1.0" encoding="utf-8"?>
     <?xml version="1.0" encoding="utf-8"?>
     <configuration>
         <startup>
             <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
             <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1"/>
         </startup>
       <runtime>
         <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
           <dependentAssembly>
           <probing privatePath="bin"/>
           <!--<dependentAssembly>
             <assemblyIdentity name="CommonServiceLocator" publicKeyToken="489b6accfaf20ef0" culture="neutral" />
             <bindingRedirect oldVersion="0.0.0.0-2.0.4.0" newVersion="2.0.4.0" />
           </dependentAssembly>
           </dependentAssembly>-->
         </assemblyBinding>
       </runtime>
         <system.serviceModel>
             <bindings>
                 <basicHttpBinding>
                     <binding name="BasicHttpBinding_IStationService" />
                     <binding name="BasicHttpBinding_IStationService"/>
                 </basicHttpBinding>
             </bindings>
             <client>
                 <endpoint address="http://192.168.0.76:9111/StationService" binding="basicHttpBinding" bindingConfiguration="BasicHttpBinding_IStationService" contract="StationService.IStationService" name="BasicHttpBinding_IStationService" />
                 <endpoint address="http://192.168.0.76:9111/StationService" binding="basicHttpBinding" bindingConfiguration="BasicHttpBinding_IStationService" contract="StationService.IStationService" name="BasicHttpBinding_IStationService"/>
             </client>
         </system.serviceModel>
     </configuration>

         /// </summary>
         public partial class App : Application
+        {
             private System.Windows.Forms.NotifyIcon _notifyIcon;
             private bool _isExit;
             //private System.Windows.Forms.NotifyIcon _notifyIcon;
             //private bool _isExit;
             protected override void OnStartup(StartupEventArgs e)
+            {
-...
             private void CreateContextMenu()
+            {
                 _notifyIcon.ContextMenuStrip =
                   new System.Windows.Forms.ContextMenuStrip();
                 _notifyIcon.ContextMenuStrip.Items.Add("MainWindow...").Click += (s, e) => ShowMainWindow();
                 _notifyIcon.ContextMenuStrip.Items.Add("Exit").Click += (s, e) => ExitApplication();
                 //_notifyIcon.ContextMenuStrip =
                 //  new System.Windows.Forms.ContextMenuStrip();
                 //_notifyIcon.ContextMenuStrip.Items.Add("MainWindow...").Click += (s, e) => ShowMainWindow();
                 //_notifyIcon.ContextMenuStrip.Items.Add("Exit").Click += (s, e) => ExitApplication();
+            }
             private void ExitApplication()
+            {
                 _isExit = true;
                 MainWindow.Close();
                 _notifyIcon.Dispose();
                 _notifyIcon = null;
                 //_isExit = true;
                 //MainWindow.Close();
                 //_notifyIcon.Dispose();
                 //_notifyIcon = null;
+            }
             private void ShowMainWindow()
-...
+                }
+            }
             private void MainWindow_Closing(object sender, CancelEventArgs e)
+            {
                 if (!_isExit)
+                {
                     e.Cancel = true;
                     MainWindow.Hide(); // A hidden window can be shown again, a closed one not
+                }
+            }
             //private void MainWindow_Closing(object sender, CancelEventArgs e)
             //{
             //    if (!_isExit)
             //    {
             //        e.Cancel = true;
             //        MainWindow.Hide(); // A hidden window can be shown again, a closed one not
             //    }
             //}
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.ComponentModel;
     using System.Linq;
     using System.Linq.Expressions;
     using System.Text;
     using System.Threading.Tasks;
     namespace Markus.Service.StationController.Base
+    {
         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 Microsoft.EntityFrameworkCore.Metadata.Internal;
     using System;
     using System.Collections.Generic;
     using System.ComponentModel;
     using System.Linq;
     using System.Linq.Expressions;
     using System.Text;
     using System.Threading.Tasks;
     namespace Markus.Service.StationController.Base
+    {
         public abstract class ViewModelBase : Base.NotifyExpectation
+        {
             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);
+                    }
+                }
+            }
+        }
+    }

             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
             xmlns:md="http://materialdesigninxaml.net/winfx/xaml/themes"
             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
             xmlns:materialEx="clr-namespace:MaterialDesignExtensions.Controls;assembly=MaterialDesignExtensions"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mvvmToolkit="clr-namespace:Markus.Mvvm.ToolKit;assembly=Markus.Mvvm.ToolKit"
             TextElement.Foreground="{DynamicResource MaterialDesignBody}"
             mc:Ignorable="d"
             xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
             xmlns:local="clr-namespace:Markus.Service.StationController.ViewModel"
             Title="Markus Convert Service" Height="450" Width="800" Foreground="{DynamicResource {x:Static SystemColors.MenuHighlightBrushKey}}">
         <i:Interaction.Triggers>
             <i:EventTrigger  EventName="Loaded">
                 <i:InvokeCommandAction Command="{Binding LoadedCommand}"/>
             </i:EventTrigger>
             <i:EventTrigger  EventName="Closing">
                 <i:InvokeCommandAction Command="{Binding ClosingCommand}"/>
             </i:EventTrigger>
         </i:Interaction.Triggers>
         <Window.DataContext>
             <local:MainViewModel/>
         </Window.DataContext>
             <materialDesign:DialogHost x:Name="m_dialogHost" Identifier="dialogHost" DialogTheme="Light">
         <materialDesign:DialogHost x:Name="m_dialogHost" Identifier="dialogHost" DialogTheme="Light">
                 <materialDesign:DrawerHost IsLeftDrawerOpen="{Binding Path=IsNavigationDrawerOpen, ElementName=appBar}" LeftDrawerBackground="{DynamicResource MaterialDesignBackground}">
                     <!--<materialDesign:DrawerHost.LeftDrawerContent>
                     <materialEx:SideNavigation Items="{Binding NavigationItems,Mode=OneTime}" Width="280"/>
-...
                                 <materialDesign:MaterialDataGridTextColumn Header="Status" Binding="{Binding ConvertState}"/>
                                 <materialDesign:MaterialDataGridTextColumn Header="Current Page" Binding="{Binding CurrentPageNo}"/>
                                 <materialDesign:MaterialDataGridTextColumn Header="TotalPage" Binding="{Binding TotalPage}"/>
                                 <materialDesign:MaterialDataGridTextColumn Header="Originfile" Binding="{Binding OriginfilePath}"/>
                                 <materialDesign:MaterialDataGridTextColumn Header="Output Path" Binding="{Binding ConvertPath}"/>
                             </DataGrid.Columns>

     <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>
         <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
         <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
         <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
         <ProjectGuid>{9D993D6E-3A7B-470E-B5AD-D2CF89633F1C}</ProjectGuid>
-...
         <DefineConstants>DEBUG;TRACE</DefineConstants>
         <ErrorReport>prompt</ErrorReport>
         <WarningLevel>4</WarningLevel>
         <Prefer32Bit>true</Prefer32Bit>
         <Prefer32Bit>false</Prefer32Bit>
       </PropertyGroup>
       <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
         <PlatformTarget>AnyCPU</PlatformTarget>
-...
         <Reference Include="Microsoft.EntityFrameworkCore">
           <HintPath>C:\Program Files\dotnet\sdk\NuGetFallbackFolder\microsoft.entityframeworkcore\2.2.0\lib\netstandard2.0\Microsoft.EntityFrameworkCore.dll</HintPath>
         </Reference>
         <Reference Include="Microsoft.Expression.Interactions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
           <HintPath>..\packages\System.Windows.Interactivity.WPF.2.0.20525\lib\net40\Microsoft.Expression.Interactions.dll</HintPath>
         </Reference>
         <Reference Include="netstandard, Version=2.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51" />
         <Reference Include="System" />
         <Reference Include="System.Data" />
-...
         <Reference Include="System.Runtime.Serialization" />
         <Reference Include="System.ServiceModel" />
         <Reference Include="System.Windows.Forms" />
         <Reference Include="System.Windows.Interactivity, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
           <HintPath>..\packages\System.Windows.Interactivity.WPF.2.0.20525\lib\net40\System.Windows.Interactivity.dll</HintPath>
         </Reference>
         <Reference Include="System.Xml" />
         <Reference Include="Microsoft.CSharp" />
         <Reference Include="System.Core" />
-...
           <Generator>MSBuild:Compile</Generator>
           <SubType>Designer</SubType>
         </ApplicationDefinition>
         <Compile Include="Base\Notification.cs" />
         <Compile Include="Base\ViewModelBase.cs" />
         <Compile Include="ViewModel\MainViewModel.cs" />
         <Page Include="MainWindow.xaml">
           <Generator>MSBuild:Compile</Generator>
-...
         <None Include="Resources\Tranfer_Error.ico" />
       </ItemGroup>
       <ItemGroup>
         <ProjectReference Include="..\Markus.Mvvm.ToolKit\Markus.Mvvm.ToolKit.csproj">
           <Project>{9efe95d6-9985-422a-a76f-285c8cf73617}</Project>
           <Name>Markus.Mvvm.ToolKit</Name>
         </ProjectReference>
         <ProjectReference Include="..\Markus.Service.Extensions\Markus.Service.Extensions.csproj">
           <Project>{5f983789-3e8f-4f9a-a601-138c3a83ca5f}</Project>
           <Name>Markus.Service.Extensions</Name>
         </ProjectReference>
       </ItemGroup>
       <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
       <PropertyGroup>
         <PostBuildEvent>mkdir $(TargetDir)Bin
     MOVE $(TargetDir)*.dll $(TargetDir)Bin\
     </PostBuildEvent>
       </PropertyGroup>
     </Project>

     using System.ServiceModel;
     using System.Text;
     using System.Threading.Tasks;
     using System.Windows.Input;
     using Markus.Mvvm.ToolKit;
     using Markus.Service.Helper;
     using Markus.Service.StationController.StationService;
     using MaterialDesignExtensions.Model;
     namespace Markus.Service.StationController.ViewModel
+    {
         public class MainViewModel : Base.ViewModelBase
         public class MainViewModel : ViewModelBase
+        {
             StationService.StationServiceClient client;
             System.Windows.Threading.DispatcherTimer timer;
             bool IsTimer;
             public MainViewModel()
             #region Command
             private ICommand _ClosingCommand;
             public ICommand ClosingCommand
+            {
                 get => _ClosingCommand ?? (_ClosingCommand = new RelayCommand(param => this.Closing()));
+            }
             private ICommand _LoadedCommand;
             public ICommand LoadedCommand
+            {
                 get => _LoadedCommand ?? (_LoadedCommand = new RelayCommand(param => this.Loaded()));
+            }
             #endregion Command
             #region 프로퍼티
             private string id;
             public string Id
+            {
                 get => id; set
+                {
                     id = value;
                     OnPropertyChanged(() => Id);
+                }
+            }
             private List<StationService.ConvertItem> aliveItems;
             public List<ConvertItem> AliveItems
+            {
                 get => aliveItems; set
+                {
                     aliveItems = value;
                     OnPropertyChanged(() => AliveItems);
+                }
+            }
             private List<INavigationItem> navigationItems;
             public List<INavigationItem> NavigationItems
+            {
                 get => navigationItems; set
+                {
                     navigationItems = value;
                     OnPropertyChanged(() => navigationItems);
+                }
+            }
             private INavigationItem selectNavigationItem;
             public INavigationItem SelectNavigationItem
+            {
                 get => selectNavigationItem; set
+                {
                     selectNavigationItem = value;
                     OnPropertyChanged(() => SelectNavigationItem);
+                }
+            }
             #endregion 프로퍼티
             private void Loaded()
+            {
                 IsTimer = true;
                 ServiceConnection();
                 System.Windows.Threading.DispatcherTimer timer = new System.Windows.Threading.DispatcherTimer();
                 timer = new System.Windows.Threading.DispatcherTimer();
                 timer.Interval = new TimeSpan(0, 0, 1);
                 timer.Tick += Timer_Tick;
                 timer.Start();
-...
                 SelectNavigationItem = NavigationItems.First();
+            }
             private void Closing()
+            {
                 IsTimer = false;
+            }
             private void ServiceConnection()
+            {
                 try
-...
+            {
                 try
+                {
                     if (!IsTimer)
+                    {
                         timer.Stop();
+                    }
                     client.AliveConvertListAsync();
+                }
                 catch (Exception ex)
-...
                 AliveItems = e.Result;
+            }
             private string id;
             public string Id
+            {
                 get => id; set
+                {
                     id = value;
                     OnPropertyChanged(() => Id);
+                }
+            }
             private List<StationService.ConvertItem> aliveItems;
             public List<ConvertItem> AliveItems
+            {
                 get => aliveItems; set
+                {
                     aliveItems = value;
                     OnPropertyChanged(() => AliveItems);
+                }
+            }
             private List<INavigationItem> navigationItems;
             public List<INavigationItem> NavigationItems
+            {
                 get => navigationItems; set
+                {
                     navigationItems = value;
                     OnPropertyChanged(() => navigationItems);
+                }
+            }
             private INavigationItem selectNavigationItem;
             public INavigationItem SelectNavigationItem
+            {
                 get => selectNavigationItem; set
+                {
                     selectNavigationItem = value;
                     OnPropertyChanged(() => SelectNavigationItem);
+        }
+    }
+        }

ConvertService/ServiceBase/Markus.Service.StationController/packages.config
4	4	<package id="MaterialDesignExtensions" version="2.6.0" targetFramework="net461" />
5	5	<package id="MaterialDesignThemes" version="2.5.1" targetFramework="net461" />
6	6	<package id="Microsoft.CSharp" version="4.5.0" targetFramework="net45" />
7		<package id="Salaros.ConfigParser" version="0.3.3" targetFramework="net45" />
	7	<package id="Salaros.ConfigParser" version="0.3.3" targetFramework="net461" />
	8	<package id="System.Windows.Interactivity.WPF" version="2.0.20525" targetFramework="net461" />
8	9	</packages>

     EndProject
     Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Markus.Service.Extensions", "Markus.Service.Extensions\Markus.Service.Extensions.csproj", "{5F983789-3E8F-4F9A-A601-138C3A83CA5F}"
     EndProject
     Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Markus.Mvvm.ToolKit", "Markus.Mvvm.ToolKit\Markus.Mvvm.ToolKit.csproj", "{9EFE95D6-9985-422A-A76F-285C8CF73617}"
     EndProject
     Global
     	GlobalSection(SolutionConfigurationPlatforms) = preSolution
     		AppVeyor|Any CPU = AppVeyor|Any CPU
-...
     		{5F983789-3E8F-4F9A-A601-138C3A83CA5F}.Release|x64.Build.0 = Release|x64
     		{5F983789-3E8F-4F9A-A601-138C3A83CA5F}.Release|x86.ActiveCfg = Release|Any CPU
     		{5F983789-3E8F-4F9A-A601-138C3A83CA5F}.Release|x86.Build.0 = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.AppVeyor|Any CPU.ActiveCfg = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.AppVeyor|Any CPU.Build.0 = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.AppVeyor|x64.ActiveCfg = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.AppVeyor|x64.Build.0 = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.AppVeyor|x86.ActiveCfg = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.AppVeyor|x86.Build.0 = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Debug|Any CPU.Build.0 = Debug|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Debug|x64.ActiveCfg = Debug|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Debug|x64.Build.0 = Debug|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Debug|x86.ActiveCfg = Debug|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Debug|x86.Build.0 = Debug|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Release|Any CPU.ActiveCfg = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Release|Any CPU.Build.0 = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Release|x64.ActiveCfg = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Release|x64.Build.0 = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Release|x86.ActiveCfg = Release|Any CPU
     		{9EFE95D6-9985-422A-A76F-285C8CF73617}.Release|x86.Build.0 = Release|Any CPU
     	EndGlobalSection
     	GlobalSection(SolutionProperties) = preSolution
     		HideSolutionNode = FALSE

ID	45f9a2adf8e2a7d01fef47909ea4b768e515fcad
상위	4939a201
하위	f3b8ff8f, ee95e6ee

프로젝트

일반

사용자정보

MARKUS

개정판 45f9a2ad