/ - Diff - MARKUS - 일정관리

개정판 a6e5055d

ID	a6e5055d17a7225d3fca1e58f3ffc47c20c5c6d2
상위	97eba451
하위	285635d3

alzkakdixm 이(가) 약 5년 전에 추가함

Markus.Service.StationController DataBaseView 추가

Change-Id: I16b9c78a690e2ae8f804bf35c8787a9c97fea157

     using System;
     using System.Collections.Generic;
     using System.ComponentModel;
     using System.Linq;
     using System.Runtime.Serialization;
     using System.Text;
-...
     namespace Markus.Service.Interface
+    {
         [DataContract]
         public class ConvertItem : IEquatable<ConvertItem>
         public class ConvertItem : IEquatable<ConvertItem> ,INotifyPropertyChanged
+        {
             public bool Equals(ConvertItem other)
+            {
-...
                 return (id + project).GetHashCode();
+            }
             public ConvertItem(string ProjectNo , string ID)
             public ConvertItem(string ProjectNo, string ID)
+            {
                 this._projectNumber = ProjectNo;
                 this._convertID = ID;
-...
                 this._projectNumber = ProjectNo;
                 this._convertID = ID;
                 this._originfilePath = originfilePath;
                 string result = "";
                 if (originfilePath.Contains("/"))
+                {
                     result = originfilePath.Substring(originfilePath.LastIndexOf("/") + 1);
+                }
                 else
+                {
                     result = originfilePath.Substring(originfilePath.LastIndexOf("%") + 1);
+                }
                 this._FileName = result;
+            }
             public ConvertItem(string key, string ProjectNo, string ID,string originfilePath,string convertPath)
-...
                 this._convertID = ID;
                 this._originfilePath = originfilePath;
                 this._convertPath = convertPath;
                 string result = "";
                 if (originfilePath.Contains("/"))
+                {
                     result = originfilePath.Substring(originfilePath.LastIndexOf("/") + 1);
+                }
                 else
+                {
                     result = originfilePath.Substring(originfilePath.LastIndexOf("%") + 1);
+                }
                 this._FileName = result;
+            }
             public ConvertItem(string key, string ProjectNo, string ID, string originfilePath, string convertPath,string Status,int currentPageNo,int totalPage,string exception)
-...
                 this._currentPageNo = currentPageNo;
                 this._totalPage = totalPage;
                 this._exception = exception;
                 string result = "";
                 if (originfilePath.Contains("/"))
+                {
                     result = originfilePath.Substring(originfilePath.LastIndexOf("/") + 1);
+                }
                 else
+                {
                     result = originfilePath.Substring(originfilePath.LastIndexOf("%") + 1);
+                }
                 this._FileName = result;
+            }
-...
             string _serviceID;
             int _reConverter;
             string _originfilePath;
             string _FileName;
             string _convertPath;
             string _convertState;
             int _currentPageNo;
-...
             DateTime _createtime;
             public event PropertyChangedEventHandler PropertyChanged;
             private void OnPropertyChanged(string propertyName)
+            {
                 if (PropertyChanged != null)
+                {
                     PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+                }
+            }
             [DataMember]
             public string ConvertID { get => _convertID; set => _convertID = value; }
             public string ConvertID
+            {
                 get
+                {
                     return _convertID;
+                }
                 set
+                {
                     if (_convertID != value)
+                    {
                         _convertID = value;
                         OnPropertyChanged("ConvertID");
+                    }
+                }
+            }
             [DataMember]
             public string ServiceID { get => _serviceID; set => _serviceID = value; }
             public string ServiceID
+            {
                 get
+                {
                     return _serviceID;
+                }
                 set
+                {
                     if (_serviceID != value)
+                    {
                         _serviceID = value;
                         this.OnPropertyChanged("ServiceID");
+                    }
+                }
+            }
             [DataMember]
             public int ReConverter { get => _reConverter; set => _reConverter = value; }
             public int ReConverter
+            {
                 get
+                {
                     return _reConverter;
+                }
                 set
+                {
                     if (_reConverter != value)
+                    {
                         _reConverter = value;
                         this.OnPropertyChanged("ReConverter");
+                    }
+                }
+            }
             [DataMember]
             public string OriginfilePath { get => _originfilePath; set => _originfilePath = value; }
             public string OriginfilePath
+            {
                 get
+                {
                     return _originfilePath;
+                }
                 set
+                {
                     if (_originfilePath != value)
+                    {
                         _originfilePath = value;
                         this.OnPropertyChanged("OriginfilePath");
+                    }
+                }
+            }
             [DataMember]
             public string ConvertPath { get => _convertPath; set => _convertPath = value; }
             public string FileName
+            {
                 get
+                {
                     return _FileName;
+                }
                 set
+                {
                     if (_FileName != value)
+                    {
                         _FileName = value;
                         this.OnPropertyChanged("FileName");
+                    }
+                }
+            }
             [DataMember]
             public string ConvertState { get => _convertState; set => _convertState = value; }
             public string ConvertPath
+            {
                 get
+                {
                     return _convertPath;
+                }
                 set
+                {
                     if (_convertPath != value)
+                    {
                         _convertPath = value;
                         this.OnPropertyChanged("ConvertPath");
+                    }
+                }
+            }
             [DataMember]
             public string ProjectNumber { get => _projectNumber; set => _projectNumber = value; }
             public string ConvertState
+            {
                 get
+                {
                     return _convertState;
+                }
                 set
+                {
                     if (_convertState != value)
+                    {
                         _convertState = value;
                         this.OnPropertyChanged("ConvertState");
+                    }
+                }
+            }
             [DataMember]
             public int TotalPage { get => _totalPage; set => _totalPage = value; }
             public string ProjectNumber
+            {
                 get
+                {
                     return _projectNumber;
+                }
                 set
+                {
                     if (_projectNumber != value)
+                    {
                         _projectNumber = value;
                         OnPropertyChanged("ProjectNumber");
+                    }
+                }
+            }
                 [DataMember]
             public int TotalPage
+            {
                 get
+                {
                     return _totalPage;
+                }
                 set
+                {
                     if (_totalPage != value)
+                    {
                         _totalPage = value;
                         this.OnPropertyChanged("TotalPage");
+                    }
+                }
+            }
             [DataMember]
             public int CurrentPageNo { get => _currentPageNo; set => _currentPageNo = value; }
             public int CurrentPageNo
+            {
                 get
+                {
                     return _currentPageNo;
+                }
                 set
+                {
                     if (_currentPageNo != value)
+                    {
                         _currentPageNo = value;
                         this.OnPropertyChanged("CurrentPageNo");
+                    }
+                }
+            }
             [DataMember]
             public DateTime CreateTime { get => _createtime; set => _createtime = value; }
             public DateTime CreateTime
+            {
                 get
+                {
                     return _createtime;
+                }
                 set
+                {
                     if (_createtime != value)
+                    {
                         _createtime = value;
                         this.OnPropertyChanged("CreateTime");
+                    }
+                }
+            }
             [DataMember]
             public string UniqueKey { get => _uniqueKey; set => _uniqueKey = value; }
             public string UniqueKey
+            {
                 get
+                {
                     return _uniqueKey;
+                }
                 set
+                {
                     if (_uniqueKey != value)
+                    {
                         _uniqueKey = value;
                         this.OnPropertyChanged("UniqueKey");
+                    }
+                }
+            }
             [DataMember]
             public string Exception { get => _exception; set => _exception = value; }
             public string Exception
+            {
                 get
+                {
                     return _exception;
+                }
                 set
+                {
                     if (_exception != value)
+                    {
                         _exception = value;
                         this.OnPropertyChanged("Exception");
+                    }
+                }
+            }
             [DataMember]
             public Int64 ProcessorAffinity { get; set; }
+        }
+    }

+                {
                     var item = items.First();
                     item.RECONVERTER = item.RECONVERTER + ReConvert;
                     item.RECONVERTER = item.RECONVERTER - ReConvert;
                     item.CREATE_DATETIME = DateTime.Now;
                     //item.START_DATETIME = null;
                     item.END_DATETIME = null;
-...
                 return convertItems;
+            }
             public IEnumerable<Interface.ConvertItem> GetConvertProjects(Func<CONVERTER_DOC, bool> @where)
+            {
                 var items = entities.CONVERTER_DOC.Where(@where);
                 if (items.Count() > 0)
+                {
                     foreach (var item in items)
+                    {
                         yield return new Interface.ConvertItem(item.DOCUMENT_ID, item.PROJECT_NO, item.ID, item.DOCUMENT_URL)
+                        {
                             ReConverter = item.RECONVERTER,
                             ServiceID = item.SERVICE_ID,
                             //ConvertState = ((StatusCodeType)item.STATUS).ToString(),
                             ConvertState = (item.STATUS).ToString(),
                             CreateTime = item.CREATE_DATETIME,
                             TotalPage = item.TOTAL_PAGE,
                             CurrentPageNo = item.CURRENT_PAGE,
                             Exception = item.EXCEPTION,
                             ConvertPath = GetConvertPath(item.PROJECT_NO, item.DOCUMENT_ID)
                         };
+                    }
+                }
+            }
             public List<Interface.ConvertItem> GetConvertProjects(Func<CONVERTER_DOC, bool> @where, StatusCodeType status)
+            {
                 List<Interface.ConvertItem> convertItems = new List<Interface.ConvertItem>();
                 //var items = entities.CONVERTER_DOC.Where(x => x.STATUS == (int)statusCodeType).Take(takeCount).ToList(); //.Where(x => x.PROJECT_NO == gProjectNo);
                 var items = entities.CONVERTER_DOC.Where(x => x.STATUS == (int)status).ToList();
                 if (items.Count() > 0)
+                {
                     foreach (var item in items)
+                    {
                         var convertitem = new Interface.ConvertItem(item.DOCUMENT_ID, item.PROJECT_NO, item.ID, item.DOCUMENT_URL)
+                        {
                             ReConverter = item.RECONVERTER,
                             ServiceID = item.SERVICE_ID,
                             //ConvertState = ((StatusCodeType)item.STATUS).ToString(),
                             ConvertState = (item.STATUS).ToString(),
                             CreateTime = item.CREATE_DATETIME,
                             TotalPage = item.TOTAL_PAGE,
                             CurrentPageNo = item.CURRENT_PAGE,
                             Exception = item.EXCEPTION,
                             ConvertPath = GetConvertPath(item.PROJECT_NO, item.DOCUMENT_ID)
                         };
+                    }
+                }
                 return convertItems;
+            }
             public List<Interface.ConvertItem> GetConvertProjectsStatus(Func<CONVERTER_DOC, bool> @where)
+            {
                 List<Interface.ConvertItem> convertItems = new List<Interface.ConvertItem>();
                 //var items = entities.CONVERTER_DOC.Where(x => x.STATUS == (int)statusCodeType).Take(takeCount).ToList(); //.Where(x => x.PROJECT_NO == gProjectNo);
                 var items = entities.CONVERTER_DOC.Where(x => x.STATUS<= 4);
                 if (items.Count() > 0)
+                {
                     foreach (var item in items)
+                    {
                         var convertitem = new Interface.ConvertItem(item.DOCUMENT_ID, item.PROJECT_NO, item.ID, item.DOCUMENT_URL)
+                        {
                             ReConverter = item.RECONVERTER,
                             ServiceID = item.SERVICE_ID,
                             //ConvertState = ((StatusCodeType)item.STATUS).ToString(),
                             ConvertState = (item.STATUS).ToString(),
                             CreateTime = item.CREATE_DATETIME,
                             TotalPage = item.TOTAL_PAGE,
                             CurrentPageNo = item.CURRENT_PAGE,
                             Exception = item.EXCEPTION,
                             ConvertPath = GetConvertPath(item.PROJECT_NO, item.DOCUMENT_ID)
                         };
                         convertItems.Add(convertitem);
+                    }
+                }
                 return convertItems;
+            }
             /// <summary>
             /// 현재 서비스에서 컨버터중인 아이템.

ConvertService/ServiceBase/Markus.Service.Extensions/Exntensions/CollectionExtenstions.cs
167	167	ArgumentCheck.IsNullorWhiteSpace(update, "update");
168	168	foreach (var item in enumerable)
169	169	{
170		if (where(item))
	170	if (where(item))//UpdateWhere에서 맨마지막 조건
171	171	{
172	172	update(item);
173	173	}

ConvertService/ServiceBase/Markus.Service.StationController/AppInit.cs
55	55	}
56	56	catch (Exception ex)
57	57	{
	58	MessageBox.Show(ex.Message);
58	59	}
59	60	}
60	61

ConvertService/ServiceBase/Markus.Service.StationController/Behaviors/StatusTypeList.cs
1	1	using System;
2	2	using System.Collections.Generic;
	3	using System.ComponentModel.DataAnnotations;
3	4	using System.Linq;
4	5	using System.Text;
5	6	using System.Threading.Tasks;
...	...
8	9	{
9	10	public class StatusTypeList : List<Message.StatusCodeType>
10	11	{
	12
11	13	}
12	14	}

ConvertService/ServiceBase/Markus.Service.StationController/Extensions/ConvertItemChangeValue.cs
9	9	{
10	10	public static class ConvertItemEx
11	11	{
12		public static void ChangeValues(object changeitem, object newitem)
	12	public static void ChangeValues(object changeitem, object newitem)//그리드에 있는 컬렉션, 디비에 있는 컬렉션
13	13	{
14		var changeProp = changeitem.GetType().GetProperties();
15		var newProp = newitem.GetType().GetProperties();
	14	var changeProp = changeitem.GetType().GetProperties();//그리드
	15	var newProp = newitem.GetType().GetProperties();//디비
16	16
17		foreach (var item in changeProp)
	17	foreach (var item in changeProp)//그리드 포문
18	18	{
19	19
20		var newinfo = newProp.Where(x => x.Name == item.Name);
	20	var newinfo = newProp.Where(x => x.Name == item.Name);//그리드와 디비 조건에 맞는 오브젝트
21	21
22	22	if(newinfo.Count() > 0)
23	23	{
24		item.SetValue(changeitem, newinfo.First().GetValue(newitem));
	24	if (item.GetValue(changeitem) != newinfo.First().GetValue(newitem))
	25	{
	26	item.SetValue(changeitem, newinfo.First().GetValue(newitem));
	27	}
25	28	}
26	29	}
27	30	}
	31
28	32	}
29	33	}

         <Reference Include="EntityFramework.SqlServer, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">
           <HintPath>..\packages\EntityFramework.6.2.0\lib\net45\EntityFramework.SqlServer.dll</HintPath>
         </Reference>
         <Reference Include="GemBox.Spreadsheet, Version=39.3.30.1215, Culture=neutral, PublicKeyToken=b1b72c69714d4847, processorArchitecture=MSIL">
           <HintPath>..\packages\GemBox.Spreadsheet.39.3.30.1215\lib\net30\GemBox.Spreadsheet.dll</HintPath>
         </Reference>
         <Reference Include="Markus.EntityModel, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
           <HintPath>..\packages\MarkusDatabase.1.7.2\lib\net45\Markus.EntityModel.dll</HintPath>
         </Reference>
-...
         <Compile Include="Extensions\VisualTreeHelper.cs" />
         <Compile Include="ViewModel\DataBaseByStatusViewModel.cs" />
         <Compile Include="ViewModel\AliveViewModel.cs" />
         <Compile Include="ViewModel\DataBaseItemsModel.cs" />
         <Compile Include="ViewModel\MergeDataViewModel.cs" />
         <Compile Include="ViewModel\MainViewModel.cs" />
         <Compile Include="ViewModel\TotalStatusViewModel.cs" />
         <Compile Include="Views\DataBaseView.xaml.cs">
           <DependentUpon>DataBaseView.xaml</DependentUpon>
         </Compile>
         <Compile Include="Views\MergeDataView.xaml.cs">
           <DependentUpon>MergeDataView.xaml</DependentUpon>
         </Compile>
-...
           <SubType>Designer</SubType>
           <Generator>MSBuild:Compile</Generator>
         </Page>
         <Page Include="Views\DataBaseView.xaml">
           <Generator>MSBuild:Compile</Generator>
           <SubType>Designer</SubType>
         </Page>
         <Page Include="Views\MergeDataView.xaml">
           <SubType>Designer</SubType>
           <Generator>MSBuild:Compile</Generator>

ConvertService/ServiceBase/Markus.Service.StationController/ViewModel/AliveViewModel.cs
115	115	}
116	116	catch (Exception ex)
117	117	{
	118	System.Diagnostics.Debug.WriteLine(ex.ToString());
118	119	}
119	120
120	121	IsLoading = false;
...	...
220	221	catch (Exception ex)
221	222	{
222	223	result = false;
	224	System.Diagnostics.Debug.WriteLine(ex.ToString());
223	225	}
224	226
225	227	return result;

ConvertService/ServiceBase/Markus.Service.StationController/ViewModel/DataBaseByStatusViewModel.cs
141	141	}
142	142	catch (Exception ex)
143	143	{
	144	System.Diagnostics.Debug.WriteLine(ex.ToString());
144	145	}
145	146	}
146	147

     using GemBox.Spreadsheet;
     using Markus.Message;
     using Markus.Service.DataBase;
     using Markus.Service.Extensions;
     using Markus.Service.StationController.Behaviors;
     using Markus.Service.StationController.Extensions;
     using Microsoft.Win32;
     using System;
     using System.Collections.Generic;
     using System.ComponentModel;
     using System.Linq;
     using System.Windows;
     using Telerik.Windows.Controls;
     using Telerik.Windows.Data;
     using ConvertItem = Markus.Service.Interface.ConvertItem;
     namespace Markus.Service.StationController.ViewModel
+    {
         //세미
         public class DataBaseItemsModel : Mvvm.ToolKit.ViewModelBase
+        {
             BackgroundWorker backgroundWorker;
             Random rnd = new Random();
             private System.Collections.ObjectModel.ObservableCollection<ConvertItem> _FilterConvertSource;
             private ConvertItem _SelectRealConvert;
             private ConvertItem _SelectFilterConvert;
             private StatusTypeList _StatusType;
             private bool _IsLoading;
             private Telerik.Windows.Data.EnumMemberViewModel _SelectedStatus;
             public Telerik.Windows.Data.EnumMemberViewModel SelectedStatus
+            {
                 get => _SelectedStatus;
                 set
+                {
                     _SelectedStatus = value;
                     OnPropertyChanged(() => SelectedStatus);
+                }
+            }
             private SelectedCountItem _SelectedCount;
             public SelectedCountItem SelectedCount
+            {
                 get => _SelectedCount;
                 set
+                {
                     _SelectedCount = value;
                     OnPropertyChanged(() => SelectedCount);
+                }
+            }
             public DelegateCommand ConvertCommand { get; private set; }
             public DelegateCommand DeleteCommand { get; private set; }
             private void DataConvert(object obj)
+            {
                 ConvertDatabase _DataConvert = new ConvertDatabase(App.MarkusDataBaseConnecitonString);
                 var resultRealConvert = _DataConvert.SetCleanUpItem(SelectRealConvert.ConvertID, SelectRealConvert.ReConverter);
                 var resultFiltertConvert = _DataConvert.SetCleanUpItem(SelectFilterConvert.ConvertID, SelectFilterConvert.ReConverter);
                 System.Diagnostics.Debug.WriteLine(resultRealConvert + "  " + resultFiltertConvert);
+            }
             private void DataDelete(object obj)
+            {
                 ConvertDatabase _DataConvert = new ConvertDatabase(App.MarkusDataBaseConnecitonString);
                 var resultRealConvert = _DataConvert.RemoveItem(SelectRealConvert.ConvertID);
                 var resultFiltertConvert = _DataConvert.RemoveItem(SelectFilterConvert.ConvertID);
                 System.Diagnostics.Debug.WriteLine(resultRealConvert + "  " + resultFiltertConvert);
+            }
             public System.Collections.ObjectModel.ObservableCollection<ConvertItem> FilterConvertSource
+            {
                 get => _FilterConvertSource;
                 set
+                {
                     _FilterConvertSource = value;
                     OnPropertyChanged(() => FilterConvertSource);
+                }
+            }
             private System.Collections.ObjectModel.ObservableCollection<ConvertItem> _RealConvertSource;
             public System.Collections.ObjectModel.ObservableCollection<ConvertItem> RealConvertSource
+            {
                 get => _RealConvertSource;
                 set
+                {
                     _RealConvertSource = value;
                     OnPropertyChanged(() => RealConvertSource);
+                }
+            }
             public ConvertItem SelectFilterConvert
+            {
                 get => _SelectFilterConvert;
                 set
+                {
                     _SelectFilterConvert = value;
                     OnPropertyChanged(() => SelectFilterConvert);
+                }
+            }
             public ConvertItem SelectRealConvert
+            {
                 get => _SelectRealConvert;
                 set
+                {
                     _SelectRealConvert = value;
                     OnPropertyChanged(() => SelectRealConvert);
+                }
+            }
             public StatusTypeList StatusType
+            {
                 get => _StatusType;
                 set
+                {
                     _StatusType = value;
                     OnPropertyChanged(() => StatusType);
+                }
+            }
             public bool IsLoading
+            {
                 get => _IsLoading;
                 set
+                {
                     if (_IsLoading != value)
+                    {
                         _IsLoading = value;
                         OnPropertyChanged(() => IsLoading);
+                    }
+                }
+            }
             List<SelectedCountItem> _SelectedCountList;
             public List<SelectedCountItem> SelectedCountList
+            {
                 get
+                {
                     if (_SelectedCountList == null)
+                    {
                         _SelectedCountList = new List<SelectedCountItem>
+                        {
                             new SelectedCountItem{DisplayMember = "50",ValueMember = 50},
                             new SelectedCountItem{DisplayMember = "100",ValueMember = 100},
                             new SelectedCountItem{DisplayMember = "150",ValueMember = 150},
                             new SelectedCountItem{DisplayMember = "200",ValueMember = 200}
                         };
+                    }
                     return _SelectedCountList;
+                }
+            }
             public DataBaseItemsModel()
+            {
                 DataSaveFileGemBoxCommand = new DelegateCommand(DataExport);
                 ConvertCommand = new DelegateCommand(DataConvert);
                 DeleteCommand = new DelegateCommand(DataDelete);
                 //Loaded();
+            }
             // 진행률에 변화가 있을때 이벤트가 발생
             private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
+            {
                 MessageBox.Show("진행률에 변화");
+            }
             // 일이 모두 마쳤을때 수행되어야할 코드
             private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
+            {
                 MessageBox.Show("임무마침");
+            }
             IEnumerable<Telerik.Windows.Data.EnumMemberViewModel> _StatusCodeList;
             public IEnumerable<Telerik.Windows.Data.EnumMemberViewModel> StatusCodeList
+            {
                 get
+                {
                     if (_StatusCodeList == null)
+                    {
                         _StatusCodeList = Telerik.Windows.Data.EnumDataSource.FromType<StatusCodeType>();
+                    }
                     return _StatusCodeList;
+                }
+            }
             // BackgroundWorker에서 수행할 일을 정의.
             private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
+            {
                 while (IsAcitve)
+                {
                     if (FilterConvertSource == null)
+                    {
                         FilterConvertSource = new System.Collections.ObjectModel.ObservableCollection<ConvertItem>();
+                    }
                     if (RealConvertSource == null)
+                    {
                         RealConvertSource = new System.Collections.ObjectModel.ObservableCollection<ConvertItem>();
+                    }
                     /// combobox 에서 선택된 items
                     if (SelectedStatus != null)
+                    {
                         DataSelect(new[] { (StatusCodeType)(SelectedStatus.Value) }, FilterConvertSource);
+                    }
                     /// 컨버터중인 items
                     DataSelect(new[] { StatusCodeType.None, StatusCodeType.Wait, StatusCodeType.PageLoading, StatusCodeType.Saving }, RealConvertSource);
+                }
+            }
             //<>쓸때는 IEnumerable
             private void DataSelect(IEnumerable<StatusCodeType> statusCodeTypeList, System.Collections.ObjectModel.ObservableCollection<ConvertItem> collection)
+            {
                 try
+                {
                     using (Markus.Service.DataBase.ConvertDatabase database = new Markus.Service.DataBase.ConvertDatabase(App.MarkusDataBaseConnecitonString))
+                    {
                         var items = database.GetConvertProjects(x => statusCodeTypeList.Count(y => (int)y == x.STATUS) > 0)
                                                     .OrderByDescending(x => x.CreateTime).Take(SelectedCount.ValueMember).ToList();
                         if (collection.Count() == 0)
+                        {
                             items.ForEach(x => collection.Add(x));
+                        }
                         else
+                        {
                             // 데이터 업데이트
                             items.ForEach(newitem =>//디비 포문
+                            {
                                 collection.UpdateWhere(changeitem =>
+                                {
                                     ConvertItemEx.ChangeValues(changeitem, newitem);
                                     System.Threading.Thread.Sleep(new TimeSpan(0, 0, 0, 0, 10));
                                 }, x => x.ConvertID == newitem.ConvertID);//UpdateWhere의  where절
                             });
                             foreach (var item in items)
+                            {
                                 //  System.Threading.Thread.Sleep(1);
                                 if (collection.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)
+                                {
                                     collection.Add(item);
+                                }
+                            }
                             //삭제
                             for (int i = collection.Count() - 1; i > -1; --i)
+                            {
                                 var item = collection[i];
                                 if (items.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)//디비에서 가져온 값과 마지막값부터 차례대로 비교
                                 {//참=> 0제외한 모든 수
                                     collection.RemoveAt(i);
+                                }
                                 // System.Threading.Thread.Sleep(new TimeSpan(0, 0, 0, 0, 1));
+                            }
+                        }
+                    }
+                }
                 catch (Exception ex)
+                {
                     MessageBox.Show(ex.ToString());
+                }
+            }
             public override void Loaded()
+            {
                 base.Loaded();
                 if (!App.IsDesignMode)
+                {
                     backgroundWorker = new BackgroundWorker();
                     backgroundWorker.DoWork += backgroundWorker_DoWork;
                     backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;
                     backgroundWorker.WorkerReportsProgress = false;
                     backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
                     backgroundWorker.RunWorkerAsync();
+                }
+            }
             public override void Closed()
+            {
                 if (backgroundWorker != null)
+                {
                     backgroundWorker.DoWork -= backgroundWorker_DoWork;
                     backgroundWorker.RunWorkerCompleted -= backgroundWorker_RunWorkerCompleted;
                     backgroundWorker.WorkerReportsProgress = false;
                     backgroundWorker.ProgressChanged -= new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
+                }
                 base.Closed();
+            }
             public DelegateCommand DataSaveFileGemBoxCommand { get; private set; }
             public class HeaderMember
+            {
                 public string HeaderName { get; set; }
                 public string Property { get; set; }
+            }
             //public void DataExport<T>(IEnumerable<T> AliveItems)
             public void DataExport(object obj)
+            {
                 SaveFileDialog saveFileDialog = new SaveFileDialog();
                 saveFileDialog.FileName = "Document"; // Default file name
                 saveFileDialog.DefaultExt = ".txt"; // Default file extension
                 saveFileDialog.Filter = "Csv documents (.Csv)|*.csv|Excel(2017~2019)Worksheets|*.xlsx"; // Filter files by extension
                 if (saveFileDialog.ShowDialog() == true)
+                {
                     if (!string.IsNullOrWhiteSpace(saveFileDialog.FileName))
+                    {
                         var extension = new System.IO.FileInfo(saveFileDialog.FileName).Extension;
                         if (extension == ".xlsx" || extension == ".csv")
+                        {
                             var headers = new List<HeaderMember>
+                            {
                                 new HeaderMember{HeaderName = "ServiceID", Property = "ServiceID" },
                                 new HeaderMember{HeaderName = "ConvertID", Property = "ConvertID" },
                                 new HeaderMember{HeaderName = "ProjectNumber", Property = "ProjectNumber" },
                                 new HeaderMember{HeaderName = "ConvertState", Property = "ConvertState" },
                                 new HeaderMember{HeaderName = "CurrentPageNo", Property = "CurrentPageNo" },
                                 new HeaderMember{HeaderName = "TotalPage", Property = "TotalPage" },
                                 new HeaderMember{HeaderName = "OriginfilePath", Property = "OriginfilePath" },
                                 new HeaderMember{HeaderName = "ConvertPath", Property = "ConvertPath" },
                                 new HeaderMember{HeaderName = "CreateTime", Property = "CreateTime" },
                                 new HeaderMember{HeaderName = "Exception", Property = "Exception" },
                                 new HeaderMember{HeaderName = "ProcessorAffinity", Property = "ProcessorAffinity" },
                                 new HeaderMember{HeaderName = "ReConverter", Property = "ReConverter" },
                                 new HeaderMember{HeaderName = "UniqueKey", Property = "UniqueKey" }
                             };
                             DataExportExcel(saveFileDialog.FileName, "Hello world", FilterConvertSource, headers);
                             //_dataExport.DataExportExcel(saveFileDialog.FileName, saveFileDialog.FileName.ToString(),  Projectsource, headers);
                             //GemBoxFileSave(obj);
+                        }
+                    }
+                }
+            }
             public void DataExportExcel<T>(string SaveFile, string SheetName, IEnumerable<T> collections, List<HeaderMember> headerMembers)
+            {
                 try
+                {
                     SpreadsheetInfo.SetLicense("EXK0-W4HZ-N518-IMEW");
                     // SpreadsheetInfo.SetLicense("FREE-LIMITED-KEY");//프리버전은 15줄까지만 가능
                     var workbook = new ExcelFile();
                     var worksheet = workbook.Worksheets.Add(SheetName);
                     // IEnumerable<T> collections를 for문
                     for (int rowNumber = 0; rowNumber < collections.Count(); rowNumber++)//1857  양이 너무 많아서 빨리 엑셀출력 누르면 숫자가 감소됨 차분히 기다리면 숫자 늘어남
+                    {
                         // index에 해당하는 row를 가져온다.
                         object row = collections.ElementAt(rowNumber);//우왕좌왕하게 모든 프로퍼티 있음 생성자 프로퍼티도 있음
                         //row의 properties를 가져옴.
                         var rowPropInfos = row.GetType().GetProperties();//행렬로 보기좋게 프로퍼티 나옴
                         /// 지정된 header에 대해서 프로퍼티에 해당하는 값을 가져와서 cell에 출력
                         for (int i = 0; i < headerMembers.Count(); i++)//13
+                        {
                             var prop = rowPropInfos.Where(x => x.Name == headerMembers[i].Property);//prop 0으로 나옴
                             if (headerMembers[i].Property == "CreateTime")
+                            {
                                 worksheet.Cells[rowNumber + 1, i].Value = prop.First().GetValue(row).ToString();
+                            }
                             else if (prop.Count() > 0)
+                            {
                                 worksheet.Cells[rowNumber + 1, i].Value = prop.First().GetValue(row);
+                            }
+                        }
+                    }
                     int k = 0;
                     foreach (var HeadInfo in headerMembers)
+                    {
                         worksheet.Cells[0, k].Value = HeadInfo.HeaderName;
                         k++;
+                    }
                     int columnCount = worksheet.CalculateMaxUsedColumns();
                     for (int i = 0; i < columnCount; i++)
+                    {
                         worksheet.Columns[i].AutoFit();
+                    }
                     var header = new CellStyle();//헤더
                     header.FillPattern.SetSolid(SpreadsheetColor.FromArgb(0, 100, 220));
                     header.Font.Weight = ExcelFont.BoldWeight;
                     header.HorizontalAlignment = HorizontalAlignmentStyle.Center;
                     header.VerticalAlignment = VerticalAlignmentStyle.Center;
                     //worksheet.Cells.GetSubrange("A1:M1").Style = header;
                     worksheet.Cells.GetSubrangeAbsolute(0, 0, collections.Count(), headerMembers.Count() - 1).Style = header;
                     var style = new CellStyle();
                     //style.Borders.SetBorders(MultipleBorders.Right | MultipleBorders.Top | MultipleBorders.Left | MultipleBorders.Bottom, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thick);//바깥쪽 border 두껍게 성공
                     style.Borders.SetBorders(MultipleBorders.Outside, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thick);//바깥쪽 border 두껍게 성공
                     style.HorizontalAlignment = HorizontalAlignmentStyle.Center;
                     style.VerticalAlignment = VerticalAlignmentStyle.Center;
                     style.Font.Color = SpreadsheetColor.FromArgb(75, 60, 50);//글자 색갈
                     style.FillPattern.SetSolid(SpreadsheetColor.FromArgb(126, 239, 239));//cell 색갈
                     style.Font.Name = "맑은 고딕";
                     style.Font.Size = 9 * 20;
                     worksheet.Cells.GetSubrangeAbsolute(0, 0, collections.Count(), headerMembers.Count() - 1).Style = style;
                     //worksheet.Cells.GetSubrange("A1:M1858").Style = style;
                     for (int line = 0; line < collections.Count() - 1; line++) //바깥border과 안쪽 얇은 border 같이 쓰면 안됨
+                    {
                         //for (int j = 0; j < 14 - 1 - 1; j++)
                         for (int j = 0; j < headerMembers.Count() - 1 - 1; j++)
+                        {
                             worksheet.Cells[line + 1, j + 1].Style.Borders.SetBorders(MultipleBorders.Outside, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//안쪽 (1,1) ~ (마지막-1,마지막-1) 가운데 성공
+                        }
+                    }
                     for (int line = 0; line < collections.Count(); line++) //바깥border과 안쪽 얇은 border 같이 쓰면 안됨
                     {//Projectsource.Count() = 761개 ( 0 ~ 760 )
                         for (int j = 0; j < headerMembers.Count() - 1; j++)
+                        {
                             worksheet.Cells[0, j].Style.Borders.SetBorders(MultipleBorders.Right, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//(0,0) ~ (0,마지막-1) 위 성공
                             worksheet.Cells[collections.Count(), j].Style.Borders.SetBorders(MultipleBorders.Right, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//(마지막,0) ~ (마지막,마지막-1) 아래 성공
+                        }
                         worksheet.Cells[line, 0].Style.Borders.SetBorders(MultipleBorders.Bottom, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//(0,0) ~ (마지막-1,0) 왼쪽 성공
                         worksheet.Cells[line, headerMembers.Count() - 1].Style.Borders.SetBorders(MultipleBorders.Bottom, SpreadsheetColor.FromArgb(140, 120, 50), LineStyle.Thin);//(0,마지막) ~ (마지막-1,마지막) 오른쪽 성공
+                    }
                     workbook.Save(SaveFile);//파일 열었던 파일로 저장 성공
                     MessageBox.Show("성공");
+                }
                 catch (Exception ex)
+                {
                     Console.WriteLine("예외 발생!! 메세지: {0}", ex.Message);
+                }
+            }
+        }
         public class SelectedCountItem
+        {
             public string DisplayMember { get; set; }
             public int ValueMember { get; set; }
+        }
+    }

                         Name = "Settings",
                         Description = "Convert Station Settings",
                         Content = new Views.SettingsView()
                     },
                       new MenuItem
+                    {
                         Name = "DataBase Items",
                         Description = "DataBase Items",
                         Content = new Views.DataBaseView()
+                    }
                 };

+                }
+            }
                 public TotalStatusViewModel()
+                {
+                }
             public TotalStatusViewModel()
+            {
+            }
                 // 진행률에 변화가 있을때 이벤트가 발생
                 private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
+                {
+                }
             // 진행률에 변화가 있을때 이벤트가 발생
             private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
+            {
+            }
                 // 일이 모두 마쳤을때 수행되어야할 코드
                 private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
+                {
+                }
             // 일이 모두 마쳤을때 수행되어야할 코드
             private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
+            {
+            }
                 // BackgroundWorker에서 수행할 일을 정의.
                 private async void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
             // BackgroundWorker에서 수행할 일을 정의.
             private async void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
+            {
                 while (IsAcitve)
+                {
                     while (IsAcitve)
                     System.Threading.Thread.Sleep(new TimeSpan(0, 0, 3));
                     if (!IsLoading)
+                    {
                         System.Threading.Thread.Sleep(new TimeSpan(0, 0, 3));
                         IsLoading = true;
                         if (!IsLoading)
                         try
+                        {
                             IsLoading = true;
                             try
+                            {
                                 List<ConvertItem> newitems = new List<ConvertItem>();
                             List<ConvertItem> newitems = new List<ConvertItem>();
                                 foreach (var client in App.StationClientList)
                             foreach (var client in App.StationClientList)
+                            {
                                 if (await SimplePingAsync(client.Endpoint.Address.ToString()))
+                                {
                                     if (await SimplePingAsync(client.Endpoint.Address.ToString()))
                                     try
+                                    {
                                         try
+                                        {
                                             var items = await client.AliveConvertListAsync();
                                             newitems.AddRange(items);
                                             System.Diagnostics.Trace.WriteLine($"{client.Endpoint.Address} ping");
                                             if (items.Count() == 0)
+                                            {
                                                 System.Diagnostics.Trace.WriteLine($"{client.Endpoint.Address} Alive Items is zero.");
+                                            }
+                                        }
                                         catch (Exception ex)
                                         var items = await client.AliveConvertListAsync();
                                         newitems.AddRange(items);
                                         System.Diagnostics.Trace.WriteLine($"{client.Endpoint.Address} ping");
                                         if (items.Count() == 0)
+                                        {
                                             System.Diagnostics.Trace.TraceError($"{client.Endpoint.Address} {ex.Message}");
                                             System.Diagnostics.Trace.WriteLine($"{client.Endpoint.Address} Alive Items is zero.");
+                                        }
+                                    }
                                     else
                                     catch (Exception ex)
+                                    {
                                         System.Diagnostics.Trace.TraceError($"{client.Endpoint.Address} ping Error");
                                         System.Diagnostics.Trace.TraceError($"{client.Endpoint.Address} {ex.Message}");
+                                    }
+                                }
+                            }
                             catch (Exception ex)
+                            {
                                 else
+                                {
                                     System.Diagnostics.Trace.TraceError($"{client.Endpoint.Address} ping Error");
+                                }
+                            }
                             IsLoading = false;
+                        }
                         catch (Exception ex)
+                        {
                             System.Diagnostics.Debug.WriteLine(ex.ToString());
+                        }
                         IsLoading = false;
+                    }
+                }
+            }
                 private void LogWrite(string log, bool IsError)
             private void LogWrite(string log, bool IsError)
+            {
                 if (IsError)
+                {
                     if (IsError)
+                    {
                         System.Diagnostics.Trace.Fail(log);
+                    }
                     else
+                    {
                         System.Diagnostics.Trace.TraceInformation(log);
+                    }
                     System.Diagnostics.Trace.Fail(log);
+                }
                 else
+                {
                     System.Diagnostics.Trace.TraceInformation(log);
+                }
+            }
                 public static async Task<bool> SimplePingAsync(string uri)
+                {
                     bool result = false;
             public static async Task<bool> SimplePingAsync(string uri)
+            {
                 bool result = false;
                     try
                 try
+                {
                     using (System.Net.Http.HttpClient Client = new System.Net.Http.HttpClient())
+                    {
                         using (System.Net.Http.HttpClient Client = new System.Net.Http.HttpClient())
+                        {
                             Client.Timeout = new TimeSpan(0, 5, 0);
                         Client.Timeout = new TimeSpan(0, 5, 0);
                             var message = await Client.GetAsync(uri);
                         var message = await Client.GetAsync(uri);
                             System.Net.HttpStatusCode StatusCode = message.StatusCode;
                         System.Net.HttpStatusCode StatusCode = message.StatusCode;
                             switch (StatusCode)
+                            {
                         switch (StatusCode)
+                        {
                                 case System.Net.HttpStatusCode.Accepted:
                                 case System.Net.HttpStatusCode.OK:
                                     result = true;
                                     break;
+                            }
                             case System.Net.HttpStatusCode.Accepted:
                             case System.Net.HttpStatusCode.OK:
                                 result = true;
                                 break;
+                        }
+                    }
                     catch (Exception ex)
+                    {
                         result = false;
+                    }
                     return result;
+                }
                 public override void Loaded()
                 catch (Exception ex)
+                {
                     base.Loaded();
                     result = false;
                     System.Diagnostics.Debug.WriteLine(ex.ToString());
+                }
                     if (!App.IsDesignMode)
+                    {
                         backgroundWorker = new BackgroundWorker();
                         backgroundWorker.DoWork += backgroundWorker_DoWork;
                         backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;
                         backgroundWorker.WorkerReportsProgress = false;
                         backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
                 return result;
+            }
                         backgroundWorker.RunWorkerAsync();
+                    }
+                }
             public override void Loaded()
+            {
                 base.Loaded();
                 public override void Closed()
                 if (!App.IsDesignMode)
+                {
                     if (backgroundWorker != null)
+                    {
                         backgroundWorker.DoWork -= backgroundWorker_DoWork;
                         backgroundWorker.RunWorkerCompleted -= backgroundWorker_RunWorkerCompleted;
                         backgroundWorker.WorkerReportsProgress = false;
                         backgroundWorker.ProgressChanged -= new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
                     backgroundWorker = new BackgroundWorker();
                     backgroundWorker.DoWork += backgroundWorker_DoWork;
                     backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;
                     backgroundWorker.WorkerReportsProgress = false;
                     backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
                         backgroundWorker.Dispose();
+                    }
                     backgroundWorker.RunWorkerAsync();
+                }
+            }
                     base.Closed();
             public override void Closed()
+            {
                 if (backgroundWorker != null)
+                {
                     backgroundWorker.DoWork -= backgroundWorker_DoWork;
                     backgroundWorker.RunWorkerCompleted -= backgroundWorker_RunWorkerCompleted;
                     backgroundWorker.WorkerReportsProgress = false;
                     backgroundWorker.ProgressChanged -= new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
                     backgroundWorker.Dispose();
+                }
                 base.Closed();
+            }
+        }
+    }

     <UserControl x:Class="Markus.Service.StationController.Views.DataBaseView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"
             xmlns:VM="clr-namespace:Markus.Service.StationController.ViewModel"
             xmlns:telerik="http://schemas.telerik.com/2008/xaml/presentation"
             mc:Ignorable="d"  Background="White"
             d:DesignHeight="450" d:DesignWidth="800">
         <UserControl.Resources>
             <Style TargetType="telerik:GridViewHeaderCell">
                 <Setter Property="HorizontalContentAlignment" Value="Center"/>
                 <Setter Property="Background" Value="Gray"/>
             </Style>
         </UserControl.Resources>
         <UserControl.DataContext>
             <VM:DataBaseItemsModel/>
         </UserControl.DataContext>
         <i:Interaction.Triggers>
             <i:EventTrigger  EventName="Loaded">
                 <i:InvokeCommandAction Command="{Binding LoadedCommand}"/>
             </i:EventTrigger>
             <i:EventTrigger  EventName="Unloaded">
                 <i:InvokeCommandAction Command="{Binding ClosingCommand}"/>
             </i:EventTrigger>
         </i:Interaction.Triggers>
         <Grid HorizontalAlignment="Left">
             <Grid.RowDefinitions>
                 <RowDefinition Height="Auto"/>
                 <RowDefinition Height="*"/>
                 <RowDefinition Height="*"/>
             </Grid.RowDefinitions>
             <StackPanel Margin="0,10" Orientation="Horizontal" HorizontalAlignment="Right" Grid.Row="0"  Height="20" >
                 <TextBlock Text="Display Count : " VerticalAlignment="Center"/>
                 <telerik:RadComboBox x:Name="ComboCount" Width="100" SelectedItem="{Binding SelectedCount, Mode=TwoWay}" Margin="0,0,10,0" SelectedValuePath="DisplayMember"
                   DisplayMemberPath="ValueMember" ItemsSource="{Binding SelectedCountList}" SelectedIndex="0" />
                 <!--SelectedIndex 디폴트 값 ItemsSource콤보박스에 넣을 값 중 DisplayMemberPath 키와 값중 화면에 보여질거 선택 SelectedValuePath 콤보박스 아이템 선택하면 SelectedItem에 DisplayMember이 값나감-->
                 <!--SelectedItem : object값 리턴-->
                 <TextBlock Text="Status Type : " Margin="10,0,0,0"  VerticalAlignment="Center"/>
                 <telerik:RadComboBox Width="100" SelectedItem="{Binding SelectedStatus, Mode=TwoWay}"
                    DisplayMemberPath="DisplayName" SelectedValuePath="Value" ItemsSource="{Binding StatusCodeList}" Height="20"/>
                 <telerik:RadToggleButton Content="  엑셀 저장  " Margin="10,0" Height="20" Command="{Binding DataSaveFileGemBoxCommand, Mode=OneWay}"/>
             </StackPanel>
             <GroupBox Grid.Row="1"
                       Header="DataBase Items"  BorderThickness="0"
                       ScrollViewer.HorizontalScrollBarVisibility="Auto" ScrollViewer.VerticalScrollBarVisibility="Auto">
                 <telerik:RadGridView x:Name="dataGrid1"  GroupRenderMode="Flat" VerticalAlignment="Stretch" HorizontalAlignment="Stretch"
     							 ItemsSource="{Binding FilterConvertSource}"
                                  SelectedItem="{Binding SelectFilterConvert}"
     							 AutoGenerateColumns="False" CanUserFreezeColumns="False"
                                  ColumnWidth="*"
                                  Grid.Row="1"  ScrollViewer.CanContentScroll="False" IsFilteringAllowed="True" >
                     <telerik:RadContextMenu.ContextMenu>
                         <telerik:RadContextMenu x:Name= "GridContextMenu">
                             <telerik:RadContextMenu.Items>
                                 <telerik:RadMenuItem  Header="Convert"  Command="{Binding ConvertCommand}" ItemsSource="{Binding SelectedItem}" />
                                 <telerik:RadMenuItem Header="Delete"  Command="{Binding DeleteCommand}" ItemsSource="{Binding SelectedItem}"/>
                             </telerik:RadContextMenu.Items>
                         </telerik:RadContextMenu>
                     </telerik:RadContextMenu.ContextMenu>
                     <telerik:RadGridView.Columns>
                         <telerik:GridViewDataColumn Header="Service ID"
     											DataMemberBinding="{Binding ServiceID }"  MinWidth="250" MaxWidth="270"/>
                         <telerik:GridViewDataColumn Header="Convert ID "
     											DataMemberBinding="{Binding ConvertID}" MinWidth="180" MaxWidth="200" />
                         <telerik:GridViewDataColumn Header="ProjectNO"
     											DataMemberBinding="{Binding ProjectNumber}" MinWidth="50" MaxWidth="70"/>
                         <telerik:GridViewDataColumn Header="ConvertState"
     											DataMemberBinding="{Binding ConvertState,Mode=TwoWay}" MinWidth="60" MaxWidth="80" />
                         <telerik:GridViewDataColumn Header="CurrentPageNo"
     											DataMemberBinding="{Binding CurrentPageNo,Mode=TwoWay}" MinWidth="80" MaxWidth="100"/>
                         <telerik:GridViewDataColumn Header="TotalPage"
     											DataMemberBinding="{Binding TotalPage}" MinWidth="60" MaxWidth="80" />
                         <!--<telerik:GridViewDataColumn Header=" OriginfilePath"
     											DataMemberBinding="{Binding  OriginfilePath}" MinWidth="170"/>-->
                         <telerik:GridViewDynamicHyperlinkColumn Header="원본파일"
                                                             NavigateUrlFormatString="{} {0}"
     													    NavigateUrlMemberPaths="OriginfilePath"
     														Width="150">
                             <telerik:GridViewDynamicHyperlinkColumn.CellTemplate>
                                 <DataTemplate>
                                     <TextBlock Text="{Binding FileName}"/>
                                 </DataTemplate>
                             </telerik:GridViewDynamicHyperlinkColumn.CellTemplate>
                         </telerik:GridViewDynamicHyperlinkColumn>
                         <telerik:GridViewDataColumn Header=" ConvertPath"
     											DataMemberBinding="{Binding ConvertPath}" MinWidth="70" MaxWidth="90"/>
                         <telerik:GridViewDataColumn Header="CreateTime"
     											DataMemberBinding="{Binding CreateTime , StringFormat=\{0:yyyy.MM.dd HH:mm:ss\}}" MinWidth="120" MaxWidth="140"/>
                         <telerik:GridViewDataColumn Header="Exception"
     											DataMemberBinding="{Binding Exception}" MinWidth="60" MaxWidth="80"/>
                         <telerik:GridViewDataColumn Header="ProcessorAffinity"
     											DataMemberBinding="{Binding ProcessorAffinity}" MinWidth="90" MaxWidth="110"/>
                         <telerik:GridViewDataColumn Header="ReConverter"

... 이 차이점은 표시할 수 있는 최대 줄수를 초과해서 이 차이점은 잘렸습니다.

내보내기 Unified diff

프로젝트

일반

사용자정보

MARKUS

개정판 a6e5055d