동구의 블로그

AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => {

    String resourceName = “AssemblyLoadingAndReflection.” +

        new AssemblyName(args.Name).Name + “.dll”;

    using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))

    {

        Byte[] assemblyData = new Byte[stream.Length];

        stream.Read(assemblyData, 0, assemblyData.Length);

        return Assembly.Load(assemblyData);

    }

}; 

참조 : https://blogs.msdn.microsoft.com/microsoft_press/2010/02/03/jeffrey-richter-excerpt-2-from-clr-via-c-third-edition/

A.exe

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Reflection;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace DelegateReflaction

{

    public partial class Form1 : Form

    {

        public Form1()

        {

            InitializeComponent();

            InvokeTest();

        }

        private void InvokeTest()

        {

            string dllFilePath = @"D:\Work\Project\Test\DelegateReflaction\TestLibrary\bin\Debug\TestLibrary.dll";

            Assembly assembly = Assembly.LoadFile(dllFilePath);

            Type formType = assembly.GetType("TestLibrary.ChiForm");

            //Child 델리게이트 타입 가져오기

            Type deleType = assembly.GetTypes().Single(a => a.Name == "CallbackDelegate");

            //현재 클래스의 Callback 메서드 정보 가져오기

            MethodInfo callBackMethodInfo = this.GetType().GetMethod("Callback", BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(string) }, null);

            //Child의 CallbackDelegate Delegate를 이용해서 Deleagte 생성

            Delegate callbackMethod = Delegate.CreateDelegate(deleType, this, callBackMethodInfo);

            //Child 폼 생성

            Form form = Activator.CreateInstance(formType) as Form;

            //Child의 DoWork 메서드 가져오기

            MethodInfo doworkMethodInfo = formType.GetMethod("DoWork");

            //파라미터 생성

            object[] parameters = new object[2];

            parameters[0] = "test~";

            parameters[1] = callbackMethod;

            //Child Dowork 메서드 호출

            doworkMethodInfo.Invoke(form, parameters);

            form.Show();

        }

        void Callback(string msg)

        {

            MessageBox.Show(msg);

        }

    }

}

B.dll

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace TestLibrary

{

    public class ChiForm : Form

    {

        public delegate void CallbackDelegate(string status);

        public ChiForm()

        {

            InitializeComponent();

        }

        public void DoWork(string param, CallbackDelegate callback)

        {

            callback("status");

        }

        private void InitializeComponent()

        {

            this.SuspendLayout();

            //

            // ChiForm

            //

            this.ClientSize = new System.Drawing.Size(284, 262);

            this.Name = "ChiForm";

            this.Text = "ChildForm";

            this.ResumeLayout(false);

        }

    }

} 

/// <summary>

    /// Undo와 Redo 내역을 기록하는 클래스

    /// </summary>

    /// <typeparam name="T">기록할 타입</typeparam>

    public class UndoRedoHistory<T>

    {

        const int DefaultUndoCount = 10;

        RimitedStack<T> undoStack;

        RimitedStack<T> redoStack;

        /// <summary>

        /// Undo 기능을 사용할 수 있는지 여부를 가져온다.

        /// </summary>

        public bool IsCanUndo

        {

            get

            {

                //맨 초기 상태때문에 1보다 커야한다.

                return this.undoStack.Count > 1;

            }

        }

        /// <summary>

        /// Redo 기능을 사용할 수 있는지 여부를 가져온다.

        /// </summary>

        public bool IsCanRedo

        {

            get { return this.redoStack.Count > 0; }

        }

        public UndoRedoHistory()

            :this(DefaultUndoCount)

        {

        }

        public UndoRedoHistory(int defaultUndoCount)

        {

            undoStack = new RimitedStack<T>(defaultUndoCount);

            redoStack = new RimitedStack<T>(defaultUndoCount);

        }

        /// <summary>

        /// 이전 상태를 가져온다.

        /// </summary>

        /// <returns></returns>

        public T Undo()

        {

            T state = this.undoStack.Pop();

            this.redoStack.Push(state);

            return this.undoStack.Peek();

        }

        /// <summary>

        /// 이후 상태를 가져온다.

        /// </summary>

        /// <returns></returns>

        public T Redo()

        {

            T state = this.redoStack.Pop();

            this.undoStack.Push(state);

            return state;

        }

        /// <summary>

        /// 상태를 추가한다.

        /// </summary>

        /// <param name="state"></param>

        public void AddState(T state)

        {

            this.undoStack.Push(state);

            this.redoStack.Clear();

        }

        /// <summary>

        /// 상태를 모두 제거한다.

        /// </summary>

        internal void Clear()

        {

            this.undoStack.Clear();

            this.redoStack.Clear();

        }

    }

/// <summary>

/// 개수 제한이 있는 스택 클래스

/// </summary>

internal class LimitedStack<T>

{

    List<T> list = new List<T>();

    readonly int capacity;

    /// <summary>

    /// 개수를 가져온다.

    /// </summary>

    public int Count

    {

        get { return this.list.Count; }

    }

    /// <summary>

    /// 생성자

    /// </summary>

    /// <param name="capacity"></param>

    public LimitedStack(int capacity)

    {

        this.capacity = capacity;

    }

    /// <summary>

    /// 맨위의 개체를 반환하고 제거한다.

    /// </summary>

    /// <returns></returns>

    internal T Pop()

    {

        T t = this.list[0];

        this.list.RemoveAt(0);

        return t;

    }

    /// <summary>

    /// 개체를 맨위에 삽입한다.

    /// </summary>

    /// <param name="state"></param>

    internal void Push(T state)

    {

        this.list.Insert(0, state);

        if (this.list.Count > capacity)

        {

            this.list.RemoveAt(this.list.Count - 1);

        }

    }

    /// <summary>

    /// 맨위의 개체를 제거하지 않고 반환한다.

    /// </summary>

    /// <returns></returns>

    internal T Peek()

    {

        return this.list[0];

    }

    /// <summary>

    /// 개체를 모두 제거한다.

    /// </summary>

    internal void Clear()

    {

        this.list.Clear();

    }

}

public partial class Form1 : Form

{

UndoRedoHistory<string> undoRedoHistory = new UndoRedoHistory<string>(10);

public Form1()

{

    InitializeComponent();

    SaveCurrentState();

    this.textBox1.KeyDown += TextBox1_KeyDown;

}

private void TextBox1_KeyDown(object sender, KeyEventArgs e)

{

    Keys keyData = e.KeyData;

    if ((keyData & Keys.Control) == Keys.Control)

    {

        if ((keyData & Keys.Z) == Keys.Z)

        {

            this.Undo();

        }

        else if ((keyData & Keys.Y) == Keys.Y)

        {

            this.Redo();

        }

    }

}

private void Redo()

{

    if (this.undoRedoHistory.IsCanRedo)

    {

        this.textBox1.Text = this.undoRedoHistory.Redo();

    }

}

private void Undo()

{

    if (this.undoRedoHistory.IsCanUndo)

    {

        this.textBox1.Text = this.undoRedoHistory.Undo();

    }

}

private void btnSave_Click(object sender, EventArgs e)

{

    this.SaveCurrentState();

}

/// <summary>

/// 현재 상태를 저장한다.

/// </summary>

private void SaveCurrentState()

{

    undoRedoHistory.AddState(this.textBox1.Text);

}

/// <summary>

/// 데이터를 수신한다.

/// </summary>

/// <param name="buf">수신할 버퍼</param>

/// <param name="offset">데이터를 저장할 위치</param>

/// <param name="count">데이터 저장 바이트 수</param>

/// <returns></returns>

public int Receive(byte[] buf, int offset, int count)

{

    if (this.serialPort != null)

    {

        int bytesExpected = count, bytesRead = 0;

        while (bytesExpected > 0 && (bytesRead = serialPort.Read(buf, offset, bytesExpected)) > 0)

        {

            offset += bytesRead;

            bytesExpected -= bytesRead;

        }

        return count;

    }

    else

        return 0;

} 

string src = "abcd";

string dest = "ABCD";

int maxIter = 10000;

int matchCount = 0;

Stopwatch sw = Stopwatch.StartNew();

matchCount = 0;

for (int i = 0; i < maxIter; i++)

{

    if (src.ToLower() == dest.ToLower())

        matchCount++;

}

sw.Stop();

if (matchCount != maxIter)

    return;

Console.WriteLine("Lower Equal " + sw.Elapsed.ToString());

sw = Stopwatch.StartNew();

matchCount = 0;

for (int i = 0; i < maxIter; i++)

{

    if (src.ToUpper() == dest.ToUpper())

        matchCount++;

}

sw.Stop();

if (matchCount != maxIter)

    return;

Console.WriteLine("Upper Equal " + sw.Elapsed.ToString());

sw = Stopwatch.StartNew();

matchCount = 0;

for (int i = 0; i < maxIter; i++)

{

    if (src.Equals(dest, StringComparison.InvariantCultureIgnoreCase))

        matchCount++;

}

sw.Stop();

if (matchCount != maxIter)

    return;

Console.WriteLine("StringComparison.Ordinal InvariantCultureIgnoreCase " + sw.Elapsed.ToString());

sw = Stopwatch.StartNew();

matchCount = 0;

for (int i = 0; i < maxIter; i++)

{

    if (src.Equals(dest, StringComparison.CurrentCultureIgnoreCase))

        matchCount++;

}

sw.Stop();

if (matchCount != maxIter)

    return;

Console.WriteLine("StringComparison.Ordinal CurrentCultureIgnoreCase " + sw.Elapsed.ToString());

sw = Stopwatch.StartNew();

matchCount = 0;

for (int i = 0; i < maxIter; i++)

{

    if (src.Equals(dest, StringComparison.OrdinalIgnoreCase))

        matchCount++;

}

sw.Stop();

if (matchCount != maxIter)

    return;

Console.WriteLine("StringComparison.Ordinal OrdinalIgnoreCase " + sw.Elapsed.ToString());

sw = Stopwatch.StartNew();

matchCount = 0;

for (int i = 0; i < maxIter; i++)

{

    if (string.Compare(src, dest, true) == 0)

        matchCount++;

}

sw.Stop();

if (matchCount != maxIter)

    return;

Console.WriteLine("string.Compare Ignore " + sw.Elapsed.ToString());

sw = Stopwatch.StartNew();

matchCount = 0;

for (int i = 0; i < maxIter; i++)

{

    if (string.CompareOrdinal(src.ToLower(), dest.ToLower()) == 0)

        matchCount++;

}

sw.Stop();

if (matchCount != maxIter)

    return;

Console.WriteLine("string.CompareOrdinal ToLower " + sw.Elapsed.ToString());

sw = Stopwatch.StartNew();

matchCount = 0;

for (int i = 0; i < maxIter; i++)

{

    if (string.CompareOrdinal(src.ToUpper(), dest.ToUpper()) == 0)

        matchCount++;

}

sw.Stop();

if (matchCount != maxIter)

    return;

Console.WriteLine("string.CompareOrdinal ToUpper " + sw.Elapsed.ToString());

string.CompareOrdinal ToUpper 00:00:00.0020907
Upper Equal 00:00:00.0016855
StringComparison.Ordinal InvariantCultureIgnoreCase 00:00:00.0011733
StringComparison.Ordinal CurrentCultureIgnoreCase 00:00:00.0017487
StringComparison.Ordinal OrdinalIgnoreCase 00:00:00.0002009
string.Compare Ignore 00:00:00.0017312
string.CompareOrdinal ToLower 00:00:00.0017755
string.CompareOrdinal ToUpper 00:00:00.0020907 

/// <summary>

/// 해당 WorkSheet의 전체 데이터를 가져온다.

/// </summary>

/// <param name="sheet"></param>

/// <returns></returns>

private object[,] GetTotalValue(Worksheet sheet)

{

    //사용중인 범위(한번도 사용하지 않은 범위는 포함되지 않음)

    Range usedRange = sheet.UsedRange;

    //마지막 Cell

    Range lastCell = usedRange.SpecialCells(XlCellType.xlCellTypeLastCell);

    //전체 범위 (왼쪽 상단의 Cell부터 사용한 맨마지막 범위까지)

    Range totalRange = sheet.get_Range(sheet.get_Range("A1"), lastCell);

    return (object[,])totalRange.get_Value();

} 

Sub 컨트롤아이디()
For Each cb In CommandBars
    For Each ctl In cb.Controls
        Cells(Rows.Count, "A").End(3)(2).Resize(, 5) = Array(cb.Name, cb.NameLocal, cb.Visible, ctl.Caption, ctl.ID)
    Next
Next
End Sub 

Application app = Globals.ThisAddIn.Application;

CommandBarButton delRowBtn = app.CommandBars.FindControl(Id: 293) as CommandBarButton;

CommandBarButton insertRowBtn = app.CommandBars.FindControl(Id: 296) as CommandBarButton;

delRowBtn.Visible = true;

delRowBtn.Click += rowDelBtn_Click;

insertRowBtn.Click += insertRowBtn_Click;