CodeDom

Lambda

변수 선언

가능                                      

불가 (단 하나의 표현식만 가능)

함수 작성

사용자가 C# 문법을 알아야함

간단하게 식 사용

Math 및 기타

라이브러리 지원

지원

지원(lambda-parser 오픈소스 사용)

컴파일 오류

오류 위치 확인 가능

오류 위치 확인 어려움

컴파일 형태

소스코드->CodeDom 그래프->IL 컴파일 (개발 복잡)

1.     Dll 파일 형태

2.     메모리 형태

소스코드->Expression tree->IL 컴파일

(소스코드 관리 편함)

1.     메모리 형태

호출 속도

1.     Func Delegate로 컴파일시 빠름, 단 함수 형태가 정의 되어있어야함

2.     DynamicInvoke는 느리지만 유연함

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace CalcDynamicCompile
{
    class AssemblyHelper :IDisposable
    {
        AppDomain newAppDomain;
        AssemblyLoader proxy;
        
 
        internal void LoadAssembly(string assemName)
        {
            AppDomainSetup setup = new AppDomainSetup();
            setup.ShadowCopyFiles = "true";
 
            newAppDomain = AppDomain.CreateDomain("newDomain", null, setup);
            proxy = newAppDomain.CreateInstanceAndUnwrap(typeof(AssemblyLoader).Assembly.FullName, 
                  typeof(AssemblyLoader).FullName) as AssemblyLoader;
 
            proxy.LoadAssembly(assemName);
        }
 
        internal string LoadCode()
        {
            return proxy.LoadCode();
        }
        
        internal void CreateInstance()
        {
            this.proxy.CreateInstance();
            
        }
 
        internal void CreateDelegate(string methodName)
        {
            this.proxy.CreateDelegate(methodName);
        }
 
        void IDisposable.Dispose()
        {
            proxy = null;
            AppDomain.Unload(newAppDomain);
            newAppDomain = null;
        }
 
        internal void Test(object[] param)
        {
            this.proxy.Test(param);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Diagnostics;
 
namespace CalcDynamicCompile
{
    public class AssemblyLoader : MarshalByRefObject
    {
        Assembly assem;
        object instance;
        Delegate dele;
        Func<float, float, float> func;

 
        public void LoadAssembly(string filename)
        {
            assem = Assembly.LoadFile(filename);
        }
 
        public override object InitializeLifetimeService()
        {
            // 이 객체가 원격 도메인 유휴 시간에 의해 자동으로 삭제되지 않게 함
            return null;
        }
 
        internal string LoadCode()
        {
            string code = string.Empty;
            string[] list = assem.GetManifestResourceNames();
            if (list.Length > 0)
            {
                using (System.Resources.ResourceReader sr = new System.Resources.ResourceReader(assem.GetManifestResourceStream(list[0])))
                {
                    string resourceType;
                    byte[] resourceData;
                    sr.GetResourceData("code.txt", out resourceType, out resourceData);
 
                    code = Encoding.ASCII.GetString(resourceData).Remove(0, 4);
                }
            }
 
            return code;
        }
 
 
        internal void CreateInstance()
        {
            Type type = assem.GetExportedTypes()[0];
            instance = Activator.CreateInstance(type);
        }
 
        internal void CreateDelegate(string methodName)
        {
            Type type = assem.GetExportedTypes()[0];
 
            MethodInfo info = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy); ;
 
            List<Type> tArgs = new List<Type>();
 
            foreach (var param in info.GetParameters())
                tArgs.Add(param.ParameterType);
            tArgs.Add(info.ReturnType);
 
            Type delDecltype = System.Linq.Expressions.Expression.GetDelegateType(tArgs.ToArray());
            this.dele = Delegate.CreateDelegate(delDecltype, this.instance, info);
            this.func = (Func<float, float, float>)this.dele;
        }
 
        internal void Test(object[] param)
        {
            Stopwatch sw = Stopwatch.StartNew();
 
            float res = 0;
 
            for (int i = 0; i < 100000; i++)
            {
                if (param == null)
                {
                    res = (float)this.dele.DynamicInvoke(null);
                }
                else
                {
                    res = (float)this.dele.DynamicInvoke(param);
                }
            }
            sw.Stop();
 
            Console.WriteLine(string.Format("DynamicInvoke : {0}", sw.Elapsed.ToString()), res.ToString());
 
 
            sw = Stopwatch.StartNew();
 
            for (int i = 0; i < 100000; i++)
            {
                res = this.func((float)param[0], (float)param[1]);
            }
 
            sw.Stop();
 
            Console.WriteLine(string.Format("FuncInvoke : {0}", sw.Elapsed.ToString()), res.ToString());
 
            sw = Stopwatch.StartNew();
 
            for (int i = 0; i < 100000; i++)
            {
                res = ((float)param[0] * (float)param[1]) / 2 + 3 - 2 * 321;
            }
 
            sw.Stop();
 
            Console.WriteLine(string.Format("Call : {0}\n", sw.Elapsed.ToString()), res.ToString());
        }
 
        float Test(float a, float b)
        {
            return (a * b) / 2 + 3 - 2 * 321;
        }
 
    }

System.CodeDom.Compiler.CompilerParameters parameters = new CompilerParameters();
parameters.GenerateExecutable = false;
parameters.IncludeDebugInformation = false;
parameters.GenerateInMemory = true;
 
System.Resources.ResourceWriter writer = new System.Resources.ResourceWriter("Resources.resx");
writer.AddResource("code.txt", Encoding.ASCII.GetBytes(code));
writer.Generate();
writer.Close();
parameters.EmbeddedResources.Add("Resources.resx");
 
 
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Core.dll");
parameters.ReferencedAssemblies.Add("System.Data.dll");
parameters.ReferencedAssemblies.Add("System.Drawing.dll");
parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
 
parameters.OutputAssembly = DllName;
 
CompilerResults r = CodeDomProvider.CreateProvider("CSharp").CompileAssemblyFromSource(parameters, code);
if (r.Errors.HasErrors == true)
{
    CompilerError err = r.Errors[0];
    MessageBox.Show(string.Format("Line:{0}, Column:{1}, ErrorNumber{2}\r\nMessage:{3}", 

       err.Line.ToString(), err.Column.ToString(), err.ErrorNumber.ToString(), err.ErrorText));
}

string code = string.Empty;
 
if (File.Exists(DllName))
{
    using (AssemblyHelper assem = new AssemblyHelper())
    {
        assem.LoadAssembly(Application.StartupPath + "\\" + DllName);
        code = assem.LoadCode();
    }
}
 
return code;

string code = this.tbCode.Text.Trim().Split('=')[1];
if (string.IsNullOrEmpty(code))
    return;
code = this.tbCode.Text;
 
 
LambdaExpression ex = ExpressionParser.Parse(code, null, this.parameters.ToArray(), 
           "System", "System.Collections.Generic");
 
this.dele = ex.Compile();
 
this.func = (Func<float, float, float>)dele;
 
MessageBox.Show("Success");

Stopwatch sw = Stopwatch.StartNew();
 
float res = 0;
 
for (int i = 0; i < 100000; i++)
{
    if (param == null)
    {
        res = (float)this.dele.DynamicInvoke(null);
    }
    else
    {
        res = (float)this.dele.DynamicInvoke(param);
    }
}
sw.Stop();
 
Console.WriteLine(string.Format("DynamicInvoke : {0}", sw.Elapsed.ToString()), res.ToString());
 
 
sw = Stopwatch.StartNew();
 
for (int i = 0; i < 100000; i++)
{
    res = this.func((float)param[0], (float)param[1]);
}
 
sw.Stop();
 
Console.WriteLine(string.Format("FuncInvoke : {0}", sw.Elapsed.ToString()), res.ToString());
 
sw = Stopwatch.StartNew();
 
for (int i = 0; i < 100000; i++)
{
    res = ((float)param[0] * (float)param[1]) / 2 + 3 - 2 * 321;
}
 
sw.Stop();
 
Console.WriteLine(string.Format("Call : {0}\n", sw.Elapsed.ToString()), res.ToString());

CodeDom의 장점은 변수의 선언 및 복잡한 식의 계산을 쉽게 할 수 있다는 것이다. 단점은 사용자가 C# 언어를 학습 해야 하고, 함수의 네이밍, 메모리 관리 등 개발이 복잡하다는 것이다.

Lambda의 장점은 간편한 식을 작성 할 수 있고, 사용자에게 친숙하고, 함수의 관리가 편하다. 단점은 변수의 선언 및 복잡한 식은 설정하기 어렵다.

object res = null;
DataTable dt = new DataTable();
 
 
string exp = expression;
foreach (KeyValuePair<string, string> item in values)
{
    exp = exp.Replace(item.Key, item.Value);
}
 
Stopwatch st = Stopwatch.StartNew();
for (int i = 0; i < 100000; i++)
{
    res = dt.Compute(exp, null);
    Type type = res.GetType();
 
    if (type == typeof(int))
    {
        int a = (int)res;
    }
    else
    {
        double b = (double)res;
    }
}
st.Stop();
Console.WriteLine(string.Format("DataTable = {0} : {1}", st.Elapsed.ToString(), res.ToString()));

Debug.Assert(0 == new Expression("Sin(0)").Evaluate());

  Debug.Assert(2 == new Expression("Sqrt(4)").Evaluate());

Debug.Assert(0 == new Expression("Tan(0)").Evaluate());

//함수 처리

Expression e = new Expression("SecretOperation(3, 6)");

  e.EvaluateFunction += delegate(string name, FunctionArgs args)

      {

          if (name == "SecretOperation")

              args.Result= (int)args.Parameters[0].Evaluate() + (int)args.Parameters[1].Evaluate();

      };

  Debug.Assert(9 == e.Evaluate());

// 함수 테스트

CalculationEngine engine = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
 
 
context.Variables.Add("a", 2);
context.Variables.Add("b", 2);
 
engine.Add("Func1", "(a*b) + 2.0", context);
 
 
Stopwatch st = Stopwatch.StartNew();
double res = 0;
for (int i = 0; i < 800; i++)
{
    res = engine.GetResult<double>("Func1");
    context.Variables["a"] = 3;
    engine.Recalculate("Func1");
}
st.Stop();
Console.WriteLine(string.Format("FleeFunc = {0} : {1}", st.Elapsed.ToString(), res.ToString()));

ExpressionContext context = new ExpressionContext();
 
double res = double.NaN;
 
context.Variables.Clear();
            
foreach (KeyValuePair<string, string> item in values)
{
    context.Variables[item.Key] = Convert.ToDouble(item.Value);
}
 
IGenericExpression<double> exp = context.CompileGeneric<double>(expression);
 
Stopwatch st = Stopwatch.StartNew();
for (int i = 0; i < 100000; i++)
{
    res = exp.Evaluate();
}
st.Stop();
Console.WriteLine(string.Format("Flee = {0} : {1}", st.Elapsed.ToString(), res.ToString()));

MathParserNet.Parser parser = new MathParserNet.Parser();
 
double res = double.NaN;
parser.RemoveAllVariables();
 
foreach (KeyValuePair<string, string> item in values)
{
    parser.AddVariable(item.Key, item.Value);
}
 
Stopwatch st = Stopwatch.StartNew();
 
for (int i = 0; i < 100000; i++)
{
    MathParserNet.SimplificationReturnValue ret = parser.Simplify(expression);
    if (ret.ReturnType == MathParserNet.SimplificationReturnValue.ReturnTypes.Integer)
    {
        res = ret.IntValue;
    }
    else
    {
        res = ret.DoubleValue;
    }
}
st.Stop();
Console.WriteLine(string.Format("MathParseNet = {0} : {1}", st.Elapsed.ToString(),res.ToString()));