MARKUS

using KCOM.ServiceDeepView;

using System.Diagnostics;

using System.IO;

using System.Net;

using System.Reflection;

using System.Xml;

        //20180921 LJY

        //public ServiceDeepViewClient _Client;

        private string versionPath = null;

                    var result = ParamDecoding(e.Args[0].Replace(@"kcom://", "").Replace(@"/", ""));

                else

                {

                    string[] strArg = Environment.GetCommandLineArgs();

                    if (strArg.Length > 1)

                    {

                        //label1.Text = strArg[1];

                        var result = ParamDecoding(strArg[1].Replace(@"kcom://", "").Replace(@"/", ""));

                        App.ViewInfo = new IKCOM.ViewInfo

                        {

                            DocumentItemID = result.DocumentItemID,

                            //DocumentItemID = "10001",

                            bPartner = result.bPartner,

                            CreateFinalPDFPermission = result.CreateFinalPDFPermission,

                            NewCommentPermission = result.NewCommentPermission,

                            ProjectNO = result.ProjectNO,

                            UserID = result.UserID,

                            //UserID = "H2009115",

                            //Mode = 0 , 1 , 2

                        };

                        ParameterMode = true;

                    }                

                }

                //GetQueryStringParameters();

                _binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly);

                //20180913 LJY 어셈블리 버전

                //string assemblyVersion = Assembly.LoadFile('your assembly file').GetName().Version.ToString();

                //string fileVersion = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion;

                //string productVersion = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).ProductVersion;

                //_Client = new ServiceDeepViewClient(App._binding, App._EndPoint);

                //var serverVersion = _Client.GetCurrentVersion();

                if (Environment.Is64BitProcess == true) //64 bit machine

                {

                    versionPath = KCOM.Properties.Settings.Default.UpdateVer64;

                }

                else //32 bit machine

                {

                    versionPath = KCOM.Properties.Settings.Default.UpdateVer86;

                }

                // 20180921 version.xml check로 변경

                var assemblyVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();

                try

                {

                    XmlDocument xdoc = new XmlDocument();

                    xdoc.Load(versionPath);                        

                    XmlNode node = xdoc.SelectSingleNode("/RootElement/version");

                    if (assemblyVersion != node.InnerText) // node.InnerText 가 null이면 catch로 빠짐

                    {

                        if(MessageBox.Show("Ver. " + node.InnerText + " 업데이트가 있습니다.\r\nSmartUpdate를 실행합니다.", "MARKUS", MessageBoxButton.OKCancel) == MessageBoxResult.OK)

                        {

                            UpdateCheck(e);

                        }

                        else

                        {

                            base.Shutdown();

                            //현재 실행되고 있는 자기 자신 프로세스의 정보 // 위에꺼랑 두개 다 써줄필요가 있는..가?

                            Process proc = Process.GetCurrentProcess();

                            proc.Kill();

                        }

                    }

                    else

                    {

                        base.OnStartup(e);

                    }                                              

                }

                catch (Exception ex) //2. 파일이 없거나 파일내에 version의 값이 없다면 KCOM 실행하기

                {

                    ErrorLogFileWrite("KCOM//UpdateCheck ERR : " + ex);

                    base.OnStartup(e);

                }           

        protected void UpdateCheck(StartupEventArgs e)

        {          

            try

            {

                if (e.Args.Count() > 0)

                {

                    ProcessStartInfo proInfo = new ProcessStartInfo();

                    var FileName = AppDomain.CurrentDomain.BaseDirectory + "SmartUpdate.exe";

                    Process.Start(FileName, e.Args[0]);

                    //다른프로그램에서는 값 안넘기고 바로 실행해도 오류 없이 파일 업데이트 잘 됨!

                    //Process.Start(FileName);

                    base.Shutdown();

                    //현재 실행되고 있는 자기 자신 프로세스의 정보 

                    Process proc = Process.GetCurrentProcess();

                    proc.Kill();

                }                    

            }

            catch(Exception ee)

            {

                ErrorLogFileWrite("KCOM//UpdateCheck ERR : " + ee);

            }            

        }

        private void ErrorLogFileWrite(string Err)

        {

            try

            {

                string pathString = AppDomain.CurrentDomain.BaseDirectory + "Err";

                if (!File.Exists(pathString))

                {

                    Directory.CreateDirectory(pathString);

                }

                Err = Err + "   " + DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss") + "\r\n";

                string path = pathString + "\\" + "Log_" + DateTime.Now.ToString("yyyy-MM-dd hh-mm") + ".txt";

                File.AppendAllText(path, Err);

            }

            catch (Exception er)

            {

                string strError = er.ToString();

                //MessageBox.Show("err : " + er);

            }

        }

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.8.0.0")]

        [global::System.Configuration.ApplicationScopedSettingAttribute()]

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

        [global::System.Configuration.DefaultSettingValueAttribute("http://www.devdoftech.co.kr:5977/TileSource/Version/version_x64.xml")]

        public string UpdateVer64

        {

            get

            {

                return ((string)(this["UpdateVer64"]));

            }

        }

        [global::System.Configuration.ApplicationScopedSettingAttribute()]

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

        [global::System.Configuration.DefaultSettingValueAttribute("http://www.devdoftech.co.kr:5977/TileSource/Version/version_x86.xml")]

        public string UpdateVer86

        {

            get

            {

                return ((string)(this["UpdateVer86"]));

            }

        }

    <Setting Name="UpdateVer64" Type="System.String" Scope="Application">

      <Value Profile="(Default)">http://www.devdoftech.co.kr:5977/TileSource/Version/version_x64.xml</Value>

    </Setting>

    <Setting Name="UpdateVer86" Type="System.String" Scope="Application">

      <Value Profile="(Default)">http://www.devdoftech.co.kr:5977/TileSource/Version/version_x86.xml</Value>

    </Setting>

<Application x:Class="SmartUpdate.App"

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

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

             xmlns:local="clr-namespace:SmartUpdate"

             StartupUri="MainWindow.xaml">

    <Application.Resources>

    </Application.Resources>

</Application>

using System;

using System.Collections.Generic;

using System.Configuration;

using System.Data;

using System.Linq;

using System.Threading.Tasks;

using System.Windows;

namespace SmartUpdate

{

    /// <summary>

    /// App.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class App : Application

    {

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SmartUpdate

{

    #region FileToImageIconConverter

    public class FileToImageIconConverter

    {

        private string filePath;

        private System.Windows.Media.ImageSource icon;

        public string FilePath { get { return filePath; } }

        public System.Windows.Media.ImageSource Icon

        {

            get

            {

                if (icon == null && System.IO.File.Exists(FilePath))

                {

                    using (System.Drawing.Icon sysicon = System.Drawing.Icon.ExtractAssociatedIcon(FilePath))

                    {

                        icon = System.Windows.Interop.Imaging.CreateBitmapSourceFromHIcon(

                                  sysicon.Handle,

                                  System.Windows.Int32Rect.Empty,

                                  System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());

                    }

                }

                return icon;

            }

        }

        public FileToImageIconConverter(string filePath)

        {

            this.filePath = filePath;

        }

    }

    #endregion

}

using System;

using System.Drawing;

using System.Collections;

using System.ComponentModel;

using System.Data;

using System.Runtime.InteropServices;

namespace Etier.IconHelper

{

    /// <summary>

    /// Provides static methods to read system icons for both folders and files.

    /// </summary>

    /// <example>

    /// <code>IconReader.GetFileIcon("c:\\general.xls");</code>

    /// </example>

    public class IconReader

    {

        /// <summary>

        /// Options to specify the size of icons to return.

        /// </summary>

        public enum IconSize

        {

            /// <summary>

            /// Specify large icon - 32 pixels by 32 pixels.

            /// </summary>

            Large = 0,

            /// <summary>

            /// Specify small icon - 16 pixels by 16 pixels.

            /// </summary>

            Small = 1

        }

        /// <summary>

        /// Options to specify whether folders should be in the open or closed state.

        /// </summary>

        public enum FolderType

        {

            /// <summary>

            /// Specify open folder.

            /// </summary>

            Open = 0,

            /// <summary>

            /// Specify closed folder.

            /// </summary>

            Closed = 1

        }

        /// <summary>

        /// Returns an icon for a given file - indicated by the name parameter.

        /// </summary>

        /// <param name="name">Pathname for file.</param>

        /// <param name="size">Large or small</param>

        /// <param name="linkOverlay">Whether to include the link icon</param>

        /// <returns>System.Drawing.Icon</returns>

        public static System.Drawing.Icon GetFileIcon(string name, IconSize size, bool linkOverlay)

        {

            Shell32.SHFILEINFO shfi = new Shell32.SHFILEINFO();

            uint flags = Shell32.SHGFI_ICON | Shell32.SHGFI_USEFILEATTRIBUTES;

            if (true == linkOverlay) flags += Shell32.SHGFI_LINKOVERLAY;

            /* Check the size specified for return. */

            if (IconSize.Small == size)

            {

                flags += Shell32.SHGFI_SMALLICON;

            }

            else

            {

                flags += Shell32.SHGFI_LARGEICON;

            }

            Shell32.SHGetFileInfo(name,

                Shell32.FILE_ATTRIBUTE_NORMAL,

                ref shfi,

                (uint)System.Runtime.InteropServices.Marshal.SizeOf(shfi),

                flags);

            // Copy (clone) the returned icon to a new object, thus allowing us to clean-up properly

            System.Drawing.Icon icon = (System.Drawing.Icon)System.Drawing.Icon.FromHandle(shfi.hIcon).Clone();

            User32.DestroyIcon(shfi.hIcon);     // Cleanup

            return icon;

        }

        /// <summary>

        /// Used to access system folder icons.

        /// </summary>

        /// <param name="size">Specify large or small icons.</param>

        /// <param name="folderType">Specify open or closed FolderType.</param>

        /// <returns>System.Drawing.Icon</returns>

        public static System.Drawing.Icon GetFolderIcon(IconSize size, FolderType folderType)

        {

            // Need to add size check, although errors generated at present!

            uint flags = Shell32.SHGFI_ICON | Shell32.SHGFI_USEFILEATTRIBUTES;

            if (FolderType.Open == folderType)

            {

                flags += Shell32.SHGFI_OPENICON;

            }

            if (IconSize.Small == size)

            {

                flags += Shell32.SHGFI_SMALLICON;

            }

            else

            {

                flags += Shell32.SHGFI_LARGEICON;

            }

            // Get the folder icon

            Shell32.SHFILEINFO shfi = new Shell32.SHFILEINFO();

            Shell32.SHGetFileInfo(null,

                Shell32.FILE_ATTRIBUTE_DIRECTORY,

                ref shfi,

                (uint)System.Runtime.InteropServices.Marshal.SizeOf(shfi),

                flags);

            System.Drawing.Icon.FromHandle(shfi.hIcon); // Load the icon from an HICON handle

            // Now clone the icon, so that it can be successfully stored in an ImageList

            System.Drawing.Icon icon = (System.Drawing.Icon)System.Drawing.Icon.FromHandle(shfi.hIcon).Clone();

            User32.DestroyIcon(shfi.hIcon);     // Cleanup

            return icon;

        }

    }

    /// <summary>

    /// Wraps necessary Shell32.dll structures and functions required to retrieve Icon Handles using SHGetFileInfo. Code

    /// courtesy of MSDN Cold Rooster Consulting case study.

    /// </summary>

    /// 

    // This code has been left largely untouched from that in the CRC example. The main changes have been moving

    // the icon reading code over to the IconReader type.

    public class Shell32

    {

        public const int MAX_PATH = 256;

        [StructLayout(LayoutKind.Sequential)]

        public struct SHITEMID

        {

            public ushort cb;

            [MarshalAs(UnmanagedType.LPArray)]

            public byte[] abID;

        }

        [StructLayout(LayoutKind.Sequential)]

        public struct ITEMIDLIST

        {

            public SHITEMID mkid;

        }

        [StructLayout(LayoutKind.Sequential)]

        public struct BROWSEINFO

        {

            public IntPtr hwndOwner;

            public IntPtr pidlRoot;

            public IntPtr pszDisplayName;

            [MarshalAs(UnmanagedType.LPTStr)]

            public string lpszTitle;

            public uint ulFlags;

            public IntPtr lpfn;

            public int lParam;

            public IntPtr iImage;

        }

        // Browsing for directory.

        public const uint BIF_RETURNONLYFSDIRS = 0x0001;

        public const uint BIF_DONTGOBELOWDOMAIN = 0x0002;

        public const uint BIF_STATUSTEXT = 0x0004;

        public const uint BIF_RETURNFSANCESTORS = 0x0008;

        public const uint BIF_EDITBOX = 0x0010;

        public const uint BIF_VALIDATE = 0x0020;

        public const uint BIF_NEWDIALOGSTYLE = 0x0040;

        public const uint BIF_USENEWUI = (BIF_NEWDIALOGSTYLE | BIF_EDITBOX);

        public const uint BIF_BROWSEINCLUDEURLS = 0x0080;

        public const uint BIF_BROWSEFORCOMPUTER = 0x1000;

        public const uint BIF_BROWSEFORPRINTER = 0x2000;

        public const uint BIF_BROWSEINCLUDEFILES = 0x4000;

        public const uint BIF_SHAREABLE = 0x8000;

        [StructLayout(LayoutKind.Sequential)]

        public struct SHFILEINFO

        {

            public const int NAMESIZE = 80;

            public IntPtr hIcon;

            public int iIcon;

            public uint dwAttributes;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH)]

            public string szDisplayName;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = NAMESIZE)]

            public string szTypeName;

        };

        public const uint SHGFI_ICON = 0x000000100;     // get icon

        public const uint SHGFI_DISPLAYNAME = 0x000000200;     // get display name

        public const uint SHGFI_TYPENAME = 0x000000400;     // get type name

        public const uint SHGFI_ATTRIBUTES = 0x000000800;     // get attributes

        public const uint SHGFI_ICONLOCATION = 0x000001000;     // get icon location

        public const uint SHGFI_EXETYPE = 0x000002000;     // return exe type

        public const uint SHGFI_SYSICONINDEX = 0x000004000;     // get system icon index

        public const uint SHGFI_LINKOVERLAY = 0x000008000;     // put a link overlay on icon

        public const uint SHGFI_SELECTED = 0x000010000;     // show icon in selected state

        public const uint SHGFI_ATTR_SPECIFIED = 0x000020000;     // get only specified attributes

        public const uint SHGFI_LARGEICON = 0x000000000;     // get large icon

        public const uint SHGFI_SMALLICON = 0x000000001;     // get small icon

        public const uint SHGFI_OPENICON = 0x000000002;     // get open icon

        public const uint SHGFI_SHELLICONSIZE = 0x000000004;     // get shell size icon

        public const uint SHGFI_PIDL = 0x000000008;     // pszPath is a pidl

        public const uint SHGFI_USEFILEATTRIBUTES = 0x000000010;     // use passed dwFileAttribute

        public const uint SHGFI_ADDOVERLAYS = 0x000000020;     // apply the appropriate overlays

        public const uint SHGFI_OVERLAYINDEX = 0x000000040;     // Get the index of the overlay

        public const uint FILE_ATTRIBUTE_DIRECTORY = 0x00000010;

        public const uint FILE_ATTRIBUTE_NORMAL = 0x00000080;

        [DllImport("Shell32.dll")]

        public static extern IntPtr SHGetFileInfo(

            string pszPath,

            uint dwFileAttributes,

            ref SHFILEINFO psfi,

            uint cbFileInfo,

            uint uFlags

            );

    }

    /// <summary>

    /// Wraps necessary functions imported from User32.dll. Code courtesy of MSDN Cold Rooster Consulting example.

    /// </summary>

    public class User32

    {

        /// <summary>

        /// Provides access to function required to delete handle. This method is used internally

        /// and is not required to be called separately.

        /// </summary>

        /// <param name="hIcon">Pointer to icon handle.</param>

        /// <returns>N/A</returns>

        [DllImport("User32.dll")]

        public static extern int DestroyIcon(IntPtr hIcon);

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Drawing;

using System.Runtime.InteropServices;

using System.Windows.Media;

using System.Windows;

using System.Windows.Media.Imaging;

public class IconManager

{

    public static ImageSource GetIcon(string path, bool smallIcon, bool isDirectory)

    {

        uint flags = SHGFI_ICON | SHGFI_USEFILEATTRIBUTES;

        if (smallIcon)

            flags |= SHGFI_SMALLICON;

        uint attributes = FILE_ATTRIBUTE_NORMAL;

        if (isDirectory)

            attributes |= FILE_ATTRIBUTE_DIRECTORY;

        SHFILEINFO shfi;

        if (0 != SHGetFileInfo(path, attributes, out shfi, (uint)Marshal.SizeOf(typeof(SHFILEINFO)), flags))

        {

            return System.Windows.Interop.Imaging.CreateBitmapSourceFromHIcon(shfi.hIcon, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());

        }

        return null;

    }

    [StructLayout(LayoutKind.Sequential)]

    private struct SHFILEINFO

    {

        public IntPtr hIcon;

        public int iIcon;

        public uint dwAttributes;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]

        public string szDisplayName;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]

        public string szTypeName;

    }

    [DllImport("shell32")]

    private static extern int SHGetFileInfo(string pszPath, uint dwFileAttributes, out SHFILEINFO psfi, uint cbFileInfo, uint flags);

    private const uint FILE_ATTRIBUTE_READONLY = 0x00000001;

    private const uint FILE_ATTRIBUTE_HIDDEN = 0x00000002;

    private const uint FILE_ATTRIBUTE_SYSTEM = 0x00000004;

    private const uint FILE_ATTRIBUTE_DIRECTORY = 0x00000010;

    private const uint FILE_ATTRIBUTE_ARCHIVE = 0x00000020;

    private const uint FILE_ATTRIBUTE_DEVICE = 0x00000040;

    private const uint FILE_ATTRIBUTE_NORMAL = 0x00000080;

    private const uint FILE_ATTRIBUTE_TEMPORARY = 0x00000100;

    private const uint FILE_ATTRIBUTE_SPARSE_FILE = 0x00000200;

    private const uint FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400;

    private const uint FILE_ATTRIBUTE_COMPRESSED = 0x00000800;

    private const uint FILE_ATTRIBUTE_OFFLINE = 0x00001000;

    private const uint FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x00002000;

    private const uint FILE_ATTRIBUTE_ENCRYPTED = 0x00004000;

    private const uint FILE_ATTRIBUTE_VIRTUAL = 0x00010000;

    private const uint SHGFI_ICON = 0x000000100;

    private const uint SHGFI_DISPLAYNAME = 0x000000200;

    private const uint SHGFI_TYPENAME = 0x000000400;

    private const uint SHGFI_ATTRIBUTES = 0x000000800;

    private const uint SHGFI_ICONLOCATION = 0x000001000;

    private const uint SHGFI_EXETYPE = 0x000002000;

    private const uint SHGFI_SYSICONINDEX = 0x000004000;

    private const uint SHGFI_LINKOVERLAY = 0x000008000;

    private const uint SHGFI_SELECTED = 0x000010000;

    private const uint SHGFI_ATTR_SPECIFIED = 0x000020000;

    private const uint SHGFI_LARGEICON = 0x000000000;

    private const uint SHGFI_SMALLICON = 0x000000001;

    private const uint SHGFI_OPENICON = 0x000000002;

    private const uint SHGFI_SHELLICONSIZE = 0x000000004;

    private const uint SHGFI_PIDL = 0x000000008;

    private const uint SHGFI_USEFILEATTRIBUTES = 0x000000010;

}

namespace System.Drawing

{

    using System;

    using System.IO;

    using System.Security;

    using System.Security.Permissions;

    using System.Drawing.Printing;

    using System.Runtime.Versioning;

    internal static class IntSecurity

    {

        private static readonly UIPermission AllWindows = new UIPermission(UIPermissionWindow.AllWindows);

        private static readonly UIPermission SafeSubWindows = new UIPermission(UIPermissionWindow.SafeSubWindows);

        public static readonly CodeAccessPermission UnmanagedCode = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);

        public static readonly CodeAccessPermission ObjectFromWin32Handle = UnmanagedCode;

        public static readonly CodeAccessPermission Win32HandleManipulation = UnmanagedCode;

        public static readonly PrintingPermission NoPrinting = new PrintingPermission(PrintingPermissionLevel.NoPrinting);

        public static readonly PrintingPermission SafePrinting = new PrintingPermission(PrintingPermissionLevel.SafePrinting);

        public static readonly PrintingPermission DefaultPrinting = new PrintingPermission(PrintingPermissionLevel.DefaultPrinting);

        public static readonly PrintingPermission AllPrinting = new PrintingPermission(PrintingPermissionLevel.AllPrinting);

        [ResourceExposure(ResourceScope.None)]

        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]

        internal static void DemandReadFileIO(string fileName)

        {

            string full = fileName;

            full = UnsafeGetFullPath(fileName);

            new FileIOPermission(FileIOPermissionAccess.Read, full).Demand();

        }

        [ResourceExposure(ResourceScope.None)]

        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]

        internal static void DemandWriteFileIO(string fileName)

        {

            string full = fileName;

            full = UnsafeGetFullPath(fileName);

            new FileIOPermission(FileIOPermissionAccess.Write, full).Demand();

        }

        [ResourceExposure(ResourceScope.Machine)]

        [ResourceConsumption(ResourceScope.Machine)]

        internal static string UnsafeGetFullPath(string fileName)

        {

            string full = fileName;

            FileIOPermission fiop = new FileIOPermission(PermissionState.None);

            fiop.AllFiles = FileIOPermissionAccess.PathDiscovery;

            fiop.Assert();

            try

            {

                full = Path.GetFullPath(fileName);

            }

            finally

            {

                CodeAccessPermission.RevertAssert();

            }

            return full;

        }

        static PermissionSet allPrintingAndUnmanagedCode;

        public static PermissionSet AllPrintingAndUnmanagedCode

        {

            get

            {

                if (allPrintingAndUnmanagedCode == null)

                {

                    PermissionSet temp = new PermissionSet(PermissionState.None);

                    temp.SetPermission(IntSecurity.UnmanagedCode);

                    temp.SetPermission(IntSecurity.AllPrinting);

                    allPrintingAndUnmanagedCode = temp;

                }

                return allPrintingAndUnmanagedCode;

            }

        }

        internal static bool HasPermission(PrintingPermission permission)

        {

            try

            {

                permission.Demand();

                return true;

            }

            catch (SecurityException)

            {

                return false;

            }

        }

    }

}

<Window x:Class="SmartUpdate.MainWindow"

        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:local="clr-namespace:SmartUpdate"

        mc:Ignorable="d"

        WindowStyle="None" WindowStartupLocation="CenterScreen" ResizeMode="CanResizeWithGrip" AllowsTransparency="True"

        Title="MARKUS SmartUpdate" Height="450" Width="600">

        <Border Name="main" BorderThickness="1" BorderBrush="LightGray" Margin="0">

        <DockPanel>

            <Border Name="border" DockPanel.Dock="Top" Height="25" Background="#FF2A579A">

                <Grid>

                    <TextBlock Text="Markus SmartUpdate" Foreground="White" Margin="100,0,100,4" HorizontalAlignment="Center" VerticalAlignment="Bottom" x:Name="TitleText"/>

                    <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" VerticalAlignment="Stretch">

                        <Image Visibility="Visible" Source="Resources/minimize-window.png" Width="24" Height="24" MouseDown="WinState" x:Name="Win_min"/>

                        <Image Visibility="Visible" Source="Resources/maximize-window.png" Width="24" Height="24" MouseDown="WinState" x:Name="Win_max"/>

                        <Image Visibility="Visible" Source="Resources/close-window.png" Width="24" Height="24" MouseDown="WinState" x:Name="Win_Close"/>

                    </StackPanel>

                </Grid>

            </Border>

            <Grid Margin="0,0,0,0" Background="WhiteSmoke">

                <!--<ProgressBar Name="TotalDownloadProgressBar" HorizontalAlignment="Center" Height="30" VerticalAlignment="Top" Width="500" Margin="46,330,46,0" />-->

                <ProgressBar Name="PartialDownloadProgressBar" HorizontalAlignment="Center" Height="30" VerticalAlignment="Top" Width="500" Margin="46,362,46,0"/>

                <TextBlock Text="{Binding ElementName=PartialDownloadProgressBar, Path=Value, StringFormat={}{0:0}%}" HorizontalAlignment="Center" VerticalAlignment="Top" Margin="0,369,0,0"/>

                <ListView  HorizontalAlignment="Left" Height="236" Margin="46,103,0,0" VerticalAlignment="Top" Width="500" Name="downloadlist">

                    <ListView.View>

                        <GridView>

                            <!--<GridViewColumn Header="Num" Width="40" DisplayMemberBinding="{Binding Num}" />-->

                            <GridViewColumn Width="310"  Header="FileName" >

                                <GridViewColumn.CellTemplate>

                                    <DataTemplate>

                                        <StackPanel Orientation="Horizontal">

                                            <Image Source="{Binding SIcon}" Width="24" Height="24"></Image>

                                            <!--<Image Source="{Binding SIcon}" Width="24" Height="24"></Image>-->

                                            <TextBlock Text="{Binding FileName}"/>

                                        </StackPanel>

                                    </DataTemplate>

                                </GridViewColumn.CellTemplate>

                            </GridViewColumn>

                           <!-- <GridViewColumn Header="FileName" Width="260"  DisplayMemberBinding="{Binding FileName}" /> -->

                            <GridViewColumn Header="Version" Width="179" DisplayMemberBinding="{Binding Version}" />

                            <!--<GridViewColumn Header="Date" Width="100" DisplayMemberBinding="{Binding Date}" />-->

                        </GridView>

                    </ListView.View>

                </ListView>

                <Rectangle Fill="#FFFFFF" HorizontalAlignment="Center" Height="70" Stroke="LightGray" VerticalAlignment="Top" Width="596" Margin="0,1,0,0"/>

                <TextBlock HorizontalAlignment="Left" TextWrapping="Wrap" VerticalAlignment="Top" Height="50" Width="400" Margin="15,15,15,15">

            <Run FontWeight="Bold" FontStyle="Italic" FontSize="14" Text="MARKUS Update...." /><LineBreak />

            <Run FontStyle="Italic"  FontSize="12" Text="    업데이트 중입니다. 잠시만 기다려주세요... " />

                </TextBlock>

                <Image HorizontalAlignment="Left" Height="64" Margin="525,4,0,0" VerticalAlignment="Top" Width="70" Source="Resources/UpdateImg.png"/>

                <!--<Separator Margin="0,0,0,0"/>-->

                <!-- <TextBox FontSize="18" Text ="MARKUS SmartUpdate" Margin="200,67,200,0" HorizontalAlignment="Center"  VerticalAlignment="Top"/>-->

            </Grid>

        </DockPanel>

    </Border>

</Window>

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Diagnostics;

using System.IO;

using System.Net;

using System.Threading;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Input;

using System.Xml;

using System.Drawing;

using System.Windows.Media;

using Image = System.Windows.Controls.Image;

using System.Windows.Media.Imaging;

using System.Text;

using System.Runtime.InteropServices;

using System.Security;

namespace SmartUpdate

{

    /// <summary>

    /// MainWindow.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class MainWindow : Window

    {

        private int index = 0; //업데이트시 파일 하나씩 넘어가게 하기 위해서

        private bool check = false; //다운완료된것 체크

        private int lastIndex;

        private Thread theProgBarThread;

        private bool m_bLoop;        

        private string versionPath = null; //64, 86 버전에 따른 서버 파일 위치        

        private string[] strArg; //KCOM 접속 파라미터 값 받기 위해        

        private int c_index = 1; //마지막 파일 확인 후 종료하기 위해        

        private string msgFileName = SmartUpdate.Properties.Settings.Default.msgFileName; //메시지창에 띄워줄 프로그램명        

        private string FileName = SmartUpdate.Properties.Settings.Default.FileName; //실행파일명

        public MainWindow()

        {

            InitializeComponent();            

            WindowStartupLocation = WindowStartupLocation.CenterOwner; //창 가운데로

            WindowStartupLocation = WindowStartupLocation.CenterScreen; //창 가운데로            

            Topmost = true; //창 최상위로

            this.Loaded += new RoutedEventHandler(MainWindow_Loaded);

        }

        void MainWindow_Loaded(object sender, RoutedEventArgs e)

        {           

            m_bLoop = true;

            lastIndex = index = 0;

            theProgBarThread = new Thread(new ThreadStart(Step));

            theProgBarThread.Start();

            Thread.Sleep(100);

            PartialDownloadProgressBar.Maximum = 100;            

            strArg = Environment.GetCommandLineArgs(); //KCOM 접속 파라미터 값 받기 위해            

            ConnectUpgradeServer(); //여기서부터 XML 파싱 및 파일 다운로드

        }

        public class ItemInfo

        {

            public string FileName { get; set; }

            public string Version { get; set; }

            public ImageSource SIcon { get; set; }

        }

        List<ItemInfo> itemInfoList = new List<ItemInfo>();

        List<ItemInfo> downloadList = new List<ItemInfo>();

        private void SetXmlParseing() 

        {            

            try

            {

                XmlDocument xdoc = new XmlDocument();              

                if (Environment.Is64BitProcess == true) //64 bit machine

                {

                    versionPath = SmartUpdate.Properties.Settings.Default.UpdateVer64;

                }

                else //32 bit machine

                {

                    versionPath = SmartUpdate.Properties.Settings.Default.UpdateVer86;

                }

                // XML 데이타를 파일에서 로드

                xdoc.Load(versionPath);

                // 특정 노드들을 필터링

                XmlNodeList nodes = xdoc.SelectNodes("/RootElement/Item");

                foreach (XmlNode emp in nodes)

                {

                    string Filename = emp.SelectSingleNode("Filename").InnerText;

                    string Version = emp.SelectSingleNode("Version").InnerText;                    

                    try

                    {

                        //해당 파일이 서버에 있는지 확인

                        HttpWebRequest webreq = (HttpWebRequest)WebRequest.Create(Filename);

                        HttpWebResponse webres = (HttpWebResponse)webreq.GetResponse();

                        webres.Close();

                        webreq = null;

                        webres = null;

                        if (File.Exists(AppDomain.CurrentDomain.BaseDirectory + @Path.GetFileName(Filename))) //해당 파일이 클라이언트에 있는가?

                        {

                            if (IsAccessAble(AppDomain.CurrentDomain.BaseDirectory + @Path.GetFileName(Filename)) == false) //다운받으려는 파일이 다른곳에서 점유중인지 확인.

                            {

                                ErrorLogFileWrite("실행중인 파일로 인해 업데이트 실패 : " + @Path.GetFileName(Filename));

                                SmartUpdateExit("실행중인 "+ msgFileName + "가 있습니다. \n모두 닫은 후 다시 실행해주세요."); //스마트 업데이트 종료

                            }

                            else if (FileVersionInfo.GetVersionInfo(AppDomain.CurrentDomain.BaseDirectory + @Path.GetFileName(Filename)).FileVersion != Version) //두개의 버전이 다른가?

                            {

                                itemInfoList.Add(new ItemInfo() { FileName = Filename, Version = Version });                               

                                ImageSource icon = IconManager.GetIcon(@Path.GetFileName(Filename), false, false);                                

                                downloadList.Add(new ItemInfo() { FileName = @Path.GetFileName(Filename), Version = Version, SIcon = icon });

                            }

                        }

                        else

                        {

                            itemInfoList.Add(new ItemInfo() { FileName = Filename, Version = Version });

                            ImageSource icon = IconManager.GetIcon(@Path.GetFileName(Filename), false, false);

                            downloadList.Add(new ItemInfo() { FileName = @Path.GetFileName(Filename), Version = Version, SIcon = icon });

                        }                        

                    }

                    catch(Exception ex) //다운로드 받아야할 파일이 서버에 없을 경우 스마트업데이트 강제 종료.

                    {

                        ErrorLogFileWrite("Err : " + ex);

                        SmartUpdateExit("서버에 파일이 없습니다.");

                    }

                }

                downloadlist.ItemsSource = downloadList;

                SetDown();                  

            }

            catch(Exception ex) //version.xml 파일이 없을 경우 스마트업데이트 강제 종료.

            {

                ErrorLogFileWrite("Err : " + ex);

                SmartUpdateExit("File Loading Error SmartUpdate를 종료합니다."); //스마트 업데이트 종료

            }                 

        }

        private void SetDown()

        {

            try

            {                

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

                {

                    WebClient theDownloadThread = new WebClient();

                    Uri url = new Uri(itemInfoList[i].FileName);

                    theDownloadThread.DownloadProgressChanged += new DownloadProgressChangedEventHandler(DownloadProgressChanged);   

                    theDownloadThread.DownloadFileCompleted += new AsyncCompletedEventHandler(Completed);

                    string filename = Path.GetFileName(itemInfoList[i].FileName);

                    theDownloadThread.DownloadFileAsync(url, AppDomain.CurrentDomain.BaseDirectory + filename);

                }               

            }

            catch(Exception ee) //다운로드 도중 에러시 스마트업데이트 강제 종료. 

            {

                ErrorLogFileWrite("SetDown()  \r\n 상세로그 : " + ee);

                SmartUpdateExit("File Download Error SmartUpdate를 종료합니다."); //스마트 업데이트 종료

            }            

        }

        private void ConnectUpgradeServer()

        {

            try

            {              

                SetXmlParseing();                

            }

            catch (Exception er)

            {

                string strError = er.ToString();

                MarkusStart(strError);

            }

        }

        private void MarkusStart(string MessageStr)

        {

            try

            {

                ErrorLogFileWrite("상세로그 : " + MessageStr);

                ProcessStartInfo proInfo = new ProcessStartInfo();

                proInfo.FileName = AppDomain.CurrentDomain.BaseDirectory + FileName;

                if (strArg.Length > 1)

                {

                    proInfo.Arguments = strArg[1];

                }

                Process.Start(proInfo);

                //현재 실행되고 있는 자기 자신 프로세스의 정보

                Process proc = Process.GetCurrentProcess();

                proc.Kill();

            }

            catch (Exception ee)

            {

                ErrorLogFileWrite("Err로그 : " + ee);

                //MessageBox.Show(ee + "MARKUS를 재실행 해주시기 바랍니다.");

            }

        }

        private void SmartUpdateExit(string MessageStr)

        {

            try

            {

                MessageBox.Show(MessageStr, "종료합니다.", MessageBoxButton.OK);

                //현재 실행되고 있는 자기 자신 프로세스의 정보

                Process proc = Process.GetCurrentProcess();

                proc.Kill();

            }

            catch (Exception ex)

            {

                ErrorLogFileWrite("SmartUpdateExit()  \r\n 상세로그 : " + MessageStr);

            }

        }

        //http://blog.naver.com/PostView.nhn?blogId=nersion&logNo=140150987526&parentCategoryNo=&categoryNo=56&viewDate=&isShowPopularPosts=true&from=search

        private bool IsAccessAble(String path)

        {

            FileStream fs = null;

            try

            {

                //앞단에서 파일이 있는 경우에만 타도록 했음 그렇지 않으면 파일 자체가 없을때도 false 반환

                fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite, FileShare.None);                                

            }

            catch (IOException)

            {

                //에러가 발생한 이유는 이미 다른 프로세서에서 점유중.               

                return false;

            }

            finally

            {

                if (fs != null)

                {

                    //만약에 파일이 정상적으로 열렸다면 점유중이 아니다.

                    //다시 파일을 닫아줘야 한다.

                    fs.Close();

                }

            }

            return true;

        }

        protected XmlNode CreateNode(XmlDocument xmlDoc, string name, string innerXml)

        {

            XmlNode node = xmlDoc.CreateElement(string.Empty, name, string.Empty);

            node.InnerXml = innerXml;

            return node;

        }

        private void Step()

        {

            while (m_bLoop)

            {

                if (lastIndex < index)

                {

                    lastIndex++;

                }

                Thread.Sleep(1000);

            }

        }

        private void Completed(object sender, AsyncCompletedEventArgs e)

        {

            c_index++;

            if (c_index > itemInfoList.Count)

            {

                try

                {                 

                    ProcessStartInfo proInfo = new ProcessStartInfo();

                    proInfo.FileName = AppDomain.CurrentDomain.BaseDirectory + FileName;

                    if (strArg.Length > 1)

                    {

                        proInfo.Arguments = strArg[1];

                    }

                    Process.Start(proInfo);

                    //현재 실행되고 있는 자기 자신 프로세스의 정보

                    Process proc = Process.GetCurrentProcess();

                    proc.Kill();

                }

                catch (Exception ee)

                {

                    ErrorLogFileWrite("SmartUpdate 종료 또는 "+ msgFileName + "실행에 실패했습니다.  \r\n 상세로그 : " + ee);

                    //MessageBox.Show(strArg[1] + "MARKUS를 재실행 해주시기 바랍니다.");

                }

            }

        }

        //파일 다운로드 상황을 반영한다.

        private void DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)

        {

            //PartialDownloadProgressBar.Value = e.ProgressPercentage;               

            //이전에 다운로드 받은 파일이 완료되었다면

            if (e.TotalBytesToReceive == e.BytesReceived && !check)

            {

                if (index < itemInfoList.Count)

                {

                    index++;

                    PartialDownloadProgressBar.Value = (Convert.ToDouble(index) / Convert.ToDouble(itemInfoList.Count)) * 100;

                    LogFileWrite();

                }                

            }

            else

            {

                check = false;

            }

        }

        private void ErrorLogFileWrite(string Err)

        {

            try

            {

                string pathString = AppDomain.CurrentDomain.BaseDirectory + "UpdateLog\\Err";

                if (!File.Exists(pathString))

                {                    

                    Directory.CreateDirectory(pathString);

                }

                Err = Err + "   " +DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss")  + "\r\n";

                string path = pathString + "\\" + "UpdateErrLog_" + DateTime.Now.ToString("yyyy-MM-dd hh-mm") + ".txt";

                File.AppendAllText(path, Err);

            }

            catch (Exception er)

            {

                string strError = er.ToString();

                //MessageBox.Show("err : " + er);

            }

        }

        private void LogFileWrite()

        {

            try

            {

                string pathString = AppDomain.CurrentDomain.BaseDirectory + "UpdateLog";

                if (!File.Exists(pathString))

                {                    

                    Directory.CreateDirectory(pathString);

                }                   

                FileStream fs = new FileStream(pathString + "\\UpdateLog_" + DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss") + ".txt", FileMode.OpenOrCreate, FileAccess.Write);

                StreamWriter sw = new StreamWriter(fs);

                sw.WriteLine("<업그레이드 정보>");

                sw.WriteLine("<업데이트 날짜>");

                sw.WriteLine("{0}", DateTime.Today.ToLongDateString());

                sw.WriteLine("<업데이트 파일>");

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

                    sw.WriteLine("{0}", itemInfoList[i].FileName);

                sw.Close();

                fs.Close();

            }

            catch (Exception er)

            {

                string strError = er.ToString();

                ErrorLogFileWrite("업데이트 파일 작성에 실패했습니다.  \r\n 상세로그 : " + strError);

            }

        }

        private void WinState(object sender, MouseButtonEventArgs e)

        {

            switch ((e.Source as Image).Name)

            {

                case ("Win_min"):

                    {

                        WindowState = WindowState.Minimized;

                    }

                    break;

                case ("Win_max"):

                    {

                        if (WindowState == WindowState.Maximized)

                        {

                            WindowState = WindowState.Normal;

                        }

                        else

                        {

                            WindowState = WindowState.Maximized;

                        }

                    }

                    break;

                case ("Win_Close"):

                    {                       

                        this.Close();

                    }

                    break;

            }

        }

    }

}

using System.Reflection;

using System.Resources;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

using System.Windows;

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

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

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

[assembly: AssemblyTitle("SmartUpdate")]

[assembly: AssemblyDescription("")]

[assembly: AssemblyConfiguration("")]

[assembly: AssemblyCompany("")]

[assembly: AssemblyProduct("SmartUpdate")]

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

[assembly: AssemblyTrademark("")]

[assembly: AssemblyCulture("")]

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

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

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

[assembly: ComVisible(false)]

//지역화 가능 응용 프로그램 빌드를 시작하려면 다음을 설정하세요.

//.csproj 파일에서 <PropertyGroup> 내에 <UICulture>CultureYouAreCodingWith</UICulture>를

//설정하십시오. 예를 들어 소스 파일에서 영어(미국)를

//사용하는 경우 <UICulture>를 en-US로 설정합니다. 그런 다음 아래

//NeutralResourceLanguage 특성의 주석 처리를 제거합니다. 아래 줄의 "en-US"를 업데이트하여

//프로젝트 파일의 UICulture 설정과 일치시킵니다.

//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]

[assembly: ThemeInfo(

    ResourceDictionaryLocation.None, //테마별 리소스 사전의 위치

                                     //(페이지 또는 응용 프로그램 리소스 사진에

                                     // 리소스가 없는 경우에 사용됨)

    ResourceDictionaryLocation.SourceAssembly //제네릭 리소스 사전의 위치

                                              //(페이지 또는 응용 프로그램 리소스 사진에

                                              // 리소스가 없는 경우에 사용됨)

)]

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

//

//      주 버전

//      부 버전 

//      빌드 번호

//      수정 버전

//

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

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

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

[assembly: AssemblyVersion("1.0.0.0")]

[assembly: AssemblyFileVersion("1.0.0.0")]

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 도구를 사용하여 생성되었습니다.

//     런타임 버전:4.0.30319.42000

//

//     파일 내용을 변경하면 잘못된 동작이 발생할 수 있으며, 코드를 다시 생성하면

//     이러한 변경 내용이 손실됩니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace SmartUpdate.Properties {

    using System;

    /// <summary>

    ///   지역화된 문자열 등을 찾기 위한 강력한 형식의 리소스 클래스입니다.

    /// </summary>

    // 이 클래스는 ResGen 또는 Visual Studio와 같은 도구를 통해 StronglyTypedResourceBuilder

    // 클래스에서 자동으로 생성되었습니다.

    // 멤버를 추가하거나 제거하려면 .ResX 파일을 편집한 다음 /str 옵션을 사용하여 ResGen을

    // 다시 실행하거나 VS 프로젝트를 다시 빌드하십시오.

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]

    internal class Resources {

        private static global::System.Resources.ResourceManager resourceMan;

        private static global::System.Globalization.CultureInfo resourceCulture;

        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]

        internal Resources() {

        }

        /// <summary>

        ///   이 클래스에서 사용하는 캐시된 ResourceManager 인스턴스를 반환합니다.

        /// </summary>

        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]

        internal static global::System.Resources.ResourceManager ResourceManager {

            get {

                if (object.ReferenceEquals(resourceMan, null)) {

                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SmartUpdate.Properties.Resources", typeof(Resources).Assembly);

                    resourceMan = temp;

                }

                return resourceMan;

            }

        }

        /// <summary>

        ///   이 강력한 형식의 리소스 클래스를 사용하여 모든 리소스 조회에 대해 현재 스레드의 CurrentUICulture 속성을

        ///   재정의합니다.

        /// </summary>

        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]

        internal static global::System.Globalization.CultureInfo Culture {

            get {

                return resourceCulture;

            }

            set {

                resourceCulture = value;

            }

        }

    }

}

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

<root>

  <!-- 

    Microsoft ResX Schema 

    Version 2.0

    The primary goals of this format is to allow a simple XML format 

    that is mostly human readable. The generation and parsing of the 

    various data types are done through the TypeConverter classes 

    associated with the data types.

    Example:

    ... ado.net/XML headers & schema ...

    <resheader name="resmimetype">text/microsoft-resx</resheader>

    <resheader name="version">2.0</resheader>

    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>

    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>

    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>

    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>

    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">

        <value>[base64 mime encoded serialized .NET Framework object]</value>

    </data>

    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">

        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>

        <comment>This is a comment</comment>

    </data>

    There are any number of "resheader" rows that contain simple 

    name/value pairs.

    Each data row contains a name, and value. The row also contains a 

    type or mimetype. Type corresponds to a .NET class that support 

    text/value conversion through the TypeConverter architecture. 

    Classes that don't support this are serialized and stored with the 

    mimetype set.

    The mimetype is used for serialized objects, and tells the 

    ResXResourceReader how to depersist the object. This is currently not 

    extensible. For a given mimetype the value must be set accordingly:

    Note - application/x-microsoft.net.object.binary.base64 is the format 

    that the ResXResourceWriter will generate, however the reader can 

    read any of the formats listed below.

    mimetype: application/x-microsoft.net.object.binary.base64

    value   : The object must be serialized with 

            : System.Serialization.Formatters.Binary.BinaryFormatter

            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.soap.base64

    value   : The object must be serialized with 

            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter

            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64

    value   : The object must be serialized into a byte array 

            : using a System.ComponentModel.TypeConverter

            : and then encoded with base64 encoding.

    -->

  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">

    <xsd:element name="root" msdata:IsDataSet="true">

      <xsd:complexType>

        <xsd:choice maxOccurs="unbounded">

          <xsd:element name="metadata">

            <xsd:complexType>

              <xsd:sequence>

                <xsd:element name="value" type="xsd:string" minOccurs="0" />

              </xsd:sequence>

              <xsd:attribute name="name" type="xsd:string" />

              <xsd:attribute name="type" type="xsd:string" />

              <xsd:attribute name="mimetype" type="xsd:string" />

            </xsd:complexType>

          </xsd:element>

          <xsd:element name="assembly">

            <xsd:complexType>

              <xsd:attribute name="alias" type="xsd:string" />

              <xsd:attribute name="name" type="xsd:string" />

            </xsd:complexType>

          </xsd:element>

          <xsd:element name="data">

            <xsd:complexType>

              <xsd:sequence>

                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />

                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />

              </xsd:sequence>

              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />

              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />

              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />

            </xsd:complexType>

          </xsd:element>

          <xsd:element name="resheader">

            <xsd:complexType>

              <xsd:sequence>

                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />

              </xsd:sequence>

              <xsd:attribute name="name" type="xsd:string" use="required" />

            </xsd:complexType>

          </xsd:element>

        </xsd:choice>

      </xsd:complexType>

    </xsd:element>

  </xsd:schema>

  <resheader name="resmimetype">

    <value>text/microsoft-resx</value>

  </resheader>

  <resheader name="version">

    <value>2.0</value>

  </resheader>

  <resheader name="reader">

    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>