MARKUS

                // 플러그인 실행

                PluginService.Run(saveitem.Id);

                result.StatusCode = StatusCodeType.Error;

                StationServiceClient.ConvertFinish(saveitem.Id, (int)result.StatusCode, saveitem.CurrentPage, saveitem.TotalPages, $"ConvertService Error    {saveitem.Id} {ex.Message} {ex.InnerException?.ToString()}");

    <Reference Include="ConfigParser, Version=0.3.3.6, Culture=neutral, processorArchitecture=MSIL">

      <HintPath>..\packages\Salaros.ConfigParser.0.3.3\lib\net45\ConfigParser.dll</HintPath>

    </Reference>

    <Compile Include="Plugin.cs" />

    <ProjectReference Include="..\Markus.Service.Convert.IPlugin\Markus.Service.Convert.IPlugin.csproj">

      <Project>{a5ba7325-379c-4ccb-b156-1704fc2175e3}</Project>

      <Name>Markus.Service.Convert.IPlugin</Name>

    </ProjectReference>

using Markus.Service.Extensions;

using Markus.Service.Helper;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Markus.Service.Convert.Plugin;

using log4net;

namespace Markus.Service

{

    public static class PluginService

    {

        private const string ConfigFileName = "Plugin.ini";

        private const string BasePath = "Plugin";

        public static bool Run(string ConvertID)

        {

            bool result = false;

            var pluginPath = System.IO.Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, BasePath);

            var plugins = GenericPluginLoader<IPlugin>.LoadPlugins(pluginPath);

            var config = ConfigHelper.AppConfig(ConfigFileName);

            if (plugins != null)

            {

                foreach (var item in plugins)

                {

                    Dictionary<string, object> parameters = new Dictionary<string, object>();

                    var sections = config.Sections.Where(x => x.SectionName == item.Name);

                    if (sections.Count() > 0)

                    {

                        foreach (var param in sections.First().Keys)

                        {

                            parameters.Add(param.Name, param.Content);

                        }

                    }

                    var pluginResult = item.Do(ConvertID, parameters);

                    if (!pluginResult)

                    {

                       throw new Exception($"Markus.Service.ConvertProcess Error ConvertId : {ConvertID} PlugIn Error : ", new Exception(item.Exception.ToString()));

                    }

                }

            }

            return result;

        }

    }

}

  <package id="Microsoft.CSharp" version="4.5.0" targetFramework="net45" />

  <package id="Salaros.ConfigParser" version="0.3.3" targetFramework="net45" />

using System;

using System.Collections.Generic;

using System.Linq;

using System.Linq.Expressions;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public static class CollectionExtensions

    {

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

        //{

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

        //    {

        //        var item = source[i];

        //         Target.Where(f=>)

        //        item.GetType().GetProperty()

        //    }

        //}

        /// <summary>

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

        /// </summary>

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

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

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

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

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(change, "change");

            foreach (var item in enumerable)

            {

                yield return change(item);

            }

        }

        /// <summary>

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

        /// </summary>

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

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

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

        /// <returns>

        /// An IEnumerable with all changes applied

        /// </returns>

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

                                                    Func<T, T> change,

                                                    Func<T, bool> @where)

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(change, "change");

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

            foreach (var item in enumerable)

            {

                if (@where(item))

                {

                    yield return change(item);

                }

                else

                {

                    yield return item;

                }

            }

        }

        public static class ArgumentCheck

        {

            /// <summary>

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

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

            /// </summary>

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

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

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

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

            {

                Type type = typeof(T);

                if (type == typeof(string) ||

                    type == typeof(String))

                {

                    if (string.IsNullOrWhiteSpace(item as string))

                    {

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

                    }

                }

                else

                {

                    if (item == null)

                    {

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

                    }

                }

            }

        }

        /// <summary>

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

        /// </summary>

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

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

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

        /// <returns>

        /// An IEnumerable with all changes applied

        /// </returns>

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

                                                     Func<T, T> change,

                                                     Func<T, bool> @where)

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(change, "change");

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

            foreach (var item in enumerable)

            {

                if (!@where(item))

                {

                    yield return change(item);

                }

                else

                {

                    yield return item;

                }

            }

        }

        /// <summary>

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

        /// </summary>

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

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

        /// <returns>

        /// The same enumerable you passed in

        /// </returns>

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

                                               Action<T> update) where T : class

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(update, "update");

            foreach (var item in enumerable)

            {

                update(item);

            }

            return enumerable;

        }

        /// <summary>

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

        /// where the where function returns true

        /// </summary>

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

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

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

        /// <returns>

        /// The same enumerable you passed in

        /// </returns>

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

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

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(update, "update");

            foreach (var item in enumerable)

            {

                if (where(item))

                {

                    update(item);

                }

            }

            return enumerable;

        }

        /// <summary>

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

        /// Except the elements from the where function

        /// </summary>

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

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

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

        /// <returns>

        /// The same enumerable you passed in

        /// </returns>

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

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

        {

            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");

            ArgumentCheck.IsNullorWhiteSpace(update, "update");

            foreach (var item in enumerable)

            {

                if (!where(item))

                {

                    update(item);

                }

            }

            return enumerable;

        }

    }

}

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public class Encrypt

    {

        public static class AESEncrypter

        {

            private static RijndaelManaged _rManaged = new RijndaelManaged();

            private static UTF8Encoding _utf8Encoder = new UTF8Encoding();

            static AESEncrypter()

            {

                MD5 _md5 = new MD5CryptoServiceProvider();

                _rManaged.KeySize = 256;

                _rManaged.BlockSize = 128;

                _rManaged.Mode = CipherMode.CBC;

                _rManaged.Padding = PaddingMode.PKCS7;

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

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

            }

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

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

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

            public static string Encrypt(string val)

            {

                string _resVal = string.Empty;

                byte[] _utf8Val = null;

                byte[] _encryptVal = null;

                ICryptoTransform tForm = _rManaged.CreateEncryptor();

                try

                {

                    if (!string.IsNullOrEmpty(val))

                    {

                        _utf8Val = _utf8Encoder.GetBytes(val);

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

                        _resVal = Convert.ToBase64String(_encryptVal);

                    }

                    else

                        _resVal = string.Empty;

                }

                catch

                {

                    _resVal = string.Empty;

                }

                return _resVal;

            }

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

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

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

            public static string Decrypt(string val)

            {

                string _resVal = string.Empty;

                byte[] _decryptVal = null;

                byte[] _encryptVal = null;

                ICryptoTransform tForm = _rManaged.CreateDecryptor();

                try

                {

                    if (!string.IsNullOrEmpty(val))

                    {

                        _encryptVal = Convert.FromBase64String(val);

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

                        _resVal = _utf8Encoder.GetString(_decryptVal);

                    }

                    else

                        _resVal = string.Empty;

                }

                catch

                {

                    _resVal = string.Empty;

                }

                return _resVal;

            }

        }

    }

}

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Management;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public static class ProcessExtension

    {

        /// <summary>

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

        /// </summary>

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

        /// <returns></returns>

        public static ProcessArguments Arguments(this Process process)

        {

            ProcessArguments result = new ProcessArguments();

            var commandLine = ProcessCommandLinesQuery(process.Id);

            try

            {

                result.WorkingDirectory = ProcessWorkingDirectory(commandLine);

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

            }

            catch (Exception ex)

            {

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

            }

            return result;

        }

        /// <summary>

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

        /// </summary>

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

        /// <returns></returns>

        public static string WorkingDirectory(this Process process)

        {

            var commandLine = ProcessCommandLinesQuery(process.Id);

            return ProcessWorkingDirectory(commandLine);

        }

        private static string ProcessCommandLinesQuery(int processId)

        {

            string result = "";

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

            ManagementObjectSearcher searcher = new ManagementObjectSearcher(wmiQuery);

            ManagementObjectCollection retObjectCollection = searcher.Get();

            if (retObjectCollection.Count > 0)

            {

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

                {

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

                }

                else

                {

                    result = "";

                }

            }

            return result;

        }

        private static string ProcessWorkingDirectory(string commandLine)

        {

            var splitCommand = commandLine.Split(' ');

            string filePath = "";

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

            {

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

                if (IO.FileExists(filePath))

                {

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

                    filePath = info.DirectoryName;

                    break;

                }

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

                {

                    var firstCmd = splitCommand.First();

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

                    {

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

                    }

                }

                else

                {

                    filePath = commandLine;

                }

            }

            return filePath;

        }

        /// <summary>

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

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

        /// </summary>

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

        /// <returns></returns>

        private static string RemoveCommadLinesFilePath(string commandLine)

        {

            string result = "";

            var splitCommand = commandLine.Split(' ');

            string filePath = "";

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

            {

                filePath += " " + splitCommand[i];

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

                {

                    result = string.Join(" ", splitCommand.Skip(i + 1).Take(splitCommand.Count() - i));

                    break;

                }

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

                {

                    var firstCmd = splitCommand.First();

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

                    {

                        result = string.Join(" ", splitCommand.Skip(1).Take(splitCommand.Count() - 1));

                    }

                }

                else

                {

                    result = commandLine;

                }

            }

            return result;

        }

        public static string[] SplitArguments(string commandLine)

        {

            List<string> args = new List<string>();

            List<char> currentArg = new List<char>();

            char? quoteSection = null; // Keeps track of a quoted section (and the type of quote that was used to open it)

            char[] quoteChars = new[] { '\'', '\"' };

            char previous = ' '; // Used for escaping double quotes

            for (var index = 0; index < commandLine.Length; index++)

            {

                char c = commandLine[index];

                if (quoteChars.Contains(c))

                {

                    if (previous == c) // Escape sequence detected

                    {

                        previous = ' '; // Prevent re-escaping

                        if (!quoteSection.HasValue)

                        {

                            quoteSection = c; // oops, we ended the quoted section prematurely

                            continue;         // don't add the 2nd quote (un-escape)

                        }

                        if (quoteSection.Value == c)

                            quoteSection = null; // appears to be an empty string (not an escape sequence)

                    }

                    else if (quoteSection.HasValue)

                    {

                        if (quoteSection == c)

                            quoteSection = null; // End quoted section

                    }

                    else

                        quoteSection = c; // Start quoted section

                }

                else if (char.IsWhiteSpace(c))

                {

                    if (!quoteSection.HasValue)

                    {

                        args.Add(new string(currentArg.ToArray()));

                        currentArg.Clear();

                        previous = c;

                        continue;

                    }

                }

                currentArg.Add(c);

                previous = c;

            }

            if (currentArg.Count > 0)

                args.Add(new string(currentArg.ToArray()));

            return args.ToArray();

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public class ProcessArguments

    {

        public string WorkingDirectory { get; set; }

        public List<string> CommandLine { get; set; }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public static class IO

    {

        /// <summary>

        /// System.IO.PathTooLongException 방지를 위해서 생성

        /// </summary>

        /// <param name="path"></param>

        /// <returns></returns>

        public static bool FileExists(string path)

        {

            bool result = false;

            if (path.Length < 260)

            {

                if (System.IO.File.Exists(path))

                {

                    result = true;

                }

            }

            return result;

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net.NetworkInformation;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    /// <summary>

    /// 네트워크 관련 확장코드

    /// </summary>

   public static  class SytemNet

    {

        /// <summary>

        /// 웹uri 활성화 상태 체크

        /// </summary>

        /// <param name="strUri"></param>

        /// <returns></returns>

        public static async Task<bool> PingAsync(string strUri)

        {

            bool result = false;

            try

            {

                Uri uri = new Uri(strUri);

                Ping pingSender = new Ping();

                PingReply reply = pingSender.Send(uri.Host);

                if (reply.Status == IPStatus.Success)

                {

                    using (System.Net.Http.HttpClient Client = new System.Net.Http.HttpClient())

                    {

                        Client.Timeout = new TimeSpan(0, 1,0);

                        var message = await Client.GetAsync(uri);

                        System.Net.Http.HttpResponseMessage responseMessage = message;

                        System.Net.HttpStatusCode StatusCode = responseMessage.StatusCode;

                        switch (StatusCode)

                        {

                            case System.Net.HttpStatusCode.Accepted:

                            case System.Net.HttpStatusCode.OK:

                                result = true;

                                break;

                        }

                    }

                }

                else

                {

                    result = false;

                }

            }

            catch (AggregateException ae)

            {

                foreach (var e in ae.InnerExceptions)

                {

                    // Handle the custom exception.

                    if (e is CustomException)

                    {

                        Console.WriteLine(e.Message);

                    }

                    // Rethrow any other exception.

                    else

                    {

                        Console.WriteLine(strUri + " Connection Error");

                    }

                }

            }

            catch (Exception)

            {

            }

            return result;

        }

    }

    public class CustomException : Exception

    {

        public CustomException(String message) : base(message)

        { }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public static class GuidExtension

    {

        public static Guid CreateUniqueGuid(this Guid guid)

        {

            return GetUniqueGuid();

        }

        private static Guid GetUniqueGuid()

        {

            char[] chars = "ABCDEF1234567890".ToCharArray();

            byte[] data = new byte[1];

            System.Security.Cryptography.RNGCryptoServiceProvider crypto = new System.Security.Cryptography.RNGCryptoServiceProvider();

            crypto.GetNonZeroBytes(data);

            data = new byte[32];

            crypto.GetNonZeroBytes(data);

            StringBuilder result = new StringBuilder(32);

            foreach (byte b in data)

            {

                result.Append(chars[b % (chars.Length - 1)]);

            }

            return Guid.ParseExact(result.ToString(0, 8) + "-" + result.ToString(8, 4) + "-" + result.ToString(11, 4) + "-"

                + result.ToString(16, 4) + "-" + result.ToString(20, 12), "D");

        }

        public static string shortGuid()

        {

            byte[] numArray = new byte[16];

            using (RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create())

                randomNumberGenerator.GetBytes(numArray);

            return Convert.ToBase64String(new Guid(numArray).ToByteArray()).Substring(0, 10).Replace("/", "").Replace("+", "") + DateTime.UtcNow.Ticks.ToString("x");

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Service.Extensions

{

    public static class StringExtension

    {

        public static bool IsNullOrEmpty(this string value)

        {

            if(!string.IsNullOrWhiteSpace(value))

            {

                return false;

            }

            else

            {

                return true;

            }

        }

        public static bool IsNumber(this string value)

        {

            int outValue = 0;

            return int.TryParse(value, out outValue);

        }

    }

}

    <ProjectReference Include="..\Markus.Service.WcfClient\Markus.Service.WcfClient.csproj">

      <Project>{691078d3-be0e-4697-bab6-ed3aca842d19}</Project>

      <Name>Markus.Service.WcfClient</Name>

/*

   Copyright 2013 Christoph Gattnar

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

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

   You may obtain a copy of the License at

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

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

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

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

   See the License for the specific language governing permissions and

   limitations under the License.

*/

using System;

using System.Collections.Generic;

using System.IO;

using System.Reflection;

namespace Markus.Service.Extensions

{

	public static class GenericPluginLoader<T>

	{

		public static ICollection<T> LoadPlugins(string path)

		{

			string[] dllFileNames = null;

			if(Directory.Exists(path))

			{

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

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

				foreach(string dllFile in dllFileNames)

				{

					AssemblyName an = AssemblyName.GetAssemblyName(dllFile);

					Assembly assembly = Assembly.Load(an);

					assemblies.Add(assembly);

				}

				Type pluginType = typeof(T);

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

				foreach(Assembly assembly in assemblies)

				{

					if(assembly != null)

					{

						Type[] types = assembly.GetTypes();

						foreach(Type type in types)

						{

							if(type.IsInterface || type.IsAbstract)

							{

								continue;

							}

							else

							{

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

								{

									pluginTypes.Add(type);

								}

							}

						}

					}

				}

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

				foreach(Type type in pluginTypes)

				{

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

					plugins.Add(plugin);

				}

				return plugins;

			}

			return null;

		}

	}

}

    <Compile Include="Exntensions\GenericPluginLoader.cs" />